YUI 3.3.0 - Nueva versión de la librería de Yahoo!

Recién salida del horno, la versión 3.3.0 de YUI (Yahoo! User Interface) trae unas cuantas novedades para pulir la interfaz de las aplicaciones web sin costo del lado servidor.

Entre las principales características:

• Soporte para FireFox 4, Internet Explorer 9 y Android 2.2.
• Abstracciones más dulces para manipulación de nodos, como show y hide para controlar la visibilidad de nodos completos (o listas de nodos), o wrap, unwrap y otros métodos.
• Un widget para auto-completar entradas de texto (como se ve en la figura a la derecha).
• Gráficos estadísticos (usando una combinación de SVG, Canvas y VML).
• Un widget para tablas de datos, incluyendo paginado y ordenamiento dinámico de manera extensible. Al pie, los interesados pueden ver este video de Tilo Mitra presentando este componente en el evento YUIConf 2010.
• Otro widget para incluir diales de valores (similares a una perilla de volumen) con una granularidad muy fina.
• Utilidad de resize, que activa la posibilidad de cambiar el tamaño de elementos en el browser utilizando los típicos ganchos en las esquinas y lados (ver imagen a la derecha).

Esta librería sigue creciendo y agregando mucha funcionalidad interesante. Mientras escribo esto estoy charlando con Juampi que es más fanático de JQuery (admito que yo también). Sin embargo, no hay que perder de vista que el mundo de Javascript es hospitalario y cuida la convivencia con el uso de recursos como espacios de nombres y pruebas extensivas con elementos externos.

Para quienes quieran aprovechar lo mejor de ambos lados, recomiendo pegar una leída a especialmente a la documentación de JQuery en relación a su uso con otras librerías.

Les dejo el video sobre las tablas de datos (en inglés):

 

Curso Certified ScrumDeveloper (CSD) Track - Verano 2011

Hoy dedico el post a un pequeño aviso, porque se que hay mucha gente interesada en capacitación sobre Scrum, y en particular estos cursos tienen que ver con un área que me parece muy importante y no siempre bien cubierta, que es la parte técnica o de ingeniería que se requiere para poder mantener la calidad iteración tras iteración.

Esta serie de cursos que organiza Kleer (la única empresa en Argentina certificada por la Scrum Alliance para dar estos cursos), tiene el siguiente temario:

* Los conceptos básicos, valores y principios de la agilidad y Scrum 
* Técnicas de análisis de procesos e identificación de historias de usuario 
* Técnicas de estimación y planificación con Scrum 
* La creación de historias de usuario que den lugar a desarrollos evolutivos 
* La identificación y automatización de sus pruebas de aceptación 
* La comunicación con el equipo mediante integración continua 
* Técnicas de diseño y desarrollo dirigido por pruebas (TDD) 
* La utilización de taskboards y métricas ágiles 

El track está orientado a: 



* Gerentes de Proyecto con formación en gestión 
* Gerentes de Proyecto con background técnico 
* Gerentes de Desarrollo 
* Líderes Técnico 
* Arquitectos de Sistemas 
* Desarrollador de Software

 

El programa completo incluye tres cursos independientes:

Curso de Introducción a Scrum

Duración: 8hs.

Fecha de Dictado: 21 de Febrero de 9 a 18hs

Lugar: Microcentro, Buenos Aires

Curso de Estimación y Planificación con Scrum

Duración: 8hs.

Fecha de Dictado: 22 de Febrero de 9 a 18hs

Lugar: Microcentro, Buenos Aires

Curso de Desarrollo Ágil de Software en Scrum

Duración: 24hs.

Fecha de Dictado: Del 23 al 25 de Febrero de 9 a 18hs

Lugar: Microcentro, Buenos Aires

Para consultas: entrenamos@kleer.la

También se puede ver  el calendario completo de Kleer o ver las fotos de los cursos anteriores en su página de Facebook.

 

Json.Net 4.0 acerca el lado dinámico y estático de las aplicaciones web

Json.Net es una librería de alto rendimiento para manejar el protocolos Json (JavaScript Object Notation) desde .NET.

Json es el mecanismo de comunicación más utilizado hoy día en aplicaciones web modernas. La revolución inicial de AJAX (Asynchronous JavasScript And XML) implicaba, como su nombre lo indica, intercambiar XML desde el browser y el servidor, manipulando el DOM de las páginas para refrescar datos, en lugar de volver a traer el HTML completo. Desde hace tiempo esto dejó de hacerse serializando a XML, pasando en cambio a Json porque es más compacto, lo que implica menos tráfico, pero también porque es muchísimo más JSON.parse (en JavaScript puro) o $.getJSON (en JQuery).

Sin embargo, volviendo a .NET, tradicionalmente la convivencia entre el mundo estático y el paradigma eminentemente dinámico que propone Json no fue sencilla. Existe dentro del framework el espacio System.Web.Script.Serialization que contiene un JavaScriptSerializer, pero utilizarlo es una tarea ardua y bastante propensa a errores.

Entre las alternativas abiertas, Json.Net es una de las más populares, y en su reciente versión 4.0 (release 1), aprovecha las nuevas características dinámicas del .NET Framework 4. Más que ninguna otra cosa, el uso de esta librería se simplificó enormemente a partir de aprovechar el nuevo tipo dynamic en .NET (que irónicamente, es un tipo estático más), y el agregado de LINQ to Json.

Veamos el uso de Json.Net con tipos dynamic:

dynamic value = new DynamicDictionary();

