Translate

jueves, 25 de octubre de 2018

The State of the Octoverse



Github publico el informe anual Octoverse, en el cual se pueden ver datos interesantes de los proyecto. El informe es grande y tiene muchos detalles.

En especial me intereso los lenguajes más utilizados:


No tengo mucho análisis para hacer javascript viene primero y es indiscutido. Y como lenguajes con mayor crecimiento podemos ver como impacto la decisión de Android de dar soporte a Kotlin :



Me llamo la atención no ver a Scala, pero bueno... dejen su opinión.

Dejo link: https://octoverse.github.com/

miércoles, 24 de octubre de 2018

Instalar un master y un nodo con spark.


La idea es instalar un cluster de spark, solo un nodo y un master. 

Primero los dos 2 servers deben verse por medio de ssh para esto sigan este post :  

Luego descargamos spark desde internet: 
wget https://www.apache.org/dyn/closer.lua/spark/spark-2.3.2/spark-2.3.2-bin-hadoop2.7.tgz

Luego desempaquetamos: 

tar -xzvf spark.tar.gz

Luego vamos a conf y copiamos a el template de spark-env pero sin ".template"

cp spark-env.sh.template spark-env.sh

Luego editamos spark-env y agregamos el java home y el ip del master : 

export JAVA_HOME=/path/java-openjdk

export SPARK_MASTER_HOST='xx.xx.xx.xx'

En SPARK_MASTER_HOST va la ip del master (esto hay que hacerlo en los dos servers)

Por ultimo levantamos todos los servicios :

$ ./start-all.sh 

Y listo! Podemos chequear su funcionamiento en el puerto 8080 del master : 


Correr una tarea en un cluster de spark.


Hemos hecho un proyecto con Spark  el cual cuenta palabras pero este utiliza spark como "local" es decir no utiliza un cluster spark.

Pero la potencia de Spark esta en utilizar esto en un Cluster para lo que tenemos que modificar nuestro Context para que permita ejecutar esto en el cluster.

Un cluster Spark tiene un master el cual tiene una ip por ejemplo x.x.x.x con dicha ip vamos a modificar el Context de Spark:

package com.myCompania.app

import org.apache.spark.{SparkConf, SparkContext}

object SparkContext {

  //Create a SparkContext to initialize Spark
  val conf = new SparkConf()
 
  conf.setMaster("spark://x.x.x.x:7077")
  conf.setJars(Seq("path/nombreDelJar.jar"))

  conf.setAppName("Hexacta")
  val sc = new SparkContext(conf)

   def getSc = {
      sc
   }
}

En el puerto 7077 spark publica su servicio, por dicha razon escribimos esta linea:

conf.setMaster("spark://x.x.x.x:7077")

Luego tenemos que agregar el jar de nuestra aplicación porque spark no conoce las clases que utilizamos, y esto lo hacemos con :

conf.setJars(Seq("path/nombreDelJar.jar"))

Y listo!!

domingo, 21 de octubre de 2018

Jugando con Lisp y Racket

Hace rato que no juego con lisp, por lo tanto vamos a hacer una pequeña función para contar elementos de una lista:

(defun contar(lista)
  (cond
     ((null lista) 0)
     (T (+ 1 (contar (rest lista))))
  )
)

Si probamos esto:

