Mis próximas Charlas en Buenos Aires: Actores en C#, Single Page Applications

Tengo varios temas que quiero tratar, en distintos lenguajes y tecnologías. Hoy quiero comentar dos charlas que se vienen, que puedo dar gracias al Microsoft User Group:

Aplicaciones Distribuidas en C#, un modelo de actores

http://www.mug-it.org.ar/Event.aspx?Event=180

Lugar: Auditorio del MUG, Rivadavia 1479 Primer Piso “A”, Buenos Aires.
Fecha y Horario: Miércoles 8 de octubre de 2014 de 18:30 a 20:30 hs.

La idea es presentar conceptos de actores, y actores distribuidos, comentar la principal implementación en Java: Akka. Y luego pasar a discutir y mostrar una implementación en C#

Luego

Desarrollando Single Page Applications con JavaScript

http://www.mug-it.org.ar/Event.aspx?Event=181

Lugar: Auditorio del MUG, Rivadavia 1479 Primer Piso “A”, Buenos Aires.
Fecha y Horario: Miércoles 29 de octubre de 2014 de 18:30 a 20:30 hs.

Veremos las fuerzas que llevan a la aparición de aplicaciones web compuestas de una sola página, con dinámica en JavaScript. Siguiendo “baby steps” y simplicidad, exploraremos cómo podemos armar algún ejemplo con simple JavaScript y JQuery, cómo alimentar los datos desde un servidor con una API expuesta (agnóstico de la tecnología) y luego visitaremos algunas librerías JavaScript del lado cliente que nos ayudan, como Angular y Backbone.

Espero que estas charlas aporten algo a estos temas, entre tantos que son interesantes en estos tiempos. Estoy preparando otras charlas, como Inteligencia Artificial en JavaScript para la JSConf 2014 de Argentina. Y espero que me aceptan alguna más, sobre JavaScript y Ruby, en la RubyConf 2014 de Argentina.

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Posted in .NET, Arg, Argentina, Buenos Aires, C#, Charlas, Desarrollo Web, JavaScript | Comments Off

Resoluciones del Nuevo Mes: Septiembre 2014

Un poco tarde esta vez, es tiempo de revisar mis resoluciones de Agosto:

- Escribir un reemplazo de jQuery para ser usado en tests de consola con Node.js [completo] ver repo
- Escribir funciones simples en JavaScript para manipulación de arreglos [completo] ver repo
- Continuar con proyecto Liqueed [completo] ver repo
- Comenzar con Aktores Distribuido [parcial] ver repo
- Comenzar con AjErl Distribuido [pendiente]

Además, trabajé en:

- Dar una charla de introducción a Express [completo] ver repo ver presentación ver ejemplos
- Mejorar AjScript [completo] ver repo
- Mejorar RuScript, Ruby intérpreter en JavaScript [completo] ver repo
- Refactor SimplePipes [completo] ver repo
- Generar código del servidor Node.js/Express desde RAML [completo] ver repo
- Crear un sitio dinámico descripto en JSON para Express [completo] ver repo
- Mejorar RustScript, intérpreter de Rust en JavaScript [completo] ver repo
- Crear Mochy, test framework a la Mocha [completo] ver repo
- Crear RSharp, language intérpreter de lenguaje R en C# [completo] ver repo
- Refactorizar (y simplificar) SimpleRules, motor de reglas en JavaScript [completo] ver repo
- Primeros ejemplos para SimpleMule [completo] ver repo
- Mejorar salida para SimpleUnit [completo] ver repo

Mis resoluciones para el nuevo mes:

- Aktores distribuidos
- AjErl distribuidos
- Soporte web y ejemplo en RuScript
- Completar Mochy
- Mejorar RSharp
- Trabajar con NodeJs en Deep Learning, Internet of Things, Artificial Intelligence
- Trabajar en Code Generation usando AjGenesis para Node
- Trabajar en Liqueed Project

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Posted in .NET, C#, JavaScript, NodeJs, Proyectos Open Source, Resoluciones | Leave a comment

