Mostrando entradas con la etiqueta api. Mostrar todas las entradas
Mostrando entradas con la etiqueta api. 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.

miércoles, 2 de septiembre de 2009

Anillo inmutable

Se me presentó un caso para el que necesité un tipo de colección que no está en la librería estándar de Java ni la de Scala: una lista circular. Que se la pueda recorrer en ambos sentidos, que no tenga fin. Seguramente hay implementaciones por ahí pero lo tomé como un ejercicio.

Ya me acostumbré a usar estructuras inmutables por default, así que este anillo será inmutable. Primer paso: definir el API. 
trait Ring[T]
{
  def get: T
  def next: Ring[T]
  def previous: Ring[T]
}
Bien simple. La idea es que una instancia de Ring me da acceso al elemento "actual" únicamente, con el método get. Con next y previous obtengo un nuevo Ring, con el mismo contenido, donde el elemento "actual" es el próximo o el anterior respectivamente.

Cualquier implementación de una colección inmutable debe contemplar alguna manera de establecer el contenido. Una alternativa es proveer el contenido en una colección más "básica" como sería un Array[T], donde los elementos están en un orden determinado. El anillo nos da una vista de ese contenido en la que los extremos están unidos. En este caso, el Array, aparte de ser el proveedor de contenido para el anillo, es la estructura subyacente de la implementación: con next y previous se reinstancia Ring pero siempre compartiendo la misma instancia del Array. El trabajo del anillo es escencialmente mantener un índice al elemento actual. Una implementación que promete eficiencia.
class ArrayRing[T](elems: Array[T], curIndex: Int) extends Ring[T]
{
    def this(elems: Array[T]) = this(elems, 0)
    
    if(elems == null) throw new IllegalArgumentException
    if(curIndex < 0 || curIndex >= elems.size) throw new IndexOutOfBoundsException

    def get: T = elems(curIndex)
    
    def next: Ring[T] = new ArrayRing(elems, if(curIndex < elems.size - 1) curIndex + 1 else 0)
 
    def previous: Ring[T] = new ArrayRing(elems, if(curIndex > 0) curIndex - 1 else elems.size - 1) 
}
Al instanciar ArrayRing, se puede indicar qué índice corresponde al elemento actual; si no, se asume el primero (0).

Me vino bien para lo que necesitaba, pero no incluiría esta clase en una librería para terceros porque cometí un sutil pecado. Si lo presento como un anillo inmutable, y de hecho eso se desprende del API, no puedo usar como estructura subyacente una colección mutable (Array) que está fuera de mi control. La clase se comporta como si el Array nunca cambiara, cuando nada garantiza tal cosa. Desde el punto de vista del usuario de la clase, nada revela que el Array se utiliza para algo más que para proveer los elementos al anillo; uno supondría que, una vez instanciado el ArrayRing, éste pierde toda dependencia con el Array informado.

Entonces, hagan lo que yo digo, no lo que yo hago. Una mejor implementación debería pedir una colección inmutable (y en ese caso no importa si se utiliza como estructura subyacente o no), o bien tomar el Array pero pasar sus elementos a alguna otra estructura interna. En éste último caso sería conveniente reutilizar esa estructura interna al reinstanciar el anillo con next y previous, para no perder en eficiencia.

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.