CL-USER 1 > (contar '(1 2 3 4 5))
5

Veamos el mismo programa en Racket: 

(define (contar lista)
  (cond
     [(empty? lista) 0]
     [else (+ 1 (contar (rest lista)))] 
  )
)

> (contar (list 1 2 3))
3

Como se puede ver Racket es un hijo o nietos de lisp, por ende tienen la misma sintasis.  

¿Que letra del abecedario no se utilizo en un nombre de un lenguaje de programación?

Leyendo la lista de lenguajes de programación de wikipedia me percate de que había una letra que faltaba.

Esa letra en nuestra querida Ñ. Lo cual indica la falta de latinos en el diseño de nuevos lenguajes de programación.

No quiero ponerme critico de nuestra condición de hispano hablantes y nuestra educación. Ya que hay muchos sectores de las ciencias de la programación que esta copadas por latinos. Pero claramente faltan empresas o emprendedores que se identifiquen con nuestra cultura.

Vamos por un ñ++ !!

Dejo el link: https://en.wikipedia.org/wiki/List_of_programming_languages

miércoles, 17 de octubre de 2018

Cstar, una herramienta de orquestación de clusters Apache Cassandra


Spotify libero Cstar que es una herramienta de código abierto, basada en linea de comandos para la orquestación de clusters Apache Cassandra.

Trabajar con Cassandra no siempre es una tarea fácil. Tiene una gran cantidad de parametros que afectan el rendimiento, la seguridad, la consistencia de los datos, etc. Muy a menudo necesita ejecutar un conjunto específico de comandos de shell en cada nodo de un clúster, generalmente en cierta coordinación para evitar que el clúster se desactive. Esto se puede hacer manualmente para grupos pequeños, pero puede ser complicado y llevar mucho tiempo para grupos grandes.

Durante 2017, Spotify alcanzó 3000 nodos de Cassandra, por lo que era cada vez más urgente contar con una solución segura y eficiente para tareas de mantenimiento.

Por lo tanto Spotify desarrollo Cstar. Cstar es una herramienta de línea de consola que ejecuta una secuencia de comandos arbitraria en todos los hosts en un clúster de Cassandra en "forma topológica". Se basa en paramiko, la misma implementación ssh/scp que utiliza Fabric.

Cstar soporta los siguientes mecanismos de ejecución:

  • ONE: El script se ejecuta exactamente en un nodo por centro de datos en ese momento.
  • TOPOLOGY: Tantos nodos al mismo tiempo como lo permita la topología de Cassandra. Es decir, no se ejecutará en dos nodos en el mismo centro de datos si una réplica puede estar en ambos nodos. Si tiene N centros de datos con M nodos cada uno y un factor de replicación de X, esto ejecutará efectivamente el script en los nodos M / X * N en ese momento.
  • All: El script se ejecuta en todos los nodos al mismo tiempo, independientemente de la topología.


Dejo links: https://github.com/spotify/cstar
https://labs.spotify.com/2018/09/04/introducing-cstar-the-spotify-cassandra-orchestration-tool-now-open-source/

lunes, 15 de octubre de 2018

Corriendo Python en el browser con Brython


Brython está diseñado para reemplazar Javascript como el lenguaje de scripting para la Web. Como tal, es una implementación de Python 3 adaptada al entorno HTML5, es decir, con una interfaz para los objetos y eventos DOM.

El objetivo de Brython es reemplazar Javascript con Python, como el lenguaje de scripting para los navegadores web.

Veamos un ejemplo:

<html>
<head>
<script src="/brython.js"></script>
</head>
<body onload="brython()">
<script type="text/python">
from browser import document, alert

# bind event 'click' on button to function echo

def echo(ev):
    alert(document["zone"].value)

document["mybutton"].bind("click", echo)
</script>
<input id="zone">
<button id="mybutton">click !</button>
</body>
</html>

Dicha pagina imprime con un alert el texto que se encuentra en el input cuando hacemos click.

Para que el script de Python sea procesado, es necesario incluir brython.js y ejecutar la función brython () al cargar la página (usando el atributo onload de la etiqueta <BODY>).

Si el programa de Python es grande, otra opción es escribirlo en un archivo separado y cargarlo usando el atributo src de la etiqueta de script:

<html>

<head>
<script src="/brython.js"></script>
</head>

<body onload="brython()">
<script type="text/python" src="test.py"></script>
<input id="zone" autocomplete="off">
<button id="mybutton">click!</button>
</body>

</html>


Dejo link: https://brython.info

domingo, 14 de octubre de 2018

Helidon un framework para microservicios



Oracle ha introducido un nuevo framework de código abierto, Project Helidon, una colección de bibliotecas Java diseñadas para crear aplicaciones basadas en microservicios.

Originalmente llamado J4C (Java para la nube), Helidon fue diseñado para ser simple y rápido, y se compone de dos versiones: Helidon SE y Helidon MP. Helidon SE presenta tres API básicas para crear un microservicio (un servidor web, configuración y seguridad) para crear aplicaciones basadas en microservicios. No se requiere un servidor de aplicaciones. Helidon MP admite la especificación MicroProfile 1.1 para crear aplicaciones basadas en microservicios.

Inspirado por NodeJS y otros frameworks de Java, el servidor web de Helidon es una API asíncrona y reactiva que se ejecuta sobre Netty. La interfaz del servidor web incluye soporte para configuración, enrutamiento, manejo de errores y creación de métricas.

Vamos un ejemplo:

// starts the server on a random available port
public void startWebServerUsingRandomPort() throws Exception {
    WebServer webServer = WebServer
           .create(Routing.builder()
                   .any((req,res) -> res.send("It works!" + "\n"))
                   .build())
           .start()
           .toCompletableFuture()
           .get(10,TimeUnit.SECONDS);
    System.out.println("Server started at: http://localhost:" + webServer.port() + "\n");
    webServer.shutdown().toCompletableFuture();
    }

Config, carga y procesa las propiedades de configuración en formato clave/valor. De forma predeterminada, las propiedades de configuración se leerán desde un archivo application.properties o application.yaml definido ubicado en el directorio /src/main/resources.

// application.yaml
server:
 port: 8080
 host: 0.0.0.0

// starts the server on a port defined in application.yaml
public void startWebServerUsingDefinedPort() throws Exception {
    Config config = Config.create();
    ServerConfiguration serverConfig = ServerConfiguration.fromConfig(config.get("server"));
    WebServer webServer = WebServer
           .create(serverConfig,Routing.builder()
                   .any((req,res) -> res.send("It works!" + "\n"))
                   .build())
           .start()
           .toCompletableFuture()
           .get(10,TimeUnit.SECONDS);
    System.out.println("Server started at: http://localhost:" + webServer.port() + "\n");
    webServer.shutdown().toCompletableFuture();
    }

La verdad es que esta muy bueno y le da un aire nuevo a Java

Dejo link:
https://helidon.io/#/

jueves, 11 de octubre de 2018

Apache Jena

Si estas interesado sobre la web semantica o ontologías. Te tiene que sonar Apache Jena. Jena esta hecho en Java es de código abierto y gratuito y permite crear aplicaciones de Web Semántica y Linked Data.

Para consultar ontologías RDF utiliza SPARQL que es un acrónimo recursivo del inglés SPARQL Protocol and RDF Query Language. SPARQL se trata de un lenguaje estandarizado para la consulta de grafos RDF, normalizado por el RDF Data Access Working Group (DAWG) del World Wide Web Consortium (W3C). Es una tecnología clave en el desarrollo de la web semántica.

Si instalamos Apache Jena cuenta con varias herramientas una interesante es Fuseki el cual es un servidor de SPARQL y vamos a tener una aplicación web que permite hacer consultas SPARQL en una ontología RDF que debemos importar como modelo.

Dejo link: https://jena.apache.org/

martes, 9 de octubre de 2018

Nitrux y Nomad Desktop, linux con sabor a Mac


Existen muchas distros de linux que emulan la estética mac como Pear Os o Elementary Os. Siguiendo la misma estética se encuentra Nitrux, cuyo desarrollo continúa y cada vez se acerca más a lograr su primera versión estable.

Sin más les comparto un video :




Dejo link:
https://nxos.org/

domingo, 7 de octubre de 2018

Los 5 cursos gratuitos de programación en R


Si queremos aprender una tecnología nueva lo mejor es empezar por un libro o un curso y luego ir a tutoriales de internet. Saltar de tutorial en tutorial, nos da el conocimiento pero nos falta el orden. Con un curso o un libro aprendemos ordenadamente, como debe ser.

Por lo tanto dejo 5 cursos gratuitos de R :

Insertar datos en Apache HBase con Scala y Scalatra


Vamos hacer un ejemplo de una API Rest con scalatra que inserte datos en HBase.

Primero hacemos un proyecto en scalatra como ya hemos explicado:
https://emanuelpeg.blogspot.com/2018/08/haciendo-un-proyecto-con-scalatra.html

Luego agregamos las dependencias de hbase, en el archivo build.sbt agregando :

libraryDependencies ++= Seq(
  "org.apache.hbase" % "hbase-common" % "2.1.0" ,
  "org.apache.hbase" % "hbase-client" % "2.1.0"
)

Luego en la clase de ejemplo generamos el método get que inserta datos en la base hbase :

 get(s"/guardar/:rowKey/:str") {

    val conf : Configuration = HBaseConfiguration.create()
    // Se debe agregar en el archivo host el nombre de la base
    conf.set("hbase.zookeeper.quorum", "mybase")
    conf.set("hbase.zookeeper.property.clientPort", "2181")

    // seteamos los puertos de hbase.
    conf.set("hbase.master.port", "60000")
    conf.set("hbase.master.info.port", "60010")
    conf.set("hbase.regionserver.info.port", "60030")
    conf.set("hbase.regionserver.port", "60020")
    // cree la tabla
    // create 'TableTest', 'info'
    // put 'TableTest', 'rowkey1', 'info:test', 'ejemplo'
    val connection = ConnectionFactory.createConnection(conf)
    val table = connection.getTable(TableName.valueOf( "TableTest" ) )

    // Put example
    val put = new Put(Bytes.toBytes(params("rowKey")))
    put.addColumn(Bytes.toBytes("info"), Bytes.toBytes("test"), Bytes.toBytes(params("str")))

    table.put(put)

    Ok("ok")
  }

}

