Emanuel Goette, alias Crespo

martes, 4 de abril de 2017

Los Creadores de los Lenguajes de Programación mas famosos

Muy buen vídeo que nos muestra a los padres de los lenguajes de programación:

A mi entender falto Smalltalk, Haskell y Scala. Pero es solo mi opinión. Que opinan ustedes??

La curva de aprendizaje en Scala

Me gusto este gráfica por lo tanto lo comparto :D

Muy buena hoja de ruta, solo nos queda estudiar :P

Dejo link:
http://sciabarra.com/blog/scala-learning-curve/

Se encuentran abiertas las inscripciones a los cursos de Gugler 2017

Quiero recomendar los cursos de Gugler que se dictan en la facultad UADER. Pueden hacerlo de forma presencial o distancia.

Hasta el lunes 17 de abril están abiertas las inscripciones para los alumnos y quienes deseen realizar los cursos del primer cuatrimestre que dictará el Laboratorio de Investigación Gugler de nuestra Facultad. La modalidad de cursado de las diferentes propuestas son presenciales y para alumnos de Latinoamérica y España la modalidad es a distancia.

Dejo links:
http://fcyt.uader.edu.ar/web/node/4089
https://inscripciones.gugler.com.ar

sábado, 1 de abril de 2017

Empezando con Elixir 3

Enum

Enum es un conjunto de funciones para interactuar con colecciones. El cual incluya más de 100 funciones.

Si queremos enumerar todas las funciones podemos hacer lo siguiente:

iex(1)> Enum.__info__(:functions) |> Enum.each(fn({function, arity}) -> IO.puts "#{function}/#{arity}" end)
all?/1
all?/2
any?/1
any?/2
at/2
at/3
chunk/2

...

Usando esto, está claro que tenemos una gran cantidad de funcionalidad, y eso es por una razón clara. La enumeración es el núcleo de la programación funcional y es una cosa increíblemente útil.

Veamos algunas funciones importantes :

all? Nos permite saber si todos los elementos de una lista cumplen alguna condición, veamos un ejemplo:

iex> Enum.all?(["foo", "bar", "hello"], fn(s) -> String.length(s) == 3 end)
false

iex> Enum.all?(["foo", "bar", "hello"], fn(s) -> String.length(s) > 1 end)
true

any? Parecido a all? pero retorna true si alguno cumple la condición:

iex> Enum.any?(["foo", "bar", "hello"], fn(s) -> String.length(s) == 5 end)
true

iex> Enum.any?(["foo", "bar"], fn(s) -> String.length(s) == 5 end)
false

chunk, dada una colección retorna un grupo de colecciones con la cantidad de elementos pasada como segundo parámetro.

iex> Enum.chunk([1, 2, 3, 4, 5, 6], 2)

[[1, 2], [3, 4], [5, 6]]

chunk_by igual que chunk pero se dividen las listas a partir de una función.

iex> Enum.chunk_by(["one", "two", "three", "four", "five"], fn(x) -> String.length(x) end)

[["one", "two"], ["three"], ["four", "five"]]

iex> Enum.chunk_by(["one", "two", "three", "four", "five", "six"], fn(x) -> String.length(x) end)

[["one", "two"], ["three"], ["four", "five"], ["six"]]

map_every a veces fragmentar una colección no es suficiente para exactamente lo que pueda necesitar. En este es el caso, map_every puede ser muy útil para modificar sólo los elementos específicos:

iex> Enum.map_every([1, 2, 3, 4], 2, fn x -> x * 2 end)

[2, 2, 6, 4]

each necesitamos iterar toda la colección:

iex> Enum.each(["one", "two", "three"], fn(s) -> IO.puts(s) end)

one

two

three

each retorno al atom :ok

map, aplica una función a una collección retornando una segunda colección:

iex> Enum.map([0, 1, 2, 3], fn(x) -> x - 1 end)

[-1, 0, 1, 2]

min y max, se puede suponer que buscan el minimo y el maximo:

iex> Enum.min([5, 3, 0, -1])

-1

iex> Enum.max([5, 3, 0, -1])

reduce podemos destilar nuestra colección en un solo valor. Para ello, suministramos un acumulador opcional para pasar a nuestra función; Si no se proporciona ningún acumulador, se utiliza el primer valor:

iex> Enum.reduce([1, 2, 3], 10, fn(x, acc) -> x + acc end)

iex> Enum.reduce([1, 2, 3], fn(x, acc) -> x + acc end)

iex> Enum.reduce(["a","b","c"], "1", fn(x,acc)-> x <> acc end)

"cba1"

sort, ordena una colección :

iex> Enum.sort([5, 6, 1, 3, -1, 4])

[-1, 1, 3, 4, 5, 6]

iex> Enum.sort([:foo, "bar", Enum, -1, 4])

[-1, 4, Enum, :foo, "bar"]

opcionalmente podemos pasar por parámetro una función:

# with our function

iex> Enum.sort([%{:val => 4}, %{:val => 1}], fn(x, y) -> x[:val] > y[:val] end)

[%{val: 4}, %{val: 1}]

# without

iex> Enum.sort([%{:count => 4}, %{:count => 1}])

[%{count: 1}, %{count: 4}]

uniq_by, remueve los duplicados:

iex> Enum.uniq_by([1, 2, 3, 2, 1, 1, 1, 1, 1], fn x -> x end)

[1, 2, 3]

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

Resultados de la encuesta 2017 de Stack overflow

Cada año stack overflow realiza una encuesta que va desde tecnología más utilizada, sueldos y si prefieren viaje a las estrellas o guerra de las galaxias.

Son muchísimos datos que me llaman la atención, a medida que vaya leyendo hago posts

Sin más, dejo link:
https://stackoverflow.com/insights/survey/2017

jueves, 30 de marzo de 2017

FaunaDB, Una nueva base de datos temporal, objeto-relacional y distribuida

Leyendo infoQ me encontré con una nueva base de datos llamada FaunaDB. Si, ya se lo que piensas "otra base de dato??!!", y es verdad estamos repletos de base datos.

Los antiguos líderes técnicos de Twitter y Couchbase han creado FaunaDB, una nueva base de datos temporal de propósito general.

Matt Freels, antiguo Director Técnico de los equipos de base de datos de Twitter, junto con Chris Anderson, cofundador de Couchbase, unieron sus fuerzas para liderar la creación de una nueva "base de datos operacional adaptativa" . El resultado es FaunaDB, una base de datos distribuida objeto-relacional que promete escalar linealmente.

FaunaDB es un sistema de CP construido para proporcionar consistencia y tolerancia de partición. Se puede ejecutar a través de múltiples centros de datos y es compatible con el fracaso de una minoría de ellos sin interrupción del servicio. Se puede escalar horizontal y verticalmente, ejecutándose en un ordenador portátil, un servidor, varios servidores localmente o en la nube, incluyendo configuraciones virtualizadas o contenedoras.

Del mismo modo que Datomic, FaunaDB mantiene todas las instancias de un dato, no sobrescribiéndolas, sino creando otras nuevas cuando se realiza una escritura. Esto es útil especialmente cuando se auditan datos, verificando su evolución en el tiempo.

Dejo link:
https://www.infoq.com/news/2017/03/faunadb
https://fauna.com/

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?

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:

https://ceylon-lang.org/blog/2017/03/03/ceylon-1-3-2/

Translate