SyntaxHighlighter

martes, 2 de junio de 2015

Scala with Style

Acabo de verme un video Martin Odersky, creador  de scala, sobre guias de estilo en este lenguaje funcional. El video esta muy bien, agradable y clara exposicion.

https://www.youtube.com/watch?v=kkTFx3-duc8

Resumen para no gastar una hora viendo el video y para que a mi no se me olvide :)

Choice #1:Infix vs .
items + 10 or item.(10)
xs map f or xs.map(f)
xs flatMap fun filterNot isZero groupBy keyfn or  xs.flatMap(fun).filterNot(isZero).groupBy(keyfn)

conclusion: donde haya duda sobre cual es el objecto y cual es el verbo es mejor . (el de la derecha)
Lo que me sugiere que si pensamos en sujetos y verbos seguimos pensando en objecto....no sera facil salir de esa forma de pensar.

Choice #2:Alphabetic vs Symbolic

xs map f or xs *|> f
vector + f or vector.add(f)
(xs.foldLeft(z))(op) or (z /: xs)(op)
UNDEFINED   or  ???

Odersky recomienda los de la izquierda excepto por el foldLeft donde admite que a el le gusta y le parece mas claro el de la derecha que es como un domino que va de izq a derecha pero admite que la mayor parte de la gente no entiende esta simbologia y que por lo mismo quiza no sea la mejor solucion.


Choice #3:Loop, recursion  or combinations?

xs map f
or
var buf  = new ListBuffer[String]
for (x <- xs) buf += f(x)
xs.toList
or
def recurs(xs: List[String]) = xs match {
   case  x :: xs1  => f(x) :: recur(xs1)
   case Nil  => Nil
}

No comment....

xs.grouped(2).toList.map {
   case List(x,y) = > x*y
}

or

var  buf = new ListBuffer[Int]
var ys = xs
while (ys.nonEmpty){
   guf += ys(0)*ys(1)
   ys = ys.tail.tail
}

or

def recur(xs: List[Int]): List[Int] = xs match {
   case x1 :: x2 :: xs1 => (x1 * x2) :: recur(xs1)
   case Nil => Nil
}
recur(xs)

Combinators: Easiest to use
Recursive functions: bedrock of FP
Pattern matching: Much clearer and safer than test and selections
Loops: Because they are familiar, and sometimes are the simples solution

Recomendations:
1. Consider using combinators first
2. if this becomes too tedious, or efficiency is a big concern, fall back on tail-recursive functions.
3. Loops can be use in simple cases, or when the computation inherently modifies state.

Choice #4: Procedures or "="

def swap[T](arr: Array[T], i: Int, j: Int){
  val t = arr(i);ar(i) = arr(j);arr(j) = t
}
def swap[T](arr: Array[T], i:Int, j:Int): Unit = {
   val t = arr(i);arr(i) = arr(j); arr(j) = t
}


Scala accident ??

Choice #5: Private vs nested

def outer(owner: Symbol) = {
   def  isJava(sym: symbol): Boolean = sym hasFlag JAVA
   if (symbols exists isJava)
}

easy nested almost always you can avoid passing parameters from the enviroment. But if you not capturing nothing code is harder to read.

def  isJava(sym: symbol): Boolean = sym hasFlag JAVA

def outer(owner: Symbol) = {
   if (symbols exists isJava)
}


Choice #6: Pattern matching vs dynamic dispatch

class Shape
  def area: Double
case class Circle(centre: Point, radius: Double) extends Shape
  def area = pi * radius * radius
case class Rectangle(ll: Point, ur: Point)
  def area = (ur.x - ll.x)* (ur.y - ll.y)

or

def area(s: Shape): Double = s match {
  case Circle(_, r) => math.pi*r*r
  case Rectangle(ll,ur) => (ur.x - ll.x)* (ur.y - ll.y)
...
}

Un espectador pregunta: Y que pasa cuando uno se olvida de definir el metodo para uno de las clases?
Hay algo que se llama sealed classes


jueves, 28 de noviembre de 2013

diseño de patrones, Visitor.


En wikipedia:
http://en.wikipedia.org/wiki/Visitor_pattern



El mismo ejemplo que alli viene...modelemoslo:





 y se usaria :
 
public class VisitorDemo {
     public static void main(String[] args) {
         CarElement car = new Car();
         car.accept(new CarElementPrintVisitor());
         car.accept(new CarElementDoVisitor());
     }
 }
 
Veamos más ejemplos:
en http://www.javaworld.com/javatips/jw-javatip98.html aparece la pregunta clave. 
¿Como se gestionan operaciones sobre colecciones de objectos diferentes?. 
Esta es la pregunta cuya respuesta es el patron visitor. El ejemplo que aquí te ponen es que si al iterar sobre la collección tengo que poner un if por cada tipo de objeto que pueda encontrarme, el codigo alcanza pronto una cantidad inaceptable de ifs. 

En este caso teniendo una colección de String, Long..y objectos diferentes se puede crear el siguiente diagrama de clases.





Legenda:


miércoles, 27 de noviembre de 2013

Diseño de patrones, Strategy

De la wikipedia:

http://en.wikipedia.org/wiki/Strategy_pattern
Busquemos algún ejemplo...
En http://java.dzone.com/articles/design-patterns-strategy


La verdad es que no hay mucho que comentar. Se desacopla la conversión concreta de su uso. Se accede a esta funcionalidad de manera indirecta, doblemente indirecta. Una por que se comprime desde el contexto pero no se accede al compresor directamente sino que se encapsula en el método compressArchive(). Y otra por que el compressor al que este método accede es generico y por tanto solo se hace directa en la ejecución, no en la compilación.

