Mostrando entradas con la etiqueta java. Mostrar todas las entradas
Mostrando entradas con la etiqueta java. Mostrar todas las entradas

sábado, 6 de marzo de 2010

Eliminando boilerplate con HOF (higher order functions)

Esta es una pequeña demostración de cómo las HOF permiten eliminar boilerplate. Para iniciados será algo muy obvio, pero puede ser interesante para los que sólo usan lenguajes sin HOF, como Java. Para empezar, definamos:

Boilerplate: secciones de código que es necesario escribir (o copiar y pegar) en diferentes contextos o aplicaciones, casi sin variaciones. Esto puede ser por limitación de un lennguaje o framework. El boilerplate es indeseable porque agranda el código sin aportar nada nuevo, y como todo código está sujeto a errores y es otra fuente de bugs. Idealmente el boilerplate debe ser abstraído.

Higher order functions: son las funciones que pueden recibir funciones como argumento (y eventualmente invocarlas), o retornar funciones como resultado. Es característica básica de todo lenguaje funcional.

El caso que voy a mostrar viene de una aplicación en Scala con SWT; hice un mini wrapper ad-hoc de SWT que no se justifica detallar acá, pero la situación es: tengo un trait TabView para ciertos componentes visuales.
trait TabView {
  def init: Unit
  def reset: Unit = /* reinicializa el TabView */
  def redisplay: Unit = /* despliega el contenido del TabView */
  // etc...
}
El método init debe ser implementado por las vistas concretas, definiendo el contenido visual. En algunas vistas tenía la necesidad de hacer cambios en el contenido visual, pero reflejar los cambios en pantalla no era algo tan directo: lo resolví implementando los métodos reset y redisplay en el trait, y haciendo los cambios de esta manera:
class MyView extends TabView {
  def init: Unit = /* definir contenido visual en base a un modelo */
 
  def changeStuff: Unit = {
    reset
    /* hacer cambios en el modelo */
    init
    redisplay
  }
}
En otras palabras, cada vez que necesitaba cambiar alguna cosa en el modelo que debería reflejarse en la vista, debía antes invocar a reset, y después a init y a redisplay. Eso que siempre se hace de la misma manera y que lleva más de una línea de código, es boilerplate.

Usando HOF podemos resolver esto aunque el código relevante del cambio esté en el medio del código reutilizable. Lo hacemos enviando nuestro código relevante como argumento a un método que sabe cómo renovar la vista, asi nos olvidamos de los pasos necesarios. Este es el método que agregué al trait:
  protected def doWithRefresh(task: => Unit): Unit = {
    reset
    task
    init
    redisplay
  }
Y así es como lo invoco:
  def changeStuff: Unit = doWithRefresh {
    /* hacer cambios en el modelo */
  }
Por si no queda claro, el bloque entre llaves es el argumento de tipo => Unit que pasamos al método doWithRefresh. Éste método ejecuta los pasos necesarios en el orden correcto, incluyendo la invocación a nuestra función anónima.

Para una solución equivalente en Java, tendríamos que definir una interfaz como la siguiente, y que sea éste el tipo aceptado por doWithRefresh():
  interface Task {
      public void execute();
  }
Luego lo usaríamos con una clase anónima que implementa Task y por consiguiente el método execute():
  void changeStuff() {
    doWithRefresh(new Task() {
      public void execute() {
  /* hacer cambios en el modelo */
      }
     });
  }
Esto es lo más cercano que tenemos en Java a HOFs: estamos obligados a definir al menos una interfaz, y a instanciarla con una clase anónima. En Java no existe la función como ciudadano de primera, sólo existe como método en un objeto: estamos condenados a pasar un objeto como argumento. Y esta solución, como se ve, agrega su propio boilerplate. El patrón es bueno y es el que se usa por ejemplo en Spring JDBC para los RowMappers. Pero, como dicen, la necesidad de un patrón suele indicar una falencia del lenguaje, y este es un buen ejemplo de eso. Donde hay soporte de HOF, este patrón no tiene razón de ser.

domingo, 27 de diciembre de 2009

Call Super en API de Android


Un API o un framework bien diseñado debe acotar al máximo las posibilidades de que sus usuarios hagan macanas. No puedo decir que la plataforma Android esté en general mal diseñada, pero ahí encuentro un antipatrón que presentaré como ejemplo.


Android provee la clase Activity, que uno debe subclasear para definir actividades específicas. La clase define varios métodos que deben ser sobreescritos en la subclase.