RuScript, Ruby Intérprete en JavaScript (1) El Proyecto

Desde hace unos meses estoy trabajando en mi tiempo libre en:

https://github.com/ajlopez/RuScript

Y escribiendo todo siguiendo el flujo de TDD (Test-Driven Development) (ver la historia de commits)

La idea es tener un intérprete de Ruby escrito en JavaScript, que pueda correr en el browser o en el server (en este caso con Node.js). No estoy implementando un compilador a JavaScript, porque quiero seguir “baby steps”, y porque veo que la semántica de Ruby puede ser bastante distinta de la de JavaScript en algunos casos. La resolución de métodos a invocar, o ver si una variable es de instancia, de clase o local a una función, son temas que difieren entre los dos lenguajes. Así que me he decantado por escribir un intérprete.

Estoy aplicando “dog fooding”, porque el parser está construido basado en:

https://github.com/ajlopez/SimpleGrammar

Que también estoy aplicando en otros proyectos, como RustScript. (Hay implementación de SimpleGrammar en C#, ver GrammGen). Fragmento de las reglas definidas para el parser de RuScript:

// Expression Level 1
get('Expression1').generate('Expression'),
get('Expression1', 'Plus', 'Expression0')
    .generate('Expression1', function (values) { return new AddExpression(values[0], values[2]); }),
get('Expression1', 'Minus', 'Expression0')
    .generate('Expression1', function (values) { return new SubtractExpression(values[0], values[2]); }),

// Expression Level 0
get('Expression0').generate('Expression1'),
get('Expression0', 'Multiply', 'Term')
    .generate('Expression0', function (values) { return new MultiplyExpression(values[0], values[2]); }),
get('Expression0', 'Divide', 'Term')
    .generate('Expression0', function (values) { return new DivideExpression(values[0], values[2]); }),

// Term
get('Term').generate('Expression0'),
get('Term', 'LeftBracket', 'ExpressionList', 'RightBracket')
    .generate('Term', function (values) { return new IndexedExpression(values[0], values[2]); }),
get('Integer').generate('Term'),
get('@@', 'Name').generate('ClassVariable', 
    function (values) { return new ClassVariableExpression(values[1].getName()); }),
get('@', 'Name').generate('InstanceVariable', 
    function (values) { return new InstanceVariableExpression(values[1].getName()); }),
get('Name').generate('Term'),
get('InstanceVariable').generate('Term'),
get('ClassVariable').generate('Term'),
get('String').generate('Term'),
get('Array').generate('Term'),
get('LeftParenthesis', 'Expression', 'RightParenthesis')
    .generate('Expression0', function (values) { return values[1]; }),
get('LeftBracket', 'RightBracket')
    .generate('Array', function (values) { return new ArrayExpression([]); }),
get('LeftBracket', 'ExpressionList', 'RightBracket')
    .generate('Array', function (values) { return new ArrayExpression(values[1]); }),


Por cada elemento que voy descubriendo, voy armando una expresión, que puede evaluarse dado un contexto (un contexto indica cuales son las variables accesibles en determinado momento, y sus valores respectivos). Ejemplo:


function NameExpression(name) {
    this.evaluate = function (context) {
        var value = context.getValue(name);
        
        if (typeof value == 'function')
            return value();
        
        return value;
    };
    
    this.getName = function () { return name; };
    
    this.setValue = function (context, value) {
        context.setLocalValue(name, value);
    }
}

function InstanceVariableExpression(name) {
    this.evaluate = function (context) {
        if (!context.$self.$vars)
            return null;
            
        return context.$self.$vars[name];
    };
    
    this.getName = function () { return name; };
    
    this.setValue = function (context, value) {
        if (!context.$self.$vars)
            context.$self.$vars = { };
            
        context.$self.$vars[name] = value;
    }
}

function ClassVariableExpression(name) {
    this.evaluate = function (context) {
        if (!context.$self.$class.$vars)
            return null;
            
        return context.$self.$class.$vars[name];
    };
    
    this.getName = function () { return name; };
    
    this.setValue = function (context, value) {
        if (!context.$self.$class.$vars)
            context.$self.$class.$vars = { };
            
        context.$self.$class.$vars[name] = value;
    }
}

function ConstantExpression(value) {
    this.evaluate = function () {
        return value;
    };
}


Tengo acceso a JavaScript desde Ruby, por ejemplo, un test:


exports['Evaluate JavaScript global name'] = function (test) {
    global.myglobal = 42;
    var context = contexts.createContext();
    var parser = parsers.createParser("js.myglobal");
    //parser.options({ log: true });
    var expr = parser.parse("Expression");
    var result = expr.value.evaluate(context);
    test.equal(result, 42);
}



El “namespace” js es el que posibilita acceder a las variables definidas en JavaScript y a todo su ecosistema, ya sea en el browser o en el servidor Node.


Espero poder presentar mi avance en la RubyConf 2014 de Argentina.


Próximos pasos: acceder a los “require” de Node.js, ejemplos de sitios web usando Node.js/Express, ejemplos de consola, ejemplos en el browser, etc.


Nos leemos!


Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Posted in Interprete, JavaScript, Node, NodeJs, Proy, Proyectos Open Source, Ruby, RuScript, Test-Driven Development | Comments Off

Ágiles Argentina 2014 – Primeras Jornadas Nacionales de Metodologías Agiles

Argentina (y Buenos Aires) sigue siendo un lugar de gran actividad en la difusión de lo ágil en el desarrollo de software y otros ámbitos. Se vienen dos días de jornadas, viernes 26 y sábado 27 de Septiembre, ver:

http://www.meetup.com/agiles-bsas/events/191103222/

Friday, September 26, 2014 9:00 AM
to Saturday, September 27, 2014, 6:00 PM

Universidad de Belgrano
Lacroze 1947, Buenos Aires (map)

Realizaremos nuestras primeras Jornadas Nacionales de Metodologías Agiles, en Formato Open Space.
Nos juntamos con ganas de compartir experiencias, buenas prácticas y aprender más sobre metodologías agiles.

Más información en el sitio oficial:

http://aa2014.agiles.org/

El formato es Open Space, no hay una agenda predefinida. Se puede ir proponiendo y votando temas en:

https://agilesargentina.uservoice.com/forums/261590-%C3%81giles-argentina-2014-26-y-27-sept-en-buenos-aire

Ágiles Argentina 2014, las Primeras Jornadas Nacionales de Metodologías Ágiles, es un evento de la Comunidad Ágil Argentina. Tendrá como sede a la Universidad de Belgrano , en la Ciudad de Buenos Aires, los dias 26 y 27 de Septiembre. Ver detalles del evento en http://aa2014.agiles.org/

Una novedad, el catering (comida, bebidas, infusiones, etc) será autoorganizado, comprometerse en alguno de los puntos de:

http://aa2014.agiles.org/catering-auto-organizado/

Si esto no es lo ágil, lo ágil ¿donde está? :-)

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Posted in Agile, Argentina, Buenos Aires | Leave a comment

