viernes, enero 28, 2011

Scala: Clases y objetos

Durante esta entrada analizaremos algunas de las características básicas del paradigma orientado a objetos presentes en Scala. Pongámonos manos a la obra:

Del mismo modo que en todos los lenguajes orientados a objetos Scala permite la definición de clases en las que podremos añadir métodos y atributos:

class MyFirstClass{
  val a = 1
}

Si deseamos instanciar un objeto de la clase anterior tendremos que hacer uso de la palabra reservada new


val v = new MyFirstClass


En Scala existen dos tipos de variables, vals y vars, que deberemos especificar a la hora de definir las mismas:

  • Se utilizará la palabra reservada val para indicar que es inmutable. Una variable de este tipo es similar al uso de final en Java. Una vez inicializada no se podrá reasignar jamás.
  • De manera contraria, podremos indicar que una variable es de clase var, consiguiendo con esto que su valor pueda ser modificado durante todo su ciclo de vida.

Uno de los principales mecanismos utilizados que garantizan la robustez de un objeto es la afirmación de que su conjunto de atributos (variables de instancia) permanezca constante a lo largo de todo el ciclo de vida del mismo. El primer paso para evitar que agentes externos tengan acceso a los campos de una clase es declarar los mismos como private. Puesto que los campos privados sólo podrán ser accedidos desde métodos que se encuentran definidos en la misma clase, todo el código podría modificar el estado del mismo estará localizado en dicha clase.

Por defecto, si no se especifica en el momento de la definición, los atributos y/o métodos, de una clase tienen acceso público. Es decir, public es el cualificador por defecto en Scala

El siguiente paso será incorporar funcionalidad a nuestras clases; para ello podremos definir métodos mediante el uso de la palabra reservada def:

class MyFirstClass{
  var a = 1
  def add(b:Byte):Unit={
a += b
  }
}


Una característica importante de los métodos en Scala es que todos los parámetros son inmutables, es decir, vals. Por tanto, si intentamos modificar el valor de un parámetro en el cuerpo de un método obtendremos un error del compilación:

def addNotCompile(b:Byte) : Unit = {
  b = 1  // Esto no compilará puesto que el 
 // parámetro b es de tipo val
  a += b
}

Otro aspecto relevante que podemos apreciar en el código anterior es que no es necesario el uso explícito de la palabra return, Scala retornará el valor de la última expresión que aparece en el cuerpo del método. Adicionalmente, si el cuerpo de la función retorna una única expresión podemos obviar la utilización de las llaves.

Habitualmente los métodos que presentan un tipo de retorno Unit tienen efectos colaterales, es decir, modifican el estado del objeto sobre el que actúan. Otra forma diferente de llevar a cabo la definición de este tipo de métodos consiste en eliminar el tipo de retorno y el símbolo igual y englobar el cuerpo de la función entre llaves, tal y como se indica a continuación:
class MyFirstClass {
  private var sum = 0
  def add(b:Byte) { sum += b }
}

En la siguiente entrada introduciremos el concepto de singleton objects. También intentaré que la apariencia de las entradas sea un poquito más atractiva utilizando el genial servicio ofrecido por http://pastie.org

jueves, enero 27, 2011

Scala: Primeros pasos (cont)

En la entrada anterior comenzabamos nuestra pequeña aventura en Scala analizando las características principales del paradigma orientado a objetos y revisando alguna de las contribuciones que este lenguaje presenta al modelo. Durante la entrada que nos ocupa revisaremos brevemente los fundamentos del paradigma funcional y analizaremos cómo Scala incorpora y unifica lo mejor de ambos paradigmas en un lenguaje estáticamente tipado.

La programación funcional es un paradigma en el que se trata la computación como la evaluación de funciones matemáticas y se evitan los programas con estado y datos que puedan ser modificados. Se adopta una visión más matemática del mundo en el que los programas están compuestos por numerosas funciones que esperan una determinada entrada y producen una determinada salida y, en muchas ocasiones, otras funciones.

Otro de los aspectos de la programación funcional es la ausencia de efectos colaterales gracias a los cuales los programas desarrollados son mucho más sencillos de comprender y probar. Adicionalmente, se facilita la programación concurrente, evitando que se convierta en un problema gracias a la ausencia de cambio.

Los lenguajes de programación que soportan este estilo de programación deberían ofrecer algunas de las siguientes características:
  • Funciones de primer nivel
  • Closures
  • Asignación simple
  • Evaluación tardía
  • Inferencia de tipos
  • Optimización del tail call
  • Efectos monadic

Es importante tener claro que Scala no es un lenguaje funcional puro dado que en este tipo de lenguajes no se permiten las modificaciones y las variables se utilizan de manera matemática (un ejemplo de lenguaje funcional puro sería Haskell).