En el javadoc del método onCreateOptionsMenu leemos:


The default implementation populates the menu with standard system menu items. These are placed in the CATEGORY_SYSTEM group so that they will be correctly ordered with application-defined menu items. Deriving classes should always call through to the base implementation.


¿Hay algo que les haga ruido en esta descripción? Si no, piénsenlo un poco.


Nos dice que la implementación default llena el menú con... bla bla bla. OK, creo que hasta podemos ignorar lo que hace. Pero dice que las subclases deben siempre llamar a la implementación base. La pregunta del millón: si siempre hay que hacer X cosa, ¿por qué arriesgarnos a que se me ocurra no hacerla, o me olvide? Lo que deba hacerse siempre, no debe requerir mi intervención.


Vean si no, cómo se les escapó la llamada a ellos mismos en un ejemplo.


En el tutorial de la Notepad Application aportan a la confusión con el valor de retorno:


@Overridepublic
boolean onCreateOptionsMenu(Menu menu) {
boolean result = super.onCreateOptionsMenu(menu);
menu.add(0, INSERT_ID, 0, R.string.menu_insert);
return result;
}


El javadoc dice que debemos retornar true si se debe mostrar el menú, false en caso contrario. Entonces, ¿por qué retornar lo que diga la implementación base? He visto otros ejemplos en los que se ignora el retorno de la implementación base, y se retorna true. ¿Será que la implementación base retorna siempre true? Estas dudas molestan, entorpecen. No deberíamos estar en situación de hacernos esas preguntas, la culpa es del mal diseño.


En wikipedia me entero que el antipatrón es conocido como Call Super.


Como allí bien se explica, esto se corrige aplicando el patrón Template Method. Activity podría haber definido el método así:



public final boolean baseOnCreateOptionsMenu(Menu menu) {
// ...
return onCreateOptionsMenu(menu);
}
public boolean onCreateOptionsMenu(Menu menu) {
return true;
}


El método baseOnCreateOptionsMenu() no puede ser sobreescrito porque es final. El framework, ante el evento correspondiente, llamaría a éste método, que contiene "la implementación base", y éste a su vez llama a onCreateOptionsMenu(), que sí podemos sobreescribir libremente.


Así nadie mete la pata, y todos contentos.

sábado, 25 de abril de 2009

Y hablando de diseño de APIs...

Hay que ver esta presentación de Joshua Bloch: How to design a good API and why it matters . Es fabulosa.

miércoles, 22 de abril de 2009

Leyendo XML en Java sin dolor

Leer XML en Java es un verdadero pain in the ass, a diferencia de Scala, que tiene soporte nativo para XML. No estoy muy al tanto de librerías que facilitan la tarea, que las debe haber, pero quiero compartir una muy elemental que hice. Las características de su diseño que, creo, la hacen interesante son:
  • Inmutabilidad
  • Acceso a subnodos por invocaciones encadenadas, evitando NPE ante nodos inexistentes
El primer punto es una verdad a medias, porque se encapsula un org.w3c.dom.Node que podría ser modificado por afuera. Esto se solucionaría clonando el nodo. Esta "librería" es simplemente un wrapper sobre el nodo. Cada instancia es creada para un nodo específico y no se le puede asignar otro; pero el nodo en sí es mutable.
El segundo punto se basa en el patrón Null Object: la idea es prescindir de null en el API para evitar el fatídico Null Pointer Exception. Más abajo lo vemos.
Como dije antes la librería es elemental, y sus limitaciones son:
  • No sirve para "recorrer" el XML sino para obtener elementos conocidos
  • No accede a los atributos de los elementos
No sería nada complicado superar esas limitaciones. Pero no es tanto por la utilidad de la librería que escribo este post sino porque me parece un buen ejemplo de API, las ideas son aplicables a otras cosas. Aparte también ilustra la idea de tener una capa de abstracción sobre una librería existente, cuando los casos de uso son lo suficientemente simples, y se desea que el código refleje claramente la intención sin que uno deba perderse en la complejidad (o torpeza) de la librería original.


API de XmlNode

Esta es la firma de los constructores:
   
   public XmlNode();
   public XmlNode(Node node);
   public XmlNode(Document doc);
El primero es el Null Object, y si bien es un constructor público, lo normal será que sólo se utilice desde la misma clase y no desde afuera. El segundo toma un Node y el tercero un Document. Este último toma el nodo raiz del documento. La idea es que podamos partir de un documento o un nodo cualquiera, y olvidarnos de la diferenciación: lo que tenemos es un árbol de nodos.
    
    public String getName();
    public String getValue();