El método inserta los datos pasados por parámetro en la URL. Donde pasamos una key y un dato. De esta manera insertamos datos en una tabla TableTest.

Algo importante que se puede ver es que seteo los puestos dado que en las ultimas versiones cambiaron de  600X0 a 160X0. Depende de la versión de Hbase, hay que usar uno u otro, yo estoy usando HBase de la maquina virtual de cloudera.

Y Listo!!



sábado, 6 de octubre de 2018

Haciendo magia con Haxe!

Haxe es un lenguaje de programación multiplataforma de alto nivel, de código abierto y compilador que puede producir código fuente para distintas plataformas desde un único código fuente. El código escrito en Haxe puede ser compilado a código fuente en Adobe Flash, Javascript, Lua, Python, C++, C#, Hashlink,​ Java y Neko y de lado del servidor en PHP,​ Apache CGI y Node.js.

Haxe incluye un conjunto de funcionalidades comunes que son compatibles con todas las plataformas, como tipos de datos numéricos, texto, arrays, binarios y otros formatos de archivos comunes. Haxe también incluye APIs exclusivas de las plataformas, pero a partir de 2012, sólo admite un subconjunto de las funciones disponibles en cada plataforma, y solo la API de Flash es totalmente utilizable.

Haxe fue desarrollado por Nicolas Cannasse y otros colaboradores

