Mostrando entradas con la etiqueta buenas prácticas. Mostrar todas las entradas
Mostrando entradas con la etiqueta buenas prácticas. Mostrar todas las entradas

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, 7 de febrero de 2009

Guía para el código testeable

Siguiendo con los posts "de referencia", hoy traduzco un resumen de la Guía para el Código Testeable utilizada en Google y publicada en el blog de Miško Hevery. Esta guía consiste en 4 fallas de diseño a evitar, y las señales de advertencia que indicarían que las cometimos. Como siempre, se trata de reglas generales, no para seguirlas dogmáticamente, sino para tenerlas presente y considerar el costo de ignorarlas.

Quizás más adelante me ponga a traducir la cosa más a fondo, porque se explica todo con mayor detalle, con argumentos y ejemplos. Mientras tanto, quienes puedan leer inglés, háganse un favor y vayan a la fuente.

Falla #1: El constructor hace trabajo
Señales de advertencia:
  • Se usa el operador new en el constructor o en la declaración de campos
  • Llamadas a métodos static en el constructor o en la declaración de campos
  • Cualquier cosa en un constructor más allá de asignación de campos
  • Objetos que no queden completamente inicializados una vez terminado el constructor (atención con los métodos initialize)
  • Flujo de control (lógica condicional o cíclica) en un constructor
  • Se construye un complejo grafo de objetos dentro de un constructor, en lugar de usar una factory o un builder
  • Bloques de inicialización

Falla #2: Hurgar en los colaboradores
Señales de advertencia:
  • Se pasan objetos pero nunca son utilizados directamente (sólo para obtener acceso a otros objetos)
  • Violación de la ley de Demeter: la cadena de llamadas a métodos recorre un grafo de objetos con más de un punto (.)
  • Nombres sospechosos: context, environment, principal, container, o manager

Falla #3: Estado global riesgoso y Singletons
Señales de advertencia:
  • Uso de singletons
  • Uso de campos static o métodos static
  • Uso de bloques de inicialización static
  • Uso de registries
  • Uso de service locators

Falla #4: La clase hace demasiado
Señales de advertencia:
  • Al describir lo que la clase hace usamos la palabra "y"
  • Sería complicado para un nuevo programador leer la clase y rápidamente comprenderla
  • La clase tiene campos que son usados solamente en algunos métodos
  • La clase tiene métodos static que solamente operan sobre los parámetros

Miško responde a los lectores que dejan sus comentarios, acá va una muestra interesante:

En la falla #3 mencionás que el "uso de registries" es una señal de advertencia. Pero la mayoría de las aplicaciones tienen algunos objetos que necesitan ser accedidos desde todas partes, o al menos en base a algún contexto. ¿Cómo manejaríamos tales objetos sin un registry? (...)


Y la respuesta:

(...) Registry, Context, ServiceLocator, o como quieras llamarlo, es un problema. En primer lugar, ¿cómo obtenés su referencia? ¿Variable global?

Las variables globales son problemáticas:
http://misko.hevery.com/2008/08/25/root-cause-of-singletons/
http://misko.hevery.com/2008/08/17/singletons-are-pathological-liars/

Los locators son problemáticos:
http://misko.hevery.com/2008/10/21/dependency-injection-myth-reference-passing/

Y la solución es Inyección de Dependencias aun si es un objeto ampliamente necesitado:
http://misko.hevery.com/2008/10/21/dependency-injection-myth-reference-passing/
(...)

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

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.