Con estos métodos obtenemos el nombre (tag) y el valor (contenido) del nodo. Ambos retornarán null si es un Null Object.

    public XmlNode subNode(String tagName);

Este método en cambio nunca retorna null y permite invocaciones encadenadas. El argumento debe ser un tag de un nodo hijo (inmediatamente relacionado con el actual). Veamos un ejemplo. Si creamos un XmlNode a partir de esto:

   <a> 
      <b>
         <c>hola</c>
         <d>que tal</d>
      </b>
   </a>

Podremos accederlo así:

   String nombre = nodo.getName(); // "a"
   XmlNode nodoB = nodo.subNode("b"); // subnodo <b>
   XmlNode nodoC = nodo.subNode("b").subNode("c"); // subnodo <c>
   String valor1 = nodo.subNode("b").subNode("d").getValue(); // "que tal"
   String valor2 = nodoC.getValue(); // "hola"

Y también así:

   XmlNode nodoX = nodo.subNode("z").subNode("y").subNode("x");
   String valor3 = nodoX.getValue(); // null

Ahí vemos la invocación encadenada con nodos inexistentes. En nodoX nos quedó un Null Object. Para verificar si el XmlNode "está definido" o es nulo, tenemos también el siguiente método (inspirado en el homónimo de Option en Scala):

    public boolean isDefined();

Así será más prolijo verificar si el nodo existe, en lugar de ver si getName() o getValue() retornan null.

El código

import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

public class XmlNode
{
    protected Node node = null;
    
    public XmlNode()
    {
    }
    
   public XmlNode(Node node)
    {
        this.node = node;
    }
    
    public XmlNode(Document doc)
    {
        this.node = doc.getDocumentElement();
    }
    
    public XmlNode subNode(String tagName)
    {
        if(node != null)
        {
            NodeList nl = node.getChildNodes();
            for(int i = 0; i < nl.getLength(); i++)
            {
                Node n = nl.item(i);
                
                if(n.getNodeName().equals(tagName))
                {
                    return new XmlNode(n);
                }
            }
        }
        return new XmlNode();
    }
    
    public String getName()
    {
        return !this.isDefined()? null : node.getNodeName();
    }
    
    public String getValue()
    {
        return !this.isDefined()? null : node.getFirstChild().getNodeValue();
    }
    
    public boolean isDefined()
    {
        return this.node != null;
    }
}

martes, 3 de febrero de 2009

Diseño orientado a objetos: The S.O.L.I.D. principles

Acá van los principios propuestos por el Tío Bob para un buen diseño orientado a objetos, en versión ultra condensada. No los sigo a rajatabla pero son una guía que conviene tener presente, como mínimo. En otro post voy a resumir las reglas de testeabilidad, que son un buen complemento a estos principios (y en parte se superponen).

Single Responsibility Principle (Principio de Responsabilidad Única)

Nunca debe haber más de un motivo por el cual modificar una clase.

Este principio se ve violado por todas partes. Un ejemplo típico es cuando un Servlet hace más de lo que debe. Ya de por sí trabajar directamente con servlets sin un framework que los esconda es una mala idea, pero cuando los usamos, debe ser solamente para dar acceso web a nuestra aplicación: levantar parámetros del request y elementos posteados, invocar las validaciones y servicios que corresponda (en otra capa) y manejar el response.

Open / Closed Principle (Principio Abierto / Cerrado)

Los elementos de software (clases, módulos, funciones, etc.) deben estar abiertos a la extensión, pero cerrados a la modificación.

En realidad, no podemos evitar completamente las modificaciones, pero el diseño puede tener en cuenta qué tipo de modificaciones contemplar, y permitir que cierto cambio de comportamiento se resuelva con nuevas implementaciones o subclases. De acá podemos derivar la regla general de "programar a interfaces", que las dependencias sean sobre abstracciones.

Liskov Substitution Principle (Principio de Sustitución de Liskov, o "Diseño por Contrato")

Los módulos que usen referencias a clases base deben poder utilizar objetos de subclases sin saberlo.

Las subclases deben seguir el comportamiento que se espera de la superclase. La superclase define un contrato. Si las subclases lo respetan, la superclase es sustituible por una subclase, y las subclases son intercambiables. Una regla relacionada con este principio es tratar de que el diseño permita a los usuarios del mismo prescindir del operador instanceof.

Interface Segregation Principle (Principio de Segregación de Interfaces)

