Scala

Lenguaje funcional sobre la JVM, orientado a concurrencia y paralelismo.

Play 2.0 Final Released | ¡A jugar más y mejor!

Y es que han liberado la versión final de la versión mayor del framework, la 2.0. Ahora
si ya está disponible desde el sitio oficial del proyecto
la descarga de la versión final, así como la documentación.

De momento, no me atrevo a dar mis opiniones debido a que necesitaría entrarle duro
con un desarrollo de al menos unas 2 o 3 horas diarias. Sin embargo en casa haré unas
pruebas pequeñas para tener una idea de que es lo que viene ahora este framework.

Cosas destacables que podemos ver de reojo es la inclusión de actores a través de Akka,
también podemos ver como la gente de Zenexity -desarrolladores de Play!- se han enfocado
más en temas como concurrencia y lo que se refiere a asincronía (¿se puede decir así en español?),
entre otras cosas.

Para los más experimentados en Scala, la 2.0 viene con cosas bastante interesantes, de modo
que ya tenemos una mejor manera para explorar las capacidades de Scala a través de Play!.

También cabe mencionar que Play 2.0 ya es parte de la pila de Typesafe Stack 2.0
que para mi se ve más que interesante.

El balance entre el uso de métodos como operadores.

Estaba escribiendo una respuesta al post de ezamudio Operadores en Ceylon pero como siempre me extendí más de la cuenta y mejor cree esta entrada separada.

El tema es la sobre carga de operadores en Ceylon.

Es interesante tratar de alcanzar el balance entre el uso de operadores y métodos en un lenguaje de programación.

Por un lado, si se permite que cualquier método se pueda utilizar como operador, se puede terminar creando código que solamente el autor del programa o la biblioteca entienda y eso cuando aún lo tiene fresco en la mente. Me parece que este es una de las críticas más fuertes hacía C++ y a Scala ( aunque Scala además permite una sintaxis diferente para la invocación de métodos que es sin usar punto )

Por otro lado si se prohibe del todo se tiene un lenguaje que es sumamente claro y fácil de entender por cualquiera pero que resulta tedioso porque el programador tiene que escribir toooodo el nombre del método y no simplemente un operador ( Java , Javascript y Go por ejemplo )

Scala IDE


Ahora que tuve un poco de tiempo de probar varios lenguajes como: Scala, Ceylon, Clojure, etc. encontré este sitio Scala IDE http://scala-ide.org/

Se trata de un IDE (plugin) para crear programas en Scala desde Eclipse.

En Eclipse basta poner este link:
http://download.scala-ide.org/releases-29/stable/site
Y la verdad no pude evitarlo, quise probarlo con un código que hice en Groovy haber como quedaba:

Horoscopo.scala

object horoscopo{

   def main(args: Array[String]){
      var resto=0;
      val anyos=List(1981,1982,1983,1984,1985,1986,1987,1988,1989,1990,1991,1992,1993,1994,1995,1996,1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2012);
      var horos=""
      println("[Horoscopo chino en Scala]");
        for(val i <- anyos){
           resto=i%12
           
           if(resto==0){
              horos="mono"
            }
           if(resto==1){
              horos="gallo"
           }

Podcast de ViveCodigo 00x11 - Entrevista con Jorge Ortiz

Los chicos de ViveCodigo han publicado el último podcast donde entrevistan a Jorge Ortíz, un desarrollador de software que trabaja actualmente en FourSquare.

El audio en directo:

Que lo disfruten...

Anuncio de Play! framework 2.0 en español

Pueden consultar el artículo aquí: http://playdoces.appspot.com/2.0

En el mismo se explican los principales cambios y las nuevas prestaciones de la próxima versión del framework.

Como principal novedad, el core del mismo estará escrito en scala, integrándose al stack de typesafe (scala + akka + sbt + play!), y tendrá soporte completo y APIs nativas tanto para scala como para java.

También hay otras novedades, como un nuevo sistema de builds (sbt), mayores validaciones en tiempo de compilación (los templates e incluso los archivos de rutas son estáticamente compilados), más soporte para operaciones asincrónicas, soporte para diversos tipos de fuentes de datos (bases relaciones y nosql) y más cambios.

Junto con algunos colaboradores, emprendimos la tarea de comenzar a traducir la documentación de Play! framework al idioma castellano para facilitar la adopción de esta herramienta en la comunidad de desarrolladores de habla hispana. Pueden consultarla en http://playdoces.appspot.com.

ScalaSQL: Interfaz sencilla para JDBC desde Scala

Desde hace tiempo que Groovy es mi lenguaje favorito para hacer scripts que a veces necesito para interactuar con bases de datos (algunos reportes o modificar ciertos datos, procesamiento por lotes, etc).

Son principalmente dos razones por las que me gusta tanto usar Groovy para este tipo de scripts:

  1. Tengo a mi disposición todo un arsenal de componentes de Java (simplemente con el JDK tengo un montón de cosas) y además todo lo que me ofrece Groovy como lenguaje, encima del JDK de Java (closures, comprehensión de listas, etc).
  2. El componente groovy.sql.Sql me permite interactuar con bases de datos de manera muy sencilla.

En Scala aún no hay un componente similar. Y aunque lo hubiera, no usaría Scala para scripting (ya he escrito al respecto anteriormente). Pero creo que sí hace falta. Si bien existe el hiperútil componente JdbcTemplate de Spring, para el cual además ya existen unas adiciones para Scala (junto con otras cosas de bean factories) en el proyecto ScalaPrimavera, no siempre es posible o deseable comenzar a depender de Spring.

Así que me propuse desarrollar un componente similar al Sql de Groovy, con algunas cosas adicionales que me han resultado muy útiles de JdbcTemplate, con la finalidad de usarlo en aplicaciones Scala, de modo que debe ser seguro su uso en ambientes multi-hilo, debe tener buen performance, debe manejar bien la transaccionalidad y sobre todo debe ser sencillo de usar.

El poder de Either en Scala

Hace tiempo escribí acerca de la versatilidad que nos da el usar Option en Scala, cuando se puede manejar un valor que podría ser nulo.

Esto es muy útil por ejemplo para un método de login: pasamos usuario y password, y obtenemos un Usuario, siempre y cuando exista el usuario con ese nombre y su password sea correcto. Entonces podemos implementar el método de estar forma:

def login(username:String, password:String):Option[Usuario]={
  val user = //Buscamos el usuario en la base de datos
  if (user != null && passwordEsValido) Some(user)
  else None
}

Entonces cuando invocamos el método login, ya no tenemos que validar contra null en un if para proceder de una forma, y presentar un error en el else; en vez de eso podemos hacer distintas funciones:

def continuar(user:Usuario)=//esto lo invocaremos si el login estuvo OK
def error()=//Esto lo invocaremos si el login falla

//Aquí viene lo bonito de usar Option:
//Esta línea de código expresa muy claramente lo que hay que hacer
login("username", "password") map continuar orElse error

ScalaQuery: Un DSL para acceso a base de datos en Scala

La manera más básica o primitiva de interactuar con una base de datos en Java es por medio de JDBC. Esto por supuesto se puede hacer también en Scala, Groovy o cualquier otro lenguaje para la JVM, pero al usar JDBC se tiene que programar en estilo Java por la manera en que fue diseñado.

En Scala existe una alternativa interesante: ScalaQuery. Lo que esta biblioteca nos permite hacer es realizar queries con código Scala, con un margen de error mucho menor, ya que se aprovecha el tipado estático del lenguaje de una forma que incluso en Java no se hace con JDBC.

La mejor manera de ilustrar su uso es con un ejemplo sencillo. Supongamos que tenemos una tabla, definida así en SQL:

CREATE TABLE ejemplo(
  clave     SERIAL PRIMARY KEY, --autoincrementada
  nombre    VARCHAR(80) NOT NULL,
  apellidos VARCHAR(80) NULL,
  fecha_nac DATE NOT NULL,
  ultimo_acceso TIMESTAMP NULL,
  entero    INT NULL,
  saldo     NUMERIC(10,4) NOT NULL
)

Un caso interesante de Scala vs. Java

Hace mucho tiempo, implementé un codificador para Base 64 en Java. El algoritmo es relativamente simple: consiste en codificar 3 bytes como 4 caracteres de texto, tomados de un alfabeto de 64 posibles caracteres (de ahí el nombre). El alfabeto está compuesto de las letras A a la Z mayúsculas y luego minúsculas, los dígitos y los signos + y /. Existe además un símbolo especial = para indicar la ausencia de datos, cuando se codifica un bloque de menos de 3 bytes.

Cuando lo implementé en Java, lo primero que hice fue definir el alfabeto, como un arreglo de char Para ello, dentro de la clase que iba a contener los dos métodos (codificar y decodificar), hice esto:

Coming soon: Play 2.0. "It's time to move on"

Parece que tenemos buenas noticias de la actividad de desarrollo de mi framework web favorito y cómo ya muchos sabrán es Play!. Un framework web del que ya había escrito algunas entradas a modo de inducción al tema (esta, esta y esta otra).

Bueno, pues revisando mi cuenta de G+, me encontré con una entrada realizada por el mismo fundador del proyecto Play!, el francés Guillaume Bort quien en el sitio web del proyecto dijo:

It's time to move on! We are working on the next major version of Play framework, integrating a brand new build system and awesome asynchronous features all with native Java and Scala support.

Cosas interesantes que se vienen del proyecto.

Distribuir contenido