Hackathon Abierto en Buenos Aires

El próximo sábado 30 de Agosto, se realizará el primer Hackathon abierto del grupo Java Argentina, en las oficinas de MuleSoft en Buenos Aires. Más detalles en:

http://www.meetup.com/jugargentina/events/197071352/

Saturday, August 30, 2014
11:00 AM to 8:00 PM
MuleSoft
Av Corrientes 316, Capital Federal, Buenos Aires (map)

Planta Baja

Vamos a estar organizando el primer hackathon abierto del grupo. La idea es juntarnos a las 11AM, arrancar al medio dia, y terminar a las 8pm. Ahi vienen las presentaciones, algunos premios y cerramos con algo para comer y tomar.

Las reglas:

• Se puede usar cualquier lenguaje, no solo Java o que corra en la JVM. 

• Hay que contribuir a un proyecto Open Source. Puede ser cualquiera, no necesariamente famoso (ej: Mule ESB, Spring, Go, Vertx, etc). 

• Dura 8 horas. 

• Equipos de 1 hasta 5 integrantes

• Se va a evaluar el impacto de la contribución.

Estamos definiendo algunos premios para el equipo ganador y menciones. Apenas tengamos algo les avisamos.

Prometemos comida, bebidas y diversion!, por lo que pedimos que se registren todos los participantes, así podemos calcular bien las cantidades. 