Diseño de patrones, Observer

de la maravillosa página :
http://sourcemaking.com/design_patterns/observer/java/1


que se utilizaría...

public static void main( String[] args ) {
    Subject sub = new Subject();
    // Client configures the number and type of Observers
    new HexObserver( sub );
    new OctObserver( sub );
    new BinObserver( sub );
    Scanner scan = new Scanner();
    while (true) {
      System.out.print( "\nEnter a number: " );
      sub.setState( scan.nextInt() );
    }
  }
 Asi que por cada número este cambiara el estado de el sujeto observado (subject) y esto accionará la notificación de sus observers y el update de cada  uno cuyo metodo depende directamente del estado del subject.

martes, 26 de noviembre de 2013

Diseño de patrones, Mediator

http://sourcemaking.com/design_patterns/mediator

Util para desacoplar comunicaciones....

 de modo que queden


veamos en http://www.dofactory.com/Patterns/PatternMediator.aspx#_self1



y como usarlo...
  class MainApp
  {
    /// <summary>
    /// Entry point into console application.
    /// </summary>
    static void Main()
    {
      ConcreteMediator m = new ConcreteMediator();

      ConcreteColleague1 c1 = new ConcreteColleague1(m);
      ConcreteColleague2 c2 = new ConcreteColleague2(m);

      m.Colleague1 = c1;
      m.Colleague2 = c2;

      c1.Send("How are you?");
      c2.Send("Fine, thanks");

      // Wait for user
      Console.ReadKey();
    }
  }

domingo, 17 de noviembre de 2013

Patrones de diseño, Chain of responsibility

 Esta imagen de http://sourcemaking.com/design_patterns/chain_of_responsibility es muy ilustrativa:
de la misma página el UML :


Es muy revelador la afirmación que allí nos hacen. Chain of Responsibility, Command, Mediator y Observer son diferentes maneras de desacoplar el origen y destino en una comunicación.

y el ejemplo que allí ponen en java solo tiene una clase.Un Handler que bien podría ser "Handler One" sino fuera por que no hereda de nadie. A parte se genera un cliente que con una Array de Handlers sobre los que se executa handle. Este método devuelve boolean que mientras es falso sigue iterando sobre la cadena de Handlers.

sourcemaking.com/design_patterns/chain_of_responsibility/java/1

class Handler
{
    private static java.util.Random s_rn = new java.util.Random();
    private static int s_next = 1;
    private int m_id = s_next++;

    public boolean handle(int num)
    {
        if (s_rn.nextInt(4) != 0)
        {
            System.out.print(m_id + "-busy  ");
            return false;
        }
        System.out.println(m_id + "-handled-" + num);
        return true;
    }
}

public class ChainDemo
{
    public static void main(String[] args)
    {
        Handler[] nodes = 
        {
            new Handler(), new Handler(), new Handler(), new Handler()
        };
        for (int i = 1, j; i < 10; i++)
        {
            j = 0;
            while (!nodes[j].handle(i))
              j = (j + 1) % nodes.length;
        }
    }
}
 
Sospechoso que no se haya respetado el esquema. Queda así desacoplado quien 
envia el mensaje de quien lo recibe?
 
Vamos con otro. 
 
http://java.dzone.com/articles/design-patterns-uncovered-chain-of-responsibility

En este caso en vez de hacerse un triste Array se genera una cadena a través de los propios Handlers.





http://howtodoinjava.com/2013/04/22/chain-of-responsibility-design-pattern/


lunes, 11 de noviembre de 2013

Diseño de patrones, Abstract Factory

Yo recomendaría que se mirara primero Factory Method.
Abstract Factory Method parece lo que dice, una abstracción del Factory Method donde se nos permite crear objetos de manera indirecta  Este patron parece subir un nivel más para crear de forma indirecta  factorias creadoras de objectos. Bien podría llamarse Meta Factory Method.

En http://en.wikipedia.org/wiki/Abstract_factory_pattern


hacer de la factoria un producto abstracto que pueda cambiarse y con el todos sus creaciones.
Aqui lo mismo. Se genera en función de la factoría creada se generarán una familia u otra de productos.

http://javapapers.com/design-patterns/creational-design-pattern/abstract-factory-pattern/
De aquel codigo se extrae el siguiente modelo.



Hecho de menos una variable que me haga accesible lo que produce Wonderland. Esta fabrica crea animales que ejecutan acciones....breath, pero no me da acceso a ellos. No puedo así utilizarlos en el resto de un cliente. Creo que la finalidad de la abstract factory, que es crear familias de productos, no se ve así cumplida. Yo imagino un código en el que hay una animal factory desperdigada que instancia diferentes factorias en funcion de alguna lógica. Vease el mismo código de uso de la página referida:

public class SampleAbstractFactory {
  public static void main(String args[]){
    new Wonderland(createAnimalFactory("water"));
  }
  public static AnimalFactory createAnimalFactory(String type){
    if("water".equals(type))
      return new SeaFactory();
    else
      return new LandFactory();
  }
}

la intención aquí es crear un wonderland. Yo me quedaría con el método createAnimalFactory(String type) que según reciba "water" o no creara Sharks o elefantes. Insisto Meta Factory Method.

http://howtodoinjava.com/2012/10/29/abstract-factory-pattern-in-java/

http://www.javapractices.com/topic/TopicAction.do?Id=128
http://www.allapplabs.com/java_design_patterns/abstract_factory_pattern.htm