value.Name = "Juan Perez";
value.Enabled = true;
value.Roles = new[] {"Admin", "User"};

string json = JsonConvert.SerializeObject(value, Formatting.Indented);
// {
//   "Name": "Juan Perez",
//   "Enabled": true,
//   "Roles": [
//     "Admin",
//     "User"
//   ]
// }

¿No es elegante? Y mucho más sencillo que cualquier cosa tradicionalmente en .NET. Consumamos ahora el Json, a la inversa que en el ejemplo anterior:

dynamic newValue = JsonConvert.DeserializeObject(json);

string role = newValue.Roles[0];
// Admin

Finalmente, LINQ to Json permite (entre otras cosas) realizar consultas directamente sobre un resultado Json de manera simple y eficiente, como en este ejemplo:

var categories =
  from c in rss["channel"]["item"].Children()["category"].Values()
  group c by c into g
  orderby g.Count() descending
  select new { Category = g.Key, Count = g.Count() };

foreach (var c in categories)
{
  Console.WriteLine(c.Category + " - Count: " + c.Count);
}

Algunas otras características de la nueva versión incluyen mejoras en la serialización binaria BSon, Json Schema, e inminentemente estará actualizado el paquete NuGet para instalar esta nueva versión desde Visual Studio directamente o desde la línea de comandos, manejando todas las dependencias que hubiese.

 

Pycon 2011 - Del 9 al 17 de marzo en Atlanta, USA

La conferencia internacional de la comunidad Python de este año llega dentro de poco, a principio de marzo.

Llego tarde con el aviso, pero como siempre, la comunidad apoya financieramente a quienes quieren participar (y tienen buenas razones) pero no cuentan con la capacidad de costearse el pasaje o alojamiento.  Lamentablemente la presentación para solicitar ayuda financiera cerró a principio de este año, pero ténganlo en cuenta para los próximos años, porque al menos con una ayuda parcial muchos pueden llegar a tener la oportunidad.

Ya está disponible el cronograma completo de las charlas, y para quienes no puedan ir (imagino que la gran mayoría de los que están leyendo esto, incluyéndome a mi), recuerden que en general quedan los videos de toda la conferencia, como los del año pasado.

Como muestra para quien no quiere leer toda la lista, seleccioné las charlas que me parecieron más interesantes (a mi, obviamente):

• Panel: Máquinas virtuales de Python
• Creando complejos pipelines de datos en la nube
• Programación Genética en Python
• Exhibición de Atrocidades
• La linguística de Twitter
• Manejando cantidades ridículas de datos con estructuras de datos probabilísticas
• Python para Computación de Alto Rendimiento (High Performance Computing)

Para quienes quieran seguir de cerca más detalles sobre la conferencia, pueden seguir su blog.

Y si algún lector asiduo de Code & Beyond asiste y tiene ganas de compartir notas con nosotros, basta con contactarme.

Raros Lenguajes Nuevos: Scotch

Siguiendo con la investigación sobre lenguajes experimentales o novedosos, hoy les presento Scotch, una creación de Ben Morris.

Ben empezó este proyecto de lenguaje como un ejercicio en Haskell, pero se entusiasmó con el resultado y sigue adelante, después de haberlo dejado abierto en GitHub para contribuciones de cualquiera.

Scotch es un lenguaje funcional que trata de mantener una sintaxis minimalista y expresiva, y agrega algunas características particulares a gusto de su creador:

La asignación es siempre no estricta (lazy), de manera que si definimos "a = b", no estamos pasando valores, sino asignando una expresión. Si luego decimos que "b = 42", al inspeccionar el resultado de "a", se va a evaluar la secuencia y obtendremos 42.

A diferencia de Haskell mismo, Scotch no es puro, y se pueden definir variables que mantengan estado, por lo que no queda libres de efectos colaterales como en lenguajes funcionales puros; también es débilmente tipado, lo que implica que podemos sumar números y strings, por ejemplo, y en lugar de dar error hace conversiones implícitas (siempre que pueda).

Otra característica interesante es la resolución implícita en base a reconocimiento de patrones. Por ejemplo, para definir una función que calcule el factorial de un número, se hacen dos definiciones, una genérica y una específica:

fact(n) = n * fact(n-1)
fact(0) = 1

La primera línea es la definición recursiva clásica, pero por si sola tiene el problema de que nunca terminaría, por lo que se puede definir el caso particular para cuando sea llamada con 0, de manera que en lugar de seguir llamándose a sí misma devuelva 1.

Casi toda la librería de clases está basada en este mecanismo, utilizando recursividad de cabeza y cola (head/tail) y utilizando patrones para manejar los casos límites donde debe cortarse la recursión.

Como casi todos los lenguajes funcionales, permite aplicación parcial y currying, como en este ejemplo:

apply(f, x) = f(x)
add(x, y) = x + y
apply(add(10), 20)

Aquí "apply" se define como la ejecución de una función que recibirá "x" como parámetro. La función "add" recibe dos parámetros y los suma, pero podemos aplicarla parcialmente como en el caso final, utilizando "apply".

También tiene soporte para hilos de ejecución livianos (lightweight threads), o sea que no son hilos reales del sistema operativo, sino implementados por el lenguaje mismo (en este caso utiliza los que provee Haskell).

Finalmente, el autor agregó Tipos de Datos Algebraicos (ADTs) que son como objetos livianos sin definición de clase, y funciones anónimas (lambdas).

La gracia principal de ste intérprete es que la implementación es muy pequeña y es un buen ejercicio tanto de implementación de un lenguaje como de Haskell mismo.