Apuren a anotarse ya que vamos a tener cupo limitado!

Lo bueno es que puede usarse cualquier lenguaje, y al parecer, puede trabajarse sobre un proyecto nuevo o existente, mientras sea Open Source. Espero que haya cerveza :-)

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Posted in Buenos, Buenos Aires, Hackathon, Java, Programacion, Reunion | Leave a comment

Próximo Meetup JavaScript en Buenos Aires: Express y D3

Se viene en Septiembre el próximo meetup de JavaScript, en Buenos Aires, ver detalles para el 11 de Septiembre en:

http://www.meetup.com/Meetup-js/events/202355182/

Retomamos la sana costumbre de reunión y discusión tecnológica con colegas de la comunidad.

Como siempre, la modalidad es la misma, arrancamos 6:30, y para los que van llegando tenemos algo para tomar, comer y charlar. A las 7 arranca la primer charla. Charlas:

Angel ‘Java’ Lopez – Introduccion a Express
Juan Pablo Kutianski – Introducción a D3

Como en la última oportunidad vamos a transmitir el evento por HO para los que no puedan venir.
Los esperamos!

Como otras veces, organizado por la gente de @scvsoft. Seguro, picada y cerveza (también medialunas y bebida cola, urrgg… :-)

Sí, voy a estar dando una charla corta sobre Express, el framework web más popular montado sobre Node.js. Veremos de usar el generador básico que viene con Express 4.x, qué funcionalidad básica da, el manejo de los middleware, el ruteo, la generación de vistas usando lenguajes de templates, y la exposición de APIs devolviendo JSON simple. Haremos código en vivo sencillo, y luego pasaré a ejemplos armados, con acceso, por ejemplo, a MongoDB. Realmente, Express es muy flexible, y se ocupa de pocas cosas, dejándonos a nosotros aprovechar el resto del ecosistema de Node. En ese sentido, no es un framework “pesado” o con mucho “opinionated”. Para algunos, esto es una ventaja, pero para otros no. A mí ese “approach” me gusta, porque permite elegir herramientas y librerías según el contexto y la necesidad, en vez de embarcarse en una gran solución única. Pero verán Uds. que les parece.

También estará el bueno de @baldpower dando una charla sobre D3, la librería de JavaScript para gráficos dinámicos, y hasta en tiempo real. Ver

http://d3js.org/

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Posted in Buenos Aires, JavaScript, Meetup, NodeJs | Leave a comment

Resoluciones del Nuevo Mes: Agosto 2014

Es tiempo de escribir las nuevas resoluciones, y revisar las de Julio:

- Mejorar AjGenesisNode generación de código para Express [completo] ver repo
- Mejorar AjGenesisNode generación de código para Sinatra [parcial] ver repo
- Primer generación de código de AjGenesisNode para Laravel [pendiente]
- Carga de módulos, exportar, en lenguaje Mass [pendiente]
- Continuar con SharpBus [completo] ver repo
- Continuar con Dynamic Site [pendiente]
- Give a talk about Node.js/Express [completo]
- Mejorar mi sitio personal [completo] ver repo
- Escribir TDD Post [pendiente]
- Escribir C# Posts [completo] ver posts
- Caso distribuido usando Aktores [pendiente]
- Revisar, refactorizar y continuar la implementación de RustScript [completo] ver repo

Additionally, I worked on:

- Comenzar SimpleList [completo] ver repo
- Comenzar SimpleJQuery [completo] ver repo
- Mejorar SimpleMule [completo] ver repo
- Comenzar SharpGD, Graph Database in C# [completo] ver repo
- Mejorar SimpleBus [completo] ver repo
- Mejorar SharpGo [completo] ver repo
- Mejorar ExpressSamples [completo] ver repo
- Mejoras menores en ScaScript [completo] ver repo
- Mejorar ScalaSharp [completo] ver repo
- Escribir Friends sample for JavaScriptSamples [completo] ver repo
- Escribir Angular examples [completo] ver repo
- Agregar método remove a OStore [completo] ver repo
- Colaborar con el proyecto Liqueed [completo] ver repo

Nuevas resoluciones para Agosto 2014:

- Escribir jQuery mock a ser usando en test de consola desde Node.js
- Escribir simples funciones en JavaScript para manipular arreglos de objetos
- Continuar colaborando con el proyecto Liqueed
- Comenzar con Aktores ejemplo distribuido
- Comenzar con AjErl ejemplo distribuido

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Posted in .NET, C#, JavaScript, NodeJs, Proyectos Open Source | Leave a comment

Resoluciones del Nuevo Mes: Julio 2014

Un nuevo mes comenzó, tiempo de revisar mis resoluciones de Junio 2014, y escribir las nuevas:

- Continuar AjErl [pendiente]
- Continuar ScalaSharp [completo] repo 
- Continuar SharpGo [completo] repo
- Alcance de variables en lenguaje Mass [completo] repo
- Comenzar SimpleItems [pendiente]
- Continuar SimpleApps [partial] repo
- Continuar ClojSharp [pendiente]
- Continuar DictSharp [pendiente]
- Primer caso de uso distribuido de AjErl [pendiente]
- Primer caso de uso distribuido de Aktores [pendiente]
- Escribir C# Posts [completo] Posts
- Escribir TDD Post [completo] Post
- Mejorar el código de mi sitio personal [completo]

También estuve trabajando en:

- Crear y publicar primer versión SimpleCurry, para programación funcional en JavaScript [completo]  repo
- Crear y publicar primer versión LoadJsons, lee un modelo JSON desde varios archivos, para JavaScript/Node [completo]  repo
- Crear un sitio dinámicado, definido por JSON, para Express 4 [completo]  repo
- Generar código para Express 4 usando AjGenesisNode [completo]  repo
- Generar código Sinatra usando AjGenesisNode [completo]  repo
- Mejorar AjGenesisNode, AjGenesisNode-Model, AjGenesisNode-Entity [completo]  repo repo repo
- Continuar DylanSharp [completo]  repo
- Crear SharpBus, un service bus tipo Mule, en C# [completo]  repo

Estas son mis resoluciones para Julio 2014:

- Seguir mejorando la generación de código de AjGenesisNode para Express
- Seguir mejorando la generación de código de AjGenesisNode para Sinatra
- Primer generación de código de AjGenesisNode para Laravel 
- Mejorar la carga de módulos y la exportación de variables/funciones en el lenguaje Mass
- Continuar con SharpBus
- Continuar con Dynamic Site
- Dar una charla sobre Node.js/Express
- Dar una jornada sobre Node.js/Express
- Seguir mejorar el código de mi sitio personal
- Escribir post de TDD
- Escribir posts de C#
- Caso de uso distribuido en Aktores
- Revisar, refactorizar y continuar la implementación de RustScript

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Posted in 1389, 14005, 15035, 15550, 18052, 5374 | Leave a comment

Introducción y Jornada Completa a Node.js en Buenos Aires

Gracias a la gente del MUG voy a dar una charla introductoria (gratuita, pero hay que registrarse) ahora en unos días acá en Buenos Aires:


http://www.mug-it.org.ar/Event.aspx?Event=162


Inicio: 23.07.2014 18:30hs, hasta las 20 y monedas | Lugar: Rivadavia 1479 1er Piso


JavaScript no solo tiene cada vez más influencia en el desarrollo cliente/nativo, también ha sabido crecer en el lado del servidor. En esta sesión gratuita veremos la implementación de Node.js, un programa que ejecuta JavaScript. Vacantes limitadas. Inscripción previa obligatoria.


Node.js permite el desarrollo de servidores de distintos protocolos, procesamiento distribuido, y desarrollo web, explotando la entrada/salida asincrónica para mejorar el rendimiento. Bravemente exploraremos como se escribe y ejecuta JavaScript en Node.js, el sistema de módulos, el ecosistema de módulos que tiene, una introducción a desarrollar sitios web con Express, con ejemplos.


Luego, viene una jornada (de un día, con costo, traer notebook para aprovecharla):


http://www.mug-it.org.ar/Event.aspx?Event=163


Lugar: Auditorio del MUG, Rivadavia 1479 Primer Piso “A”, Buenos Aires.


Fecha y Horario: Miércoles 30 de julio de 2014 de 9:00 a 17:00 hs. 


 


Contenidos:

1. Introducción a Node.js

1.1. Programación Javascript desde Node sobre el motor V8 

1.2. Entrada/Salida asincrónica 

1.3. Módulos 

1.4. Manejador de paquetes npm

1.5. Elementos de Test-Driven Development 

2. Programación Web con Node.js 

2.1. Módulo HTTP 

2.2. Manejo asincrónico 

2.3. Acceso a MongoDB

3. Programación Web con Express

3.1. Concepto de Middleware 

3.2. Lenguaje de Templates 

3.3. Ejemplos con Páginas y Acceso a Datos

3.4. Programando con JSON

3.5. Elementos de Socket.IO

(*)  Instalar previamente el siguiente software:

Instalador de Node (para Windows y otros) http://nodejs.org/download/

Git bajarlo de http://git-scm.com/



La idea de la jornada es practicar Node.js, desde el inicio, y ver de instalar, levantar y examinar ejemplos, de consola y web, para ir viendo cómo es el tema de desarrollo con Node.js, cómo se usan los módulos, el ecosistema que existe, el manejador de paquetes NPM, y Express como framework web. Usaremos MongoDB para la persistencia.


Como siempre, el material de los dos eventos estará en mi cuenta de GitHub, y algún anuncio habrá por acá.


Nos leemos!



Posted in 10747, 14005, 15550, 17044 | Leave a comment

El valor de TDD (Test-Driven Development) (1)

En estos últimos años he estado practicando deliberadamente TDD (Test-Driven Development) y trabajo en proyectos personales usando el flujo de trabajo de esta disciplina casi todos los días (ver mis posts de TDD y los commits en GitHub) Y también he trabajado en proyectos profesionales, con y sin TDD. Y luego de tanto código y proyectos, pienso que ya tengo un panorama de cuáles son los valores que agrega TDD a un proyecto que tenga desarrollo de software y cuáles son los problemas que podemos tener si no usamos TDD..


Primero, hay que recordar que un proyecto profesional puede ser más que programar código: he escrito que un proyecto BUENO es el que resuelve un problema (ver Un Buen Proyecto). No es solamente programar código, y menos programar código como nos parece o nos gusta. Lo importante es solucionar el problema que tiene quien nos contrata como equipo o como desarrollador individual.


Hecha esa aclaración ¿que es lo que vi de más valor siguiendo TDD, tanto en proyectos personales como profesionales? El primer punto de valor que veo como evidente, espero poder transmitirles el concepto, es:


TDD NOS EMPUJA A LA SIMPLICIDAD EN EL SOFTWARE QUE CONSTRUIMOS


Como cada vez que escribimos un test tenemos que pasarlo de rojo a verde con el código más simple, entonces esa simplicidad se va transmitiendo a lo que estamos construyendo.


Antes de seguir con el tema simplicidad, recordemos que no es sólo hacer TDD. Por ejemplo, tengo en gran importancia implementar casos de uso (ver TDD y Casos de Uso). Sin una serie de casos de uso a implementar, corremos el peligro de salirnos del carril y escribir algo que nos parece lindo, interesante, pero no soluciona el problema que tenemos que atacar en el proyecto.


Entonces, con TDD y guiado por los principales casos de uso, vamos diseñando un software. TDD es un proceso de diseño de software, no de escribir tests o de testing. TDD nos lleva a construir un software lo más simple posible, y los casos de uso nos guían hacia donde realmente esta el problema a resolver. Me gusta decir que aplicamos “baby steps”, hacia un diseño incremental de la solución (ver TDD y Baby Steps). No digo no hacer diseño de antemano: hago algo de diseño,  pero en la servilleta del desayuno, y apenas un poco. No pongo diseño imaginado en el código HASTA QUE NO LLEGUE EL TEST que lo amerite.


No olvidarse del otro importante paso: el refactor. Es ahí donde vamos a poner lo que conocemos para mejorar el código. Y es notable: TDD, como flujo de trabajo, nos va enseñando sobre diseño de código, de forma incremental. Al llegar un nuevo test, podemos ver que lo que habíamos escrito hasta entonces no sea lo óptimo, y refactorizamos la implementación interna. En este paso puede aparece la aplicación de patrones. Y eso es bueno: aparecen en un contexto, el de refactorización, no aparecen “del aire” o porque se nos ocurre a nosotros que hay que aplicar tal patrón. Recordemos que unos de los atributos de un patrón de software es el contexto donde se aplica. En la etapa de refactor podemos descubrir o poner de manifiesto ese contexto y ahí entonces reción aplicar el patrón. Si hacemos diseño de antemano, podemos caer (y lo he visto suceder) en la “patronitis”: agregar todos los patrones habidos y por haber, porque pensamos que son la mejor práctica. Hacer eso es una variante de “optimización prematura es la madre de todos los males”. Lo que nos va a enseñar TDD es que no hace falta pensar todo de antemano, rompiendo YAGNI. Lo que vamos creando con TDD en general va estar en “buena forma” para adaptarse a los nuevos casos de uso y nuevos tests que aparezcan. 


Y aca esta el otro valor que agrega, paralelo a la simplicidad: no solamente el código va creciendo con la simplicidad necesaria, sino que tambien esta en su mayor parte ajustado a lo que nuestros tests piden, no a lo que nosotros queremos o imaginamos que necesita tener nuestro código. El diseño del software en construcción, de esta forma, es como la confección de un traje a medida, que va calzando perfecto en cada iteración a lo que necesitamos implementar. 


Para que no todo sea cháchara en este post, pongo un ejemplo concreto, que ya he expuesto en otros posts (ver, por ejemplo, Desarrollando una Aplicación usando TDD). Supongamos que necesitamos devolver una lista de nuestros productos por categoría, digamos, en una API. ¿Qué hacemos en el controlador? He visto muchas veces que ya al primer test se le coloca un repositorio “mockeado” porque, claro, necesitamos el patrón repositorio ¿no?. Así nace la “paternitis”. NO: si somos consecuentes con el flujo TDD, lo más simple es ir entregando al controlador…. un LISTA DE PRODUCTOS. Solamente cuando tengamos más casos de uso, y veamos que la lista de productos la necesitamos en otros lados, vamos separando su existencia en otros componentes. He visto también que llegado al primer o segundo test, o aún antes, ya se está diseñando la base de datos para tener una tabla de productos y otra de categorías. Yo pregunto ¿quién, en qué el test, pidió eso? ¿qué test puso persistencia en el tapete? Muchas veces, NINGUNO. De nuevo, hay que ir implementando lo que nos pide el test, nada más, no hay que agregar nuestra propia “bajada de línea”, “ruptura de YAGNI”, como cuando pensamos “vamos a necesitar repositorio, vamos a necesitar persistencia” y entonces, necesitamos YA ponerlo y YA ponerlo como mock y así. Ese es el camino de romper la simplicidad de la que hablo.


De esta forma, el software que tengamos en construcción, crece como un organismo: de a poco, de forma controlada.


Seguiré con el tema del valor que agrega TDD, en los próximos posts: aumenta la calidad de código, permite la evolución y la adaptación al cambio, permite reducir la cantidad de bugs, permite arreglar los bugs detectados de forma más rápida, deja al proyecto en buena forma para que lo tomo otro equipo, etc.


Nos leemos!


Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez


 

Posted in 10549, 11699, 1392 | Leave a comment