miércoles, 26 de abril de 2017

Scala exercises


Queres aprender scala? y divertirte??

Este sitio es para vos!!

Scala exercises permite ingresar con un usuario de github y podes realizar ejercicios que te permite aprender Scala, si! y de forma gratuita!!

Dejo link: https://www.scala-exercises.org


GitLab



GitLab es un sistema web para administración de nuestros repositorios GIT. Entre mucas características podemos nombras que trae con sigo una wiki y un sistema de seguimientos de bugs. Además es open source y fue desarrollado por GITlab inc.

Con todas esas ventajas no es de extrañar que sea usado por IBM, Sony, Jülich Research Center, NASA, Alibaba, Invincea, O’Reilly Media, Leibniz-Rechenzentrum (LRZ) y CERN.

La versión se puede bajar y instalar de forma gratuita pero a la vez trae una versión de pago.

La verdad que me toco usarlo y es por demás recomendable.

Dejo link: https://about.gitlab.com/

viernes, 21 de abril de 2017

Openlibra


Que bueno que esta openlibra. Para el que no conoce Openlibra es una biblioteca open source, donde se comparten libros y podes descargarlo de forma gratuita.

Se pueden encontrar libros de diferentes temas, si lo que te interesa es la ciencia de computación o informática, este sitio no te va a defraudar. Es muy bueno!!

Entre los temas que podes encontrar tenemos: programación, base de datos, open source, arduino, matemática, libro de metodología, etc.

Muy recomendado!!

Dejo link:
https://openlibra.com/


miércoles, 19 de abril de 2017

Scala vs Kotlin

Estoy viendo un tutorial de kotlin, igual ya antes había leído algo pero muy poco. Muy bueno este lenguaje, pero me llamo la atención que es muy similar a Scala.

Para nombrar algunas cosas una función en scala es algo así:

def suma(a : Int, b: Int) : Int = a + b

y en kotlin algo así:

fun suma(a : Int, b: Int) : Int = a + b

Similar no?

Como pueden probar esto? en scala:

object HelloWorld {
   
  def suma(a : Int, b: Int) : Int = a + b
   
   def main(args: Array[String]) {
      println(suma(2,3))
   }
}

y en kotlin:

fun suma(a : Int, b: Int) : Int = a + b

fun main(args: Array<String>) {
    println(suma(2,3))
}

Soy yo o son parecidos.

Bueno, estuve leyendo una comparación que indica que no tiene Kotlin y scala comparando uno con él otro. Lo malo es que fue escrito por la gente de Kotlin por lo que deja un poco mal parado a scala.

Dejo link:
https://kotlinlang.org/docs/reference/comparison-to-scala.html


sábado, 15 de abril de 2017

Un resumen de Scala for the Impatient, parte 16


Objetos

scala no tiene campos o métodos estáticos, en cambio se pueden usar los objetos. Estos son objetos que solo tienen una instancia (similar a los singletons) y contienen atributos y métodos. Veamos un ejemplo:

object Accounts {
private var lastNumber = 0
def newUniqueNumber() = { lastNumber += 1; lastNumber }
}

Cuando necesita una único numero de cuenta puede llamar a Accounts.newUniqueNumber()

El constructor de un objeto es ejecutado cuando el objeto es utilizado por primera vez. En el ejemplo el constructor es ejecutado cuando se llame Accounts.newUniqueNumber(). Si este objeto no es utilizado, el constructor no es ejecutado.

Se debería utilizar objetos de scala cuando en java o c++ usábamos singleton.
Esto tiene mayores utilidades que los singletons y es más facil de usar :
  • Se puede utilizar como una clase útil que contiene funciones.
  • No tenemos los problemas del singleton, cuando quiere ser accedido por varios hilos.
  • Se puede utilizar para exponer servicios.

Objetos compañeros.

En Java o c++ podemos poner en la misma clase métodos y propiedades y/o métodos y propiedades estáticas. Pero en scala esto no es posible, por lo tanto podemos hacer objetos con el mismo nombre de la clase y este va contener métodos y propiedades de forma que funcionen como si fueran estáticos.

class Account {
val id = Account.newUniqueNumber()
private var balance = 0.0
def deposit(amount: Double) { balance += amount }
...
}

object Account { // The companion object
private var lastNumber = 0
private def newUniqueNumber() = { lastNumber += 1; lastNumber }
}

El objeto y la clase pueden acceder a propiedades privadas pero deben estar en el mismo archivo.

Objetos que extienden de una Clase o un Rasgo (Trait)

Un objeto puede extender de una clase o uno o más Rasgos o Traits. El resultado es un objeto de una clase que extiende la clase dada y / o rasgos, y además tiene todas las características especificadas en la definición del objeto.

Una aplicación útil es especificar objetos predeterminados que se pueden compartir. Por ejemplo, considere una clase para acciones que se pueden deshacer en un programa.

abstract class UndoableAction(val description: String) {
def undo(): Unit
def redo(): Unit
}

Por defecto el objeto que no hace nada, puede ser un objeto ya que no debemos instanciarlo varias veces:

object DoNothingAction extends UndoableAction("Do nothing") {
override def undo() {}
override def redo() {}
}

DoNothingAction puede ser usado como acción por defecto.



viernes, 14 de abril de 2017

Sequel, un orm para Ruby

Sequel es un ORM para ruby, con todas las ventajas de un ORM y las ventajas que da un lenguaje como Ruby.

  • Sequel proporciona seguridad de subprocesos, agrupación de conexiones y un DSL conciso para la construcción de consultas SQL y esquemas de tabla.
  • Sequel incluye una capa completa de ORM para mapeos de tablas a objetos Ruby.
  • Sequel es compatible con funciones de base de datos avanzadas como sentencias, variables enlazadas, procedimientos almacenados, confirmación de dos fases, aislamiento de transacciones y fragmentación de bases de datos.
  • Actualmente, Sequel tiene adaptadores para ADO, Amalgalite, IBM_DB, JDBC, MySQL, Mysql2, ODBC, Oracle, PostgreSQL, SQLAnywhere, SQLite3 y TinyTDS.
Veamos un ejemplo de creación de tabla y inserción: 


require "rubygems"
require "sequel"

# connect to an in-memory database
DB = Sequel.sqlite

# create an items table
DB.create_table :items do
  primary_key :id
  String :name
  Float :price
end

# create a dataset from the items table
items = DB[:items]

# populate the table
items.insert(:name => 'abc', :price => rand * 100)
items.insert(:name => 'def', :price => rand * 100)
items.insert(:name => 'ghi', :price => rand * 100)

# print out the number of records
puts "Item count: #{items.count}"

# print out the average price
puts "The average price is: #{items.avg(:price)}"


Try docker


Codeschool ha lanzado un nuevo curso, esta vez sobre docker.

Para que no sabe que es docker:  Docker es un proyecto de código abierto que automatiza el despliegue de aplicaciones dentro de contenedores de software, proporcionando una capa adicional de abstracción y automatización de Virtualización a nivel de sistema operativo en Linux. Docker utiliza características de aislamiento de recursos del kernel de Linux, tales como cgroups y espacios de nombres (namespaces) para permitir que "contenedores" independientes se ejecuten dentro de una sola instancia de Linux, evitando la sobrecarga de iniciar y mantener máquinas virtuales.

En conclusión docker es el futuro en deployments por lo tanto, estaría bueno que hagas este curso.

Sin más dejo la info:

Try Docker
Dive into the basics of Docker and learn how to create a self-contained, shareable development environment with containers, images, Dockerfiles, and volumes.
View the Course
What You'll Learn

Level 1: Containers & Images
Learn how to use images to create Docker containers.                  

Level 2: Dockerfiles
Use Dockerfiles to configure images in a centralized and repeatable way.

Level 3: Volumes
Take control of the data in your containers with volumes.                  
Why Learn Docker?
Course Instructor Jon Friskics explains how Docker can make your development workflow more efficient.

martes, 11 de abril de 2017

Curso de Kotlin Gratis

Se pueden encontrar muchísimos cursos de programación pero de un lenguaje moderno en castellano, es raro.

Les quiero recomendar este curso de Kotlin en castellano:




Dejo link: 

sábado, 8 de abril de 2017

Phoenix el poderoso framework de elixir





Si están prendidos con los post sobre Elixir, les va interesar leer el siguiente post (que no es mio) de Phoenix que es un framework de Elixir.

Sin más dejo el link:
http://backtrackacademy.com/articulo/conoce-phoenix-el-poderoso-framework-de-elixir

Un resumen de Scala for the Impatient, parte 15



Nested Classes

En Scala se puede definir una función dentro de una función o una clase dentro de otra clase: 