Veamos un ejemplo de haxe :

class Test {
    static function main() {
        var people = [
            "Elizabeth" => "Programming",
            "Joel" => "Design"
        ];
       
        for (name in people.keys()) {
            var job = people[name];
            trace('$name does $job for a living!');
        }
    }
}

Par instalarlo en versiones ubuntus solo tienes que hacer :

sudo add-apt-repository ppa:haxe/releases -y
sudo apt-get update
sudo apt-get install haxe -y
mkdir ~/haxelib && haxelib setup ~/haxelib

Vamos hacer un hola mundo y luego lo traducimos a javascript.

Escribimos un archivo llamado "Hola.hx" :

$ nano Hola.hx

y escribimos:

class Hola {
    static public function main() {
        trace("hola!!");
    }
}

guardamos y salimos.

Ahora vamos a generar hola.js :

$ haxe -main Hola -js Hola.js

y si hacemos un cat de Hola.js : 

 $ cat Hola.js 
// Generated by Haxe 3.4.7
(function () { "use strict";
var Hola = function() { };
Hola.main = function() {
console.log("Hello World");
};
Hola.main();
})();

Ahora a PHP: 
haxe -main Hola -php Hola.php

En php nos genera todo un directorio con archivos. 

Dejo link: https://haxe.org/