Los clientes no deben verse obligados a depender de interfaces que no utilizan.

Las interfaces "gordas" producen acoplamiento entre clientes que deberían estar aislados. Un cliente no tiene por qué "ver" más de lo que necesita de una clase, entonces debería poder accederla a través de una interfaz particular. Por ejemplo, si tenemos una PavaElectrica, y la interfaz Pava define una dependencia con Agua, puede haber clientes para los cuales la PavaElectrica interesa sólo en tanto que ArtefactoElectrico. Y esos clientes deberían poder reutilizarse en proyectos donde haya otras implementaciones de ArtefactoElectrico pero donde no exista la definición de Agua.

Dependency Inversion Principle (Principio de Inversión de Dependencias, también conocido como "Inversión de Control")

Los módulos de alto nivel no deben depender de módulos de bajo nivel: ambos deben depender de abstracciones. Las abstracciones no deben depender de detalles: los detalles deben depender de las abstracciones.

El término "inversión" se debe a que este principio propone dar vuelta las dependencias con respecto a la tradición procedural: módulos de alto nivel que llaman a módulos de bajo nivel. En OOP creamos estas dependencias hardcodeadas cuando usamos el operador new. Cuando dependemos de abstracciones, las dependencias pueden ser inyectadas, en un módulo de inicialización o con un framework de inyección de dependencias.

viernes, 30 de enero de 2009

Lecciones funcionales para imperativos (2): Inmutabilidad

Se puede objetar que la definición de funciones puras en un lenguaje orientado a objetos sólo aplicaría a métodos static, de los que ponemos en clases de "utilitarios". Y los static no son nada representativos de lo que es el paradigma de objetos. Esta observación parece indicar que el paradigma funcional no se lleva bien con el de objetos, y que cualquier intento de fusión sería forzado y torpe.
Las clases más elementales de una aplicación típicamente definen getters y setters: el clásico "JavaBean". Los getters no son puros porque pueden retornar algo diferente cada vez. Los setters producen efectos colaterales al cambiar el estado del objeto.
Habíamos dicho que las funciones puras arrojan un resultado que depende solamente de los parámetros. Como los métodos de instancia se ejecutan en el contexto de un objeto, siempre tienen disponible su referencia, y podemos entender a esa referencia como un parámetro implícito. ¿Por qué, entonces, si un simple getter sólo depende del estado del parámetro implícito (el objeto al que pertenece), no tiene transparencia referencial?
El motivo es que la mutabilidad del objeto conspira contra este fin. Para que un getter tenga transparencia referencial, es necesario que el atributo retornado no tenga posibilidad de cambiar: que su valor inicial permanezca durante la vida del objeto. Por ende no debería existir el correspondiente setter:


class Person {
private String name;
private int age;

public Person(String name, int age) {
this.name = name;
this.age = age;
}

public String getName() { return this.name; }
public int getAge() { return this.age; }
}


De hecho, en la programación funcional pura no existen las variables. Todo valor es inmutable. En Java es fácil crear un primitivo inmutable, para eso utilizamos la palabra clave final. Pero para hacer inmutable un objeto, eso no alcanza: final garantiza que la referencia no apuntará a otro objeto, pero no impide que mute el estado del objeto referenciado. Para lograr esto tenemos que seguir el patrón del ejemplo de arriba.
Para quien haya programado siempre en lenguajes imperativos, la idea de trabajar sin mutabilidad puede parecer un sinsentido. Pero pensemos en algo de uso corriente: la clase java.lang.String es inmutable. En Java no podemos modificar un objeto String, y sin embargo podemos utilizar esta clase sin problemas.


String s = " test ";
s.trim();


En este ejemplo vemos un ingenuo intento de modificar la variable s aplicando el método trim(). Los que alguna vez cometimos este error, aprendimos que los métodos de String retornan una referencia a un nuevo objeto, el resultado del método. Si no guardamos la referencia, de nada sirvió invocar al método. Java no nos advierte de esta situación porque sus diseñadores siguieron el criterio de C y C++: se considera válido invocar a un método y descartar su resultado, porque se asume que se lo quiso llamar como procedimiento, y que sólo nos interesan los efectos colaterales.
Otro ejemplo interesante de uso intensivo de inmutabilidad es la librería Joda Time.
Entonces, resumiendo, lo que normalmente hacemos con mutabilidad, lo podemos lograr invocando funciones que producen un nuevo resultado que consiste en una transformación del valor original.