import scala.collection.mutable.ArrayBuffer 
class Network { 
class Member(val name: String) { 
val contacts = new ArrayBuffer[Member] 

private val members = new ArrayBuffer[Member] 

def join(name: String) = { 
val m = new Member(name) 
members += m 
}

Supongamos que tenemos 2 Networks: 

val chatter = new Network 
val myFace = new Network

Cada instancia tiene una definición de clase por lo tanto la clase Member de chatter no es igual a la clase Member de myFace. 

En nuestro ejemplo una instancia de Member puede ser agregado a diferentes redes: 

val fred = chatter.join("Fred") 
val wilma = chatter.join("Wilma") 
fred.contacts += wilma // OK 
val barney = myFace.join("Barney") // es de tipo myFace.Member 
fred.contacts += barney // No porque son de diferente tipo

Ante este comportamiento hay 2 posibilidades: 

1.Se puede mover Member a otra clase o a algún objeto. Por ejemplo: 

object Network { 
class Member(val name: String) { 
val contacts = new ArrayBuffer[Member] 
}

class Network { 
private val members = new ArrayBuffer[Network.Member] 
... 
}

2. Se puede utilizar type projection, que permite utilizar una subclase en varias instancias. Network#Member esto significa Member es un subtipo y esta en la clase Network y no es una clase de la instancia.

class Network { 
class Member(val name: String) { 
val contacts = new ArrayBuffer[Network#Member] 
... 
}

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])
5

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)
16

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

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]





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?


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: 

Google ofrece cursos gratuitos, con certificación y en español


Solamente quiero hacerme eco de esta noticia que lei en un blog.

El programa “Actívate” busca mejorar las competencias digitales de los usuarios como también de quienes manejan pequeñas y grandes empresas. Google en colaboración con universidades e instituciones de España ofrecen siete cursos gratuitos de manera online, estos van desde marketing hasta productividad personal. Todos los cursos cuentan con certificación.

Dejo link:
https://www.azulweb.net/google-ofrece-cursos-gratuitos-certificacion-espanol/?utm_campaign=arteprogra&utm_medium=facebook&utm_source=030317

sábado, 4 de marzo de 2017

Un resumen de Scala for the Impatient, parte 12

Zipping

Una de las razones para utilizar tuplas, es porque podemos procesar un conjunto de elementos de distinto tipo, todos juntos. Esto es común cuando utilizamos el método zip:

val symbols = Array("<", "-", ">")
val counts = Array(2, 10, 2)
val pairs = symbols.zip(counts)

y esto retornara pares de la siguiente forma:

Array(("<", 2), ("-", 10), (">", 2))

Luego estos pares se pueden procesar juntos:

for ((s, n) <- pairs) Console.print(s * n) // Prints <<---------->>

Algo que podemos hacer es luego pasar este par a un mapa con el método toMap :

keys.zip(values).toMap

Clases

Es hora de hablar de clases, para el que no esta muy interiorizado con la programación orientada a objetos, le recomiendo que lea algo de teoría de objetos antes de seguir.

Scala cuenta con una estructura para definir clases como java o c++. Pero un tanto más moderna y nos simplifica bastante las escritura.

class Counter {
  private var value = 0 // Se deben inicializar los valores
  def increment() { value += 1 } // Métodos por defecto son públicos
  def current() = value
}

En Scala no es necesario indicar que una clase es publicas. Un archivo puede contener muchas clases y estas son todas publicas.

Si queremos utilizar la clase declarada lo podemos hacer:

val myCounter = new Counter // o new Counter()
myCounter.increment()
println(myCounter.current)

Se pueden llamar los métodos sin parámetros con paréntesis o sin paréntesis:

myCounter.current // OK
myCounter.current() // también esta bien

Cual es la mejor forma? Por conversión se indica que se utilicen los paréntesis cuando el método modifica un valor, si es un simple método para acceder a un valor no es necesario. Como lo usamos anteriormente:

myCounter.increment() //modifica el valor
println(myCounter.current) // solo accede

Se puede forzar a no utilizar parentesis en los metodos de la siguiente manera:

class Counter {
def current = value // El metodo no es definido con ()
}

Ahora el método current debe ser usado sin parentesis

Propiedades getter y setters

En Java necesitamos declarar métodos que nos permitan acceder a nuestros atributos privados:

public class Person { // Esto es Java
  private int age = 0;
  public int getAge() { return age; }
  public void setAge(int age) { this.age = age; }
}

Porque es mejor esto que hacer publico age? Porque podemos indicar restricciones, por ejemplo si no queremos que la persona pueda ser más joven:

public void setAge(int newValue) { if (newValue > age) age = newValue; }

Como se puede ver es mucho mejor usar métodos getters y setters que hacer públicos los atributos de una clase.

Scala provee métodos getters y setters para los campos, aquí podemos ver una definición de un campo publico:

class Person {
  var age = 0
}

Scala genera una clase para la JVM con un atributo privado y métodos getter y setter públicos, si declaramos este atributo privado va a generar métodos getter y setter privados.

En scala los métodos son llamados age y age_= , de esta manera si hacemos:

println(fred.age) // Llama al metodo fred.age()
fred.age = 21 // Llama al metodo fred.age_=(21)

Esto es mucho mejor que tener atributos privados, porque podemos redefinir estos métodos:

class Person {
private var privateAge = 0 // hacemos privado a la edad y la renombramos.

def age = privateAge
def age_=(newValue: Int) {
if (newValue > privateAge) privateAge = newValue; // No puede ser más joven
}

Ahora podemos seguir accediendo a age pero no podemos rejuvenecer a una persona:

val fred = new Person
fred.age = 30
fred.age = 21
println(fred.age) // 30

Notemos que en Scala no tenemos la necesidad de saber si estamos accediendo a un método o a un atributo, de esta forma scala puede implementar este mecanismo.

Si esperamos tener una propiedad solo lectura, es decir que no se pueda modificar podemos utilizar la palabra val al declarar este atributo:

class Message {
  val timeStamp = new java.util.Date
  …
}

Como ya vimos anteriormente, en ciertos casos es necesario mantener un atributo que no sea modificable directamente:

class Counter {
   private var value = 0 // Se deben inicializar los valores
   def increment() { value += 1 } // Métodos por defecto son públicos
   def current = value
}