Durante las dos últimas entradas hemos centrado nuestra atención en algunos de los aspectos más teóricos por lo que posiblemente a los (pocos) que hayáis leído esto se os haya hecho demasiado aburrido.

Esperemos que la siguiente entrada sea más entretenida.

martes, enero 18, 2011

Scala: Primeros pasos

Me gustaría comenzar una serie de post relativos al lenguaje de programación Scala para que, si alguien se pasa por aquí y tiene interés, pueda dar sus primeros pasos en este fantástico lenguaje. Dejar claro desde el principio que no soy, ni por asomo,  un experto :) , aunque intentaré explicarme con la mayor claridad que me sea posible.


Para comenzar, un poquito de teoría e historia:

Scala es un lenguaje de propósito general diseñado para expresar los patrones de programación más comunes de una manera sencilla, elegante y segura. Integra de manera sencilla características de orientación a objetos y lenguajes funcionales, permitiendo de este modo que los desarrolladores puedan ser más productivos. Su creador, Martin Odersky, y su equipo comenzaron el desarrollo de este nuevo lenguaje en el año 2001, en el laboratorio de métodos de programación en EPFL (École Polytechnique Fédérale de Lausanne)

Scala hizo su aparación pública sobre la plataforma JVM (Java Virtual Machine) en enero de 2004 y unos meses después haría lo propio sobre la plataforma .NET. Aunque se trata de un elemento relativamente novedoso dentro del espacio de los lenguajes de programación, ha adquirido una notable popularidad la cual se acrecenta día tras día.


Orientación a objetos


Un lenguaje orientado a objetos "puro" debería presentar las siguientes características:

Ocultación de información.

  • Herencia.
  • Polimorfismo/Enlace dinámico.
  • Todos los tipos predefinidos son objetos.
  • Todas las operaciones son llevadas a cabo mediante en envío de mensajes a objetos.
  • Todos los tipos definidos por el usuario son objetos.
  • Scala da soporte a todas las características anteriores mediante la utilización de un modelo puro de orientación a objetos muy similar al presentado por Smalltalk (lenguaje creado por Alan Kay sobre el año 1980).

De manera adicional Scala añade algunas innovaciones en el espacio de los lenguajes orientados a objetos:
  • Composición modular de mixin. Mecanismo que permite la composición de clases para el diseño de componentes reutilizables evitando los problemas presentados por la herencia múltiple. Similar a los interfaces Java y las clases abstractas. Por una parte se pueden definir múltiples "contratos" (del mismo modo que los interfaces). Por otro lado, se podrían tener implementaciones concretas de los métodos.
  • Self-type. Los mixin no dependen de ningún método y/o atributo de aquellas clases con las que se está entremezclando aunque en determinadas ocasiones será necesario hacer uso de las mismas. Esta capacidad es conocida en Scala como self-type
  • Se ha optado por mantener el término original disponible en la documentación del lenguaje.
  • Abstracción de tipos. Existen dos mecanismos principales de abstracción en los lenguajes de programación: la parametrización y los miembros abstractos. Scala soporta ambos estilos de abstracción de manera uniforme para tipos y valores
Vamos a dejar la entrada en este punto para no convertirla en un ladrillo (más aun de lo que ya  es) y en el próximo post analizaremos, de manera general, las características generales del paradigma funcional.

martes, enero 04, 2011

2011: Propósitos

2010 ha sido un año complicado en muchos sentidos y creo que, en la medida de lo posible, hemos hecho todo lo posible para que las cosas nos hayan ido bien.

Aunque no soy excesivamente partidario de los propósitos de año nuevo voy a hacer una excepción. Voy a hacer una lista de cosas que me gustaría realizar durante este nuevo año que acabamos de comenzar:

  • Pasar mucho más tiempo con mi futura esposa. Soy consciente de que a veces me enfrasco en muchas cosas que no deberían quitarme tanto tiempo. Es algo en lo que tengo mejorar y por eso está en la primera posición de mi lista
  • Casarme. Si señores, como bien habréis deducido del punto anterior, este año me caso. Creo que no necesita mayor explicación :)
  • Retomar el deporte. 
  • Leer, leer y leer. Terminar la interminable lista de libros y artículos que tengo pendientes además de todos los que están por venir :)
  • Comenzar mi tésis doctoral. Estoy empezando a escribir la tesina, la cual si todo va bien, servirá como base para mi tésis doctoral. Ligado con el mundo investigador este año me esforzaré por publicar algún artículo.
  • Programar, programar, y programar. Reactivar mi participación en alguno de los proyectos de software libre en los que participaba hace tiempo y en los que, por diversos motivos, he tenido que reducir mi participación a la mínima expresión.
  • . . .
Seguramente muchas de las anteriores tareas se quedarán en el tintero por diversos motivos aunque esperemos que con muchas ganas y esfuerzo algunas de ellas salgan adelante.

Un abrazo y feliz 2011 para tod@s!