Un objeto inmutable es, por definición, thread-safe. La inmutabilidad nos da thread-safety en un sentido absoluto, sin depender de un mecanismo obtuso como el de la "sincronización".

Volviendo al ejemplo de la clase Person, ¿cómo definiríamos un método equivalente a modificar la edad de una persona?


public Person withAge(int newAge) { return new Person(this.name, newAge); }


Nada más simple.
El objetivo no es aplicar el paradigma funcional indiscriminadamente en un lenguaje como Java, porque no está en su naturaleza. Pero sí se puede tomar conceptos útiles y aplicarlos hasta donde sea razonable. Por ejemplo, podemos hacer una función con transparencia referencial cuya implementación usa variables:


public int sumChars(String s) {
int a = 0;
for(int i = 0; i < s.length(); i++)
{
a += s.charAt(i);
}
return a;
}


En un caso así no hay efectos colaterales, toda la mutabilidad está manejada en variables locales.

jueves, 29 de enero de 2009

Un cuestionable legado de C / C++

Muchos lenguajes diferencian los conceptos de procedimiento y función, pero los creadores de C decidieron unificarlos, supongo que en un intento de simplificación, llamándolos indistintamente funciones. El procedimiento pasó a ser una función que no retorna ningún resultado (o lo que es lo mismo, con tipo de retorno void). La unificación va más allá, en tanto que C permite invocar cualquier función como si no retornara un resultado. Es decir, cuando sólo interesa lo que la función hace y no lo que retorna, se invoca a la función como procedimiento y el resultado es descartado automáticamente. Quien haya intentado esto con otros lenguajes, como BASIC, se habrá visto obligado a guardar explícitamente un resultado irrelevante, y probablemente considere feliz la iniciativa de C.

C++ mantuvo el criterio de C, aunque empezamos a hablar de funciones miembro, o métodos. Más tarde llegaron Java y C#, donde seguimos hablando de métodos. Todos reconocemos que detrás del concepto de método subyacen los de procedimiento y función, pero es como si nos hubiésemos puesto de acuerdo en mantener medio difusa esa distinción.

Idealmente, a una función hay que llamarla por el resultado que arroja y no por lo que hace. La llamada a una función debe poder ocupar el lugar de un valor, una función es un valor. Por otro lado, a los procedimientos se los llama por lo que hacen. La propuesta es: escribir métodos que son claramente una cosa o la otra, manteniendo los efectos colaterales bajo control. 

Lecciones funcionales para imperativos (1): Transparencia referencial

La transparencia referencial es una propiedad de las funciones. Aplica a toda función matemática, y las de los lenguajes de programación funcional pura. Sin embargo no es una noción ajena a la programación imperativa u orientada a objetos: podemos definir métodos como funciones con transparencia referencial, o "funciones puras". Esta es, quizás, la lección más básica que podemos tomar de la programación funcional, para aplicar en programación imperativa.

Una función tiene transparencia referencial si su resultado depende única y exclusivamente de los parámetros provistos, y no produce efectos colaterales. La implicancia de esto es que, dado un juego de parámetros, no importa cuántas veces llamemos a la función ni desde dónde, el resultado será siempre el mismo.

¿De qué otras cosas podría depender una función que de sus parámetros? De la fecha y hora del sistema, de globales, de valores aleatorios o ingresados por el usuario. En un lenguaje OO, un método también puede depender de atributos mutables, y de métodos sin transparencia referencial, del mismo objeto o de otros. Recordemos además que los singletons y los elementos static son globales.


// Funciones con transparencia referencial

public String capitalize(String x) {
return x.substring(0,1).toUpperCase() + x.substring(1);
}
public int foo(int a, int b) {
int r;
if(a % 2 == 0)
r = b + a * 2;
else
r = b * 5;
return r;
}
public float pi() {
return 3.14;
}


Efectos colaterales

Los efectos colaterales son cualquier cambio en el estado del sistema, como podría ser: modificar globales u otros elementos, y operaciones de salida a dispositivos, incluyendo la pantalla. Cualquier cosa que cambie en el "mundo exterior" a la función es un efecto colateral: una función con transparencia referencial no genera otra novedad en el mundo que el cómputo de su resultado.
Ejemplos de efectos colaterales:


public Dog createDog(List<animal> animals) {
Dog dog = new Dog();
animals.add(dog); // altera una estructura que existe fuera de la función
return dog;
}

Este método produce un efecto colateral al mutar el estado del objeto recibido por parámetro.


