domingo, 26 de marzo de 2017

Reactive Programming with Java




Quiero recomendarles este libro que ha publicado de forma gratuita infoQ.

Sin más dejo el link:

https://www.infoq.com/minibooks/emag-reactive-programming-java

Un resumen de Scala for the Impatient, parte 14

Constructor primario

En Scala, todas clases tienen un constructor primario. Y se debe tener en cuenta los siguientes puntos:

1. El constructor principar se representa como los parámetros que van luego del nombre de la clase :

class Person(val name: String, val age: Int) {
// Parameters of primary constructor in (…)

}

Los parámetros del primer constructor son campos que son inicializados en el constructor. En el ejemplo nombre y edad son campos de la persona. El constructor siempre se debe llamar (al menos) con los dos parámetros, esto es equivalente en Java a :

public class Person { // This is Java
      private String name;
      private int age;
     
      public Person(String name, int age) {
            this.name = name;
            this.age = age;
      }

      public String name() { return this.name; }

      public int age() { return this.age; }
      …
}

El constructor primario ejecuta todas las sentencias en la definición de clase. Por ejemplo:

class Person(val name: String, val age: Int) {
      println("Just constructed another person")

      def description = name + " is " + age + " years old"
}

El método println se va a ejecutar cuando el objeto se cree. Esto es útil para cuando se necesita inicializar un campo. Por ejemplo:

class MyProg {
     private val props = new Properties
     props.load(new FileReader("myprog.properties"))
     // The statement above is a part of the primary constructor
     ...
}

Podemos eliminar constructores auxiliares usando parámetros por defecto:

class Person(val name: String = "", val age: Int = 0)

El constructor primario puede recibir variables mutables, inmutables, privadas, publicas …

class Person(val name: String, private var age: Int)

Esto es como declarar los campos de la siguiente manera:

val name: String
private var age: Int

Los parámetros del constructor también pueden ser parámetros de métodos regulares, sin val o var. La forma en que se procesan estos parámetros depende de su uso dentro de la clase.

Si se utiliza un parámetro sin val o var dentro de al menos un método, se convierte en un campo. Por ejemplo:

class Person(name: String, age: Int) {
     def description = name + " is " + age + " years old"
}

Como podemos ver se declara e inicializa los campos inmutables nombre y edad que son privados en el objeto. Esto es equivalente a private[this]

De lo contrario, el parámetro no se guarda como un campo. Es sólo un parámetro regular al que se puede acceder en el código del constructor principal. (Estrictamente hablando, esto es una optimización específica de la implementación.)

Tengamos en cuenta a la hora de definir los parámetros que :

  • sin modificador : Va ser un campo privado si se utiliza en un metodo, de lo contrarío no se va guardar, es decir va vivir solo en el contructor de la clase. Ejemplo: name: String
  • con modificador private: Va ser privado y se van a generar getters y setters privados
  • con val o var: campos privados y getters y setters publicos
  • con @BeanProperty y val o var: campo privado y getters y setters públicos, y también con forma que entienda java. 


martes, 21 de marzo de 2017

Como va el resumen de Scala for the Impatient?


Puff, vamos por la entrega 13 y seguimos (como no). Lo malo es que no encuentro más imágenes de conejos con reloj (tengo miedo que pierda el estilo)

Dejo los links:
http://emanuelpeg.blogspot.com.ar/2016/12/un-resumen-de-scala-for-impatient.html
http://emanuelpeg.blogspot.com.ar/2016/12/un-resumen-de-scala-for-impatient-parte.html
http://emanuelpeg.blogspot.com.ar/2016/12/un-resumen-de-scala-for-impatient-parte_21.html
http://emanuelpeg.blogspot.com.ar/2016/12/un-resumen-de-scala-for-impatient-parte_26.html
http://emanuelpeg.blogspot.com.ar/2016/12/un-resumen-de-scala-for-impatient-parte_30.html
http://emanuelpeg.blogspot.com.ar/2017/01/un-resumen-de-scala-for-impatient-parte.html
http://emanuelpeg.blogspot.com.ar/2017/01/un-resumen-de-scala-for-impatient-parte_15.html
http://emanuelpeg.blogspot.com.ar/2017/02/un-resumen-de-scala-for-impatient-parte.html
http://emanuelpeg.blogspot.com.ar/2017/02/un-resumen-de-scala-for-impatient-parte_17.html
http://emanuelpeg.blogspot.com.ar/2017/02/un-resumen-de-scala-for-impatient-parte_25.html
http://emanuelpeg.blogspot.com.ar/2017/02/un-resumen-de-scala-for-impatient-parte_28.html
http://emanuelpeg.blogspot.com.ar/2017/03/un-resumen-de-scala-for-impatient-parte.html
http://emanuelpeg.blogspot.com.ar/2017/03/un-resumen-de-scala-for-impatient-parte_18.html