miércoles, 3 de octubre de 2018

¿Cuáles son los mejores lenguajes que se ejecutan en la JVM?


Quiero compartir este ranking de lenguajes que corren en la JVM. Al parecer viene ganando Kotlin, claramente ayudado por android.

Lo que me sorprende es que en segundo lugar este Clojure, es una grata sorpresa.  Sin más...

Dejo link: https://www.slant.co/topics/397/~best-languages-that-run-on-the-jvm


domingo, 30 de septiembre de 2018

Oxygene

Oxygene (anteriormente conocido como Chrome) es un lenguaje de programación desarrollado por RemObjects Software para Common Language Infrastructure de Microsoft, Java Platform y Cocoa. Oxygene está basado en Object Pascal, pero también tiene influencias de C#, Eiffel, Java, F# y otros lenguajes.

En comparación con Delphi.NET, ahora obsoleto, Oxygene no enfatiza la compatibilidad total hacia atrás, sino que está diseñado para ser una "reinvención" del lenguaje y aprovechar todas las características y tecnologías proporcionadas por el runtimes de .NET y Java.

Oxygene es un producto comercial, y ofrece integración completa en Visual Studio IDE de Microsoft en Windows, así como su propio IDE, Fire para uso en macOS. El compilador de línea de comandos está disponible gratis.

Oxygene no usa "Unidades" como Delphi, pero usa .NET-namespaces para organizar y agrupar tipos. Un espacio de nombre puede abarcar varios archivos (y ensamblajes), pero un archivo solo puede contener tipos de un espacio de nombres. Este espacio de nombre se define en la parte superior del archivo:

namespace ConsoleApplication1;

Los archivos Oxygene están separados en una interfaz y una sección de implementación, que es la estructura conocida de Delphi. La sección de interfaz sigue a la declaración del espacio de nombres. Contiene la cláusula uses, que en Oxygene importa tipos de otros espacios de nombres:

uses
  System.Linq;

Los espacios de nombres importados deben estar en el proyecto mismo o en los ensamblados a los que se hace referencia.

Siguiendo la cláusula uses un archivo contiene declaraciones de tipo, como se conocen de Delphi:

interface

type
  ConsoleApp = class
  public
    class method Main;
  end;

Al igual que en C#, el método principal es el punto de entrada para cada programa. Puede tener un parámetro args: Array of String para pasar argumentos de línea de comando al programa.

Se pueden declarar más tipos sin repetir la palabra clave type.

La implementación de los métodos declarados se ubica en la sección de implementación:

implementation

class method ConsoleApp.Main;
begin
  Console.WriteLine('Hola');
end;

end.

Por último veamos el ejemplo "hola mundo" completo:

namespace HelloWorld;

interface

type
  HelloClass = class
  public
    class method Main;
  end;

implementation

class method HelloClass.Main;
begin
  System.Console.WriteLine('Hello World!');
end;

end.

La verdad no me gusta nada, soy más proclive a escribir menos y tal vez muchas cosas se pueden resolver por convención. Pero confieso que el espíritu de revivir a pascal es muy bueno, dado que era un lenguaje muy bueno y fácil de usar. 

Dejo link: https://www.elementscompiler.com/elements/oxygene/language.aspx