public int foo(int a) {
this.someAttr += a; // altera un atributo del mismo objeto
return a > 0? a * a : a;
}

Este otro método es determinístico en su resultado, pero al mutar un atributo, el estado del objeto no será igual cuando se llame al método varias veces con el mismo parámetro.


public int sum(int a, int b) {
System.out.println("sum"); // genera salida por pantalla
return a + b;
}

Este caso parece particularmente inocuo. Es como que para el programa da igual si se imprimió "sum" o no. Sin embargo, consideremos los siguientes programas:


// Programa #1
int x = sum(1, 1);
System.out.println(x);


// Programa #2
int x = sum(1, 1);
x = sum(1, 1);
System.out.println(x);


El resultado de ejecutar uno y el otro es diferente, no es lo mismo imprimir algo una vez que dos veces. La pantalla es parte del "mundo exterior" sobre el que actuó la función.
La propuesta de hacer funciones sin efectos colaterales puede sonar ridícula, y de hecho no puede haber un programa útil sin efectos colaterales. La idea es que estos efectos estén controlados. Cuando hacemos una función, conviene plantear si los efectos colaterales son necesarios, y si no lo son, quizás sea candidata a tener transparencia referencial.
Si determinamos que cierto efecto colateral es necesario, igualmente conviene en lo posible cumplir con el otro aspecto de la transparencia referencial: que el resultado dependa sólo de los parámetros.

La transparencia referencial ayuda a que el código sea más claro y testeable.

Los efectos colaterales tienen mayor sentido en los procedimientos. A los procedimientos se los llama para hacer algo, para cambiar el estado del sistema, para producir un efecto; en cambio una función es un valor.
Los programas en lenguajes de programación funcional consisten en una composición de funciones. En lenguajes imperativos, podemos tener módulos basados en composición de funciones puras, aunque el programa sea impuro. Todo lo que se pueda acotar con una implementación pura será más mantenible y menos proclive a bugs.

martes, 27 de enero de 2009

Qué cuernos es Scala y por qué esa obsesión

Ya lo dije en otras partes pero me voy a tomar un post acá para resumirlo. Scala es un lenguaje de incipiente adopción, señalado a veces como "el próximo Java" o como uno de sus herederos. Aparentemente Java llegó a un techo en su evolución, por cuestiones intrínsecas (su diseño) y extrínsecas (determinación de Sun). Una forma elegante de evadir completamente este problema es pasándose a otro lenguaje mejor diseñado, sin cambiar de plataforma. Scala es uno de esos. Incorpora bastante más que lo que algunos están reclamando como torpe mejora en Java.
Algunas características:

  • Compila a bytecode (JVM)
  • Es interoperable con Java (o sea, se pueden seguir usando librerías y frameworks existentes en Java)
  • Es de tipo estático
  • Inferencia de tipos
  • Fusiona exitosamente programación funcional con OOP
  • Tiene una forma de herencia múltiple llamada composición mixin
  • "Conversiones implícitas": permiten extender librerías externas y hacer una especie de prototyping
  • Incluye un intérprete ("REPL")
  • Soporta XML como un tipo más
  • Viene con librerías interesantísimas: concurrencia tipo Erlang, parser combinators, etc.
  • ¿Qué más querés?
El sistema de tipos tiene cierta complejidad, que domino a medias, pero con eso en general alcanza. Más allá de todas las ideas incorporadas, tomadas de varios lenguajes e integradas por Martin Odersky en Scala, el reto mayor para quien viene de Java u otro lenguaje imperativo es asimilar el estilo de programación funcional. 

Scala permite codificar en estilo imperativo, como si fuera un Java con diferente sintaxis. Eso puede estar bueno para ir metiéndose de a poco, pero de nada servirá si uno no busca avanzar a un código más funcional. El estilo funcional lamentablemente estuvo siempre muy divorciado de la industria y muy casado con la academia, pero esto ya está cambiando. Está presente en Python, Ruby, JavaScript; entró de lleno en .NET con C#/LINQ y F#, etc., y es probable que esta tendencia se profundice, aunque haya que terminar desechando Java por completo.

Se dice por ahí que "aprender programación funcional nos convierte en mejores programadores aunque nos dediquemos a la programación imperativa". Hay dos o tres cosas que me gustaría rescatar en ese sentido, para un próximo post, aplicables a cualquier lenguaje. Son cosas bien sencillas que se nos escaparon por mucho tiempo, y pueden ser un buen punto de entrada a los beneficios del paradigma funcional.
¡Salud!