sábado, 18 de marzo de 2017

Spark y Scala las tecnologías mejor remuneradas



Haciendo el curso de scala y spark en coursera, me entere que segun Stackoverflow, Spark y Scala las tecnologías mejor remuneradas. Así que mis queridos chichipios, ha estudiar!!

Dejo link: http://stackoverflow.com/insights/survey/2016#technology-top-paying-tech

Un resumen de Scala for the Impatient, parte 13


Campos privados 

En scala (como en java o c++) los métodos pueden acceder a campos privados para todos los objetos de la misma clase:

class Counter {
      private var value = 0
      def increment() { value += 1 }
      def isLess(other : Counter) = value < other.value
      //Puede acceder a metodo privado de un objeto de su misma clase.
}

La expresión other.value es valida porque es el mismo tipo que la clase que contiene le método isLess

Scala permite mayor cantidad de restricciones, con private[this] con este modificador el campo es privado en serio, es decir no es publico para otras instancia de la misma clase.

private[this] var value = 0 // no permite acceso a otra instancia del mismo tipo.

Bean Properties

Como se vio en las secciones anteriores, Scala proporciona métodos getter y setter para los campos que se definen. Sin embargo, los nombres de estos métodos no son lo que las herramientas Java esperan. La especificación JavaBeans (www.oracle.com/technetwork/java/javase/tech/index-jsp-138795.html) define una propiedad Java como un par de métodos getFoo / setFoo (o simplemente un método getFoo para una propiedad de sólo lectura ).

Muchas herramientas Java se basan en esta convención de nomenclatura.

Cuando anote un campo Scala con @BeanProperty, estos métodos son generada automáticamente. Por ejemplo:

import scala.reflect.BeanProperty

class Person {
       @BeanProperty var name: String = _
}

esto genera 4 metodos:
1. name: String
2. name_=(newValue: String): Unit
3. getName(): String
4. setName(newValue: String): Unit

Constructores auxiliares.

Como java y c++, scala permite que los objetos tengan más de un constructor. Sin embargo, una clase Scala tiene un constructor que es más importante que todos los demás, llamado el constructor primario. Además, una clase puede tener cualquier número de constructores auxiliares.

Los constructores auxiliares son muy similares a los constructores en Java o C ++, con sólo dos diferencias:
A los constructores auxiliares se les llama this. (En Java o C ++, los constructores tienen el mismo nombre que la clase, lo cual no es tan conveniente si cambia el nombre de la clase.)
Cada constructor auxiliar debe comenzar con una llamada a un constructor auxiliar previamente definido o al constructor primario.

Aquí hay una clase con dos constructores auxiliares:

class Person {
   private var name = ""
   private var age = 0
 
   def this(name: String) { // Un constructor auxiliar
       this() // Llama al constructor principal
       this.name = name
   }

   def this(name: String, age: Int) { // Otro constructor auxiliar
       this(name) // Llama al otro constructor
       this.age = age
   }
}

Como se puede ver esta clase tiene 3 constructor. El primer constructor es el contructor principal y no espera parametros y luego tenemos 2 constructores auxiliares. De esta forma podemos instanciar esta clase así:

val p1 = new Person // Primary constructor
val p2 = new Person("Fred") // First auxiliary constructor
val p3 = new Person("Fred", 42) // Second auxiliary constructor


jueves, 16 de marzo de 2017

Empezando con Elixir 2


Vamos a seguir aprendiendo Elixir porque me gustan estos, post continuados. 

Elixir tiene varios tipos de colecciones: List, tuples, keywords, maps. Empecemos con listas o list en ingles.

Las listas son colecciones simples de datos que pueden ser de diferente tipo. Y puede contener valores repetidos:

iex> [3.14, :pie, "Apple"]
[3.14, :pie, "Apple"]

Elixir implementa las listas como listas linkeadas. Por esa razón llegar al elemento n tiene complejidad o(n) . Pero es muy eficiente cuando se agregan datos:

iex> list = [3.14, :pie, "Apple"]
[3.14, :pie, "Apple"]
iex> ["π"] ++ list
["π", 3.14, :pie, "Apple"]
iex> list ++ ["Cherry"]
[3.14, :pie, "Apple", "Cherry"]

Si queremos concatenar 2 listas debemos usar el operador ++

iex> [1, 2] ++ [3, 4, 1]
[1, 2, 3, 4, 1]

Podemos quitar elementos o sustraerlos con el operador -- 

iex> [1,2,2,3,2,3] -- [1,2,3,2]
[2, 3]

Con la función hd (head) podemos conocer el comienzo de la lista y con tl (tail) podemos conocer el resto de la lista: 

 iex> hd [3.14, :pie, "Apple"]
3.14
iex> tl [3.14, :pie, "Apple"]
[:pie, "Apple"]

A la vez podemos utilizar pattern matching  y el operador | nos permite asignar los valores: 

iex> [h|t] = [3.14, :pie, "Apple"]
[3.14, :pie, "Apple"]
iex> h
3.14
iex> t
[:pie, "Apple"]

Las tuplas son similares a las listas pero esta estructura se guarda secuencial en memoria por lo que es más rápida a la hora de acceder pero muy lenta cuando queremos insertar un elemento en el medio. 

iex> {3.14, :pie, "Apple"}
{3.14, :pie, "Apple"}

Esto se utiliza mucho cuando necesitamos que una función retorne muchos datos. 

iex> File.read("path/to/existing/file")
{:ok, "... contents ..."}
iex> File.read("path/to/unknown/file")
{:error, :enoent}

Las listas clave/valor y mapas están asociados a las colecciones, es decir listas clave/valor son un tipo de tuplas y esto mejora la performance: 

iex> [foo: "bar", hello: "world"]
[foo: "bar", hello: "world"]
iex> [{:foo, "bar"}, {:hello, "world"}]
[foo: "bar", hello: "world"]

Hay tres características a tener en cuenta: 
  • Las claves son atómicas
  • No se pueden repetir 
  • Y están ordenadas
Por estas razones, las listas clave/valor se utilizan con más frecuencia para pasar opciones a funciones.

Los mapas son un tanto diferentes a las listas clave/valor. En los mapas se puede tener claves de cualquier tipo y las claves no están ordenadas. Para construir un mapa utilizamos %{}

iex> map = %{:foo => "bar", "hello" => :world}
%{:foo => "bar", "hello" => :world}
iex> map[:foo]
"bar"
iex> map["hello"]
:world

En Elixir 1.2 las variables pueden ser claves:

iex> key = "hello"
"hello"
iex> %{key => "world"}
%{"hello" => "world"}

Si se duplica una clave pisa el valor anterior:

iex> %{:foo => "bar", :foo => "hello world"}
%{foo: "hello world"}

Como podemos ver en la salida anterior, existe una sintaxis especial para mapas que contienen sólo claves atómicas:

iex> %{foo: "bar", hello: "world"}
%{foo: "bar", hello: "world"}

iex> %{foo: "bar", hello: "world"} == %{:foo => "bar", :hello => "world"}
true

Otra propiedad interesante de los mapas es que proporcionan su propia sintaxis para actualizar y acceder a las claves atómicas:

iex> map = %{foo: "bar", hello: "world"}
%{foo: "bar", hello: "world"}
iex> %{map | foo: "baz"}
%{foo: "baz", hello: "world"}
iex> map.hello
"world"

Dejo link: https://elixirschool.com/lessons/basics/collections/



Oracle Help Center


Tal vez estoy posteando algo super viejo pero de verdad no lo conocía. Buscando documentación de oracle, me encontré con Oracle Help Center que es un sitio que contiene mucha documentación de todos los productos de Oracle.

Esta muy bueno!!


Dejo link:
http://docs.oracle.com/en/
http://www.oracle.com/pls/db102/portal.portal_db?selected=1

domingo, 12 de marzo de 2017

El gran catálogo de software desarrollado por la NASA ahora está disponible para todos y gratis

No la voy a hacer tan larga, la nasa nos regala su software. Si, si, podes bajar software que hizo la nasa de forma gratuita.


La NASA está liberando gran parte del software que han desarrollado y lo han puesto a disposición de (casi) cualquier persona. El casi es porque debes registrar e indicar para que se va utilizar.

Esta es la tercera vez que la NASA publica software, algo que la agencia ha hecho desde abril de 2014. Este nuevo catálogo de software de la NASA incluye una gran cantidad de programas para todas las plataformas, incluidos iOS y Android.

Dejo link:
https://software.nasa.gov/

Dejo un video:

miércoles, 8 de marzo de 2017

Ceylon 1.3.2 fue liberado!!


El lenguaje diseñado por el amigo Gavin King, llego a su versión 1.3.2 y nos prueba que esta maduro y que tambien esta en todos lados.

Lo que prueba que la industria lo recibió muy bien. Recordemos que su objetivo era modernizar a Java pero no introducir conceptos extraños a java.

Ceylon 1.3.2 es un release menor del lenguaje pero con más de 100 temas cerrados. Esta versión presenta assemblies, que permiten exportar módulos de Ceylon como repositorios de Maven, hace que sea aún más fácil que antes tener un proyecto mixto de Java y Ceylon en Maven, permite la interpolación de cadenas en aserciones e introduce la inicialización perezosa para atributos.

 Esta versión de Ceylon ha sido probada con una amplia variedad de bibliotecas y frameworks Java, incluyendo:

  • Spring Boot,
  • WildFly and WildFly Swarm,
  • Hibernate (JPA),
  • RESTEasy (JAXB and JAX-RS),
  • Weld (CDI) and Guice,
  • Eclipse Equinox, Apache Karaf, and Apache Felix (OSGi),
  • Spark,
  • RxJava
  • JOGL (OpenGL), and
  • Android.
Y las mejoras más importantes son: 


  • Assemblies (archivo .cas)
  • Genera repositorios Maven 
  • Suporta proyerctos mixtos Java and Ceylon 
  • String interpolation en mensajes 
  • Initialización Lazy para atributos marcados para esto
Dejo link: 

Empezando con Elixir


Antes que nada tenemos que instalarlo, eso es fácil y más fácil si se utiliza linux, les dejo la guía de instalación: http://elixir-lang.org/install.html

Ojo antes que antes a leer un poco: http://emanuelpeg.blogspot.com.ar/search/label/Elixir

Si lo instalamos bien al escribir lo siguiente, veremos la versión:

% elixir -v
Erlang/OTP 19 [erts-8.0.2] [source] [64-bit] [smp:4:4] [async-threads:10] [hipe] [kernel-poll:false] [dtrace]

Elixir 1.4.0

Empesemos utilizando el modo interactivo, como para amigarnos con el lenguaje. Para acceder a esto debemos tipear iex en la consola:

 ~ $ iex
Erlang/OTP 18 [erts-7.3] [source] [64-bit] [smp:6:6] [async-threads:10] [kernel-poll:false]

Interactive Elixir (1.1.0-dev) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)>

Y el cursor quedara en espera de comandos y nosotros podemos empezar a jugar!!!

Vamos a probar cosas básicas del lenguaje:

iex> 2+3
5
iex> 2+3 == 5
true
iex> String.length("The quick brown fox jumps over the lazy dog")
43

Veamos los datos básicos:

Integers

iex> 255
255

Podemos usar octales, binarios o hexadecimales:

iex> 0b0110
6
iex> 0o644
420
iex> 0x1F
31

Floats
En Elixir, el número flotante requiere un decimal antes/después del punto y permite usar la notación exponencial.

iex> 3.14
3.14
iex> .14
** (SyntaxError) iex:2: syntax error before: '.'
iex> 1.0e-10
1.0e-10

Booleans
Elixir soporta los valores True y False. Y todo es verdadero excepto false y nil

iex> true
true
iex> false
false

Atoms
Un átomo es una constante cuyo nombre es su valor. Si está familiarizado con Ruby, estos son sinónimos de Símbolos:

iex> :foo
:foo
iex> :foo == :bar
false
Los booleanos verdadero y falso son también los átomos: true y: false respectivamente.

iex> true |> is_atom
true
iex> :true |> is_boolean
true
iex> :true === true
true

Los nombres de los módulos en Elixir son también átomos. MyApp.MyModule es un átomo válido, incluso si aún no se ha declarado dicho módulo.

iex> is_atom(MyApp.MyModule)
true
Los átomos también se utilizan para referenciar módulos de las bibliotecas Erlang, incluidas las importadas.

iex> :crypto.rand_bytes 3
<<23, 104, 108>>

Strings o cadenas.
Las cadenas en Elixir tienen codificación UTF-8 y están envueltas entre comillas dobles:

iex> "Hello"
"Hello"
iex> "dziękuję"
"dziękuję"
Los String soportan espacios en blancos y enters, etc:

iex> "foo
...> bar"
"foo\nbar"
iex> "foo\nbar"
"foo\nbar"

Elixir incluye más tipos de datos complejos.

Operación.

Elixir soporta los operadores básicos como : +, -, *, y "/" .

iex> 2 + 2
4
iex> 2 - 1
1
iex> 2 * 5
10
iex> 10 / 5
2.0

Si necesita división entera o el resto de división, Elixir viene con dos funciones útiles para lograr esto:

iex> div(10, 5)
2
iex> rem(10, 3)
1

Boolean
Elixir provee operadores booleanos: ||, &&, y !

iex> -20 || true
-20
iex> false || 42
42

iex> 42 && true
true
iex> 42 && nil
nil

iex> !42
false
iex> !false
true

Hay tres operadores adicionales cuyo primer argumento debe ser un booleano (verdadero o falso):

iex> true and 42
42
iex> false or true
true
iex> not false
true
iex> 42 and true
** (ArgumentError) argument error: 42
iex> not 42
** (ArgumentError) argument error

Comparación
Elixir provee los operadores para comparar como otros lenguajes:

iex> 1 > 2
false
iex> 1 != 2
true
iex> 2 == 2
true
iex> 2 <= 3
true
Además provee la comparación estricta:  ===:

iex> 2 == 2.0
true
iex> 2 === 2.0
false

Una característica importante de Elixir es que cualquier dos tipos pueden ser comparados; Esto es particularmente útil en la clasificación. No necesitamos memorizar el orden de clasificación, pero es importante estar consciente de el

number < atom < reference < function < port < pid < tuple < map < list < bitstring
Esto puede llevar a algunas comparaciones interesantes, pero válidas, que no puede encontrar en otros Lenguajes:

iex> :hello > 999
true
iex> {:hello, :world} > [1, 2, 3]
false

String Interpolation
Si has usado Ruby o Scala, string interpolation en Elixir te va sonar familiar:

iex> name = "Sean"
iex> "Hello #{name}"
"Hello Sean"

String Concatenation
Para concatenar 2 cadenas utilizamos el operador <> :

iex> name = "Sean"
iex> "Hello " <> name
"Hello Sean"

Este es el primer post de algunos más que nos acerquen a este lenguaje.

Dejo link:



martes, 7 de marzo de 2017

Quien usa Elixir?

Cuando le cuento a alguien las ventajas de usar Elixir, lo primero que me preguntan es quien usa ese lenguaje.

Es decir porque todo el mundo use una rueda cuadrada, no quiere decir que esta bien, pero tengo que reconocer, que un lenguaje de programación tenga muchos programadores es una gran ventaja y además que compañías lo usen y creen frameworks, es muy interesante.

Por lo tanto no está mal pensar en quien usa Elixir, por lo tanto quiero compartir esta página que detalla todas las compañías que lo usan:


https://github.com/doomspork/elixir-companies

domingo, 5 de marzo de 2017

Pipe Operator de Elixir



Hice el curso try Elixir de codescholl y quede asombrado sobre el operador pipe o |> como les guste llamarlo.

Vamos por parte, si no conocen Elixir te recomiendo:
y si queres saber más sobre Elixir: http://emanuelpeg.blogspot.com.ar/search/label/Elixir

En programación funcional y en otros paradigmas también, es común que una función reciba como parámetros el resultado de otra función y así sucesivamente. Lo que nos queda:

foo(bar(baz(new_function(other_function(2)))))

Como pueden ver no es muy legible para estos casos tenemos el operador |> que funciona igual al operador pipe de linux, es decir permite que el resultado de una función sea el primer parámetro de una segunda función.

Por lo tanto nuestro ejemplo nos queda:

other_function(2) |> new_function() |> baz() |> bar() |> foo()

Veamos unos ejemplos: 

iex> "Elixir rocks" |> String.split
["Elixir", "rocks"]


iex> "Elixir rocks" |> String.upcase |> String.split
["ELIXIR", "ROCKS"]


iex> "elixir" |> String.ends_with?("ixir")
true

Dejo link: