Novedades de Microsoft en direcciones interesantes (+ video)

Ayer hubo un evento de lanzamiento de Visual Studio 2013, donde Microsoft conato una serie de novedades. Algunas eran sabidas, dos en particular me llamaron la atención, porque me parece que son movimientos en la dirección correcta.

Finalmente se mostró el primer preview de la versión online de Visual Studio, que al parecer sólo se puede ver en videos por ahora, pero suena interesante. A pesar de estar bastante pegada a TFS online, una plataforma que no me resulta especialmente atractiva, mantiene y expande una actitud más abierta, con fuerte integración con Git, como se puede ver en el video que dejo debajo. Por otro lado, como verán, Node mantiene una presencia muy fuerte, con gran cantidad de ejemplos. La idea de que este entorno sea gratuito para grupos reducidos es importante.

Leí un par de notas periodísticas que mencionan esta iniciativa como una competencia directa de Microsoft a GitHub, que realmente me hicieron reír. Es cierto que algunos desarrolladores muy establecidos en el ecosistema Microsoft pueden preferir moverse en algún momento, pero no veo ninguna posibilidad de que algo de esto se plantee como una alternativa masiva. Al contrario, veo que son plataformas que pueden complementarse, y aunque no tengo chance de probarlo todavía, intuyo por las demos que tranquilamente se podría trabajar con esta IDE online desde un repositorio de GitHub. No veo ninguna dificultad técnica, y confío que el espíritu de apertura que intentan mantener desde este grupo de Microsoft no genere una barrera artificial.

Queda un video breve (~ 5 min) donde se muestra un proyecto Node, y cómo se utiliza el entorno, altamente integrado con TypeScript, que es otra estrategia interesante, sobre todo por lo poco intrusiva:

 

El otro gran anuncio es una asociación más directa con la gente de Xamarin, la empresa formada por los iniciadores del proyecto Mono, y todavía uno de los mayores grupos contribuyendo con él, que se dedica a permitir el desarrollo de aplicaciones nativas (no híbridas) en C# para iOS, Android, Windows Phone, OS X y otras plataformas (por extensión).

Lo interesante de esta asociación es que más allá de temas comerciales, tiene puntos técnicos muy importantes, logrando abrir más las puertas del ecosistema Microsoft / .NET hacia el exterior. Por ejemplo, las Portable Class Libraries (PCL) de .NET son ahora realmente abiertas y soportan el movimiento de librerías entre cualquier plataforma, facilitando muchísimo el intercambio también a nivel NuGet (el mecanismo de manejo de dependencias abierto del mundo .NET).

En total, esta noticia parece más de índole comercial, pero para mi el acercamiento al equipo de Xamarin y el reconocimiento del valor de llegar a estas plataformas fuera de su control son un blanqueo y una buena actitud que espero seguir viendo desde Microsoft hacia afuera.

Monkey Square: desarrollando el ecosistema Open Source en .NET

Un grupo conformado por algunos de los sospechosos de siempre en el ambiente .NET han formado esta organización sin fines de lucro para evangelizar y apoyar activamente el desarrollo de proyectos y plataforma de código abierto alrededor de .NET.

Hay algunos ex-Microsoft como Phil Haack (actualmente en GitHub), Joseph Hill, cofundador de Xamarin con Miguel de Icaza, Dale Ragan, cofundador de Moncaí (una Plataforma como Servicio basada en Mono), e incluso un empleado activo (hiper-activo, en realidad) de Microsoft como Scott Hanselman.

Entre otras cosas, esta organización es actualmente la responsable de la conferencia MonoSpace 2012, que se realizará del 17al 19 de octubre en el Microsoft NERD Center (no, el nombre no es chiste) de Cambridge, Massachusetts. Los interesados en la conferencia puede acceder a todas las presentaciones de la edición del año pasado en InfoQ.

No hay muchas más noticias por ahora, pero parece un movimiento interesante. 

Video: BrowserID - otro mecanismo de Identidad en la web

Mozilla Persona es la implementación en en FireFox de BrowserID, un nuevo Identity Provider impulsado por Mozilla Identity misma junto a otros interesados.

Como en otros casos, este es otro mecanismo de Single-Sign-On para la web, y aunque todos lo plantean como el mecanismo único para identificarse, en la práctica sigue habiendo mucha fragmentación porque no todos los sitios (o navegadores) soportan todos los protocolos, que sin embargo, son generalmente interoperables (en esta interoperabilidad, casualmente, se basan las herramientas que genera en este espacio la nueva empresa de mi amigo Mati Woloski, Auth10; a quien menciono por ser de las personas que más saben de este tema sobre la Tierra).

 Lo cierto es que Mozilla agrega a este nuevo protocolo, basado en certificar la identidad utilizando una cuenta cualquiera de email, el soporte dentro del navegador, para poder brindar una experiencia de usuario mejorada. Como siempre, los desafíos son que otros navegadores adopten el modelo (cosa en la que no tengo enormes esperanzas), y que muchos sitios comiencen a soportar el mecanismo (o más probablemente, que productos como Auth10 o Janrain Engage) agreguen soporte para este nuevo proveedor.

Para los interesados en el tema, hay documentación para desarrolladores y un completo post de Lloyd Hilaiel, del equipo de BrowserID, explicando todo el mecanismo.

 

Y finalmente les dejo un video corto demostrando como funciona:

Llegaron los monos a Heroku (+ video)

Heroku es un servicio PaaS (Plataforma como Servicio), que permite publicar en la nube aplicaciones Ruby (el lenguaje soportado originalmente), Node.js, Scala, Java y Python.

La plataforma es fabulosa porque tiene un modelo de escala muy interesante, y es muy sencillo montar aplicaciones de manera gratuita por bastante tiempo, hasta que el volumen de tráfico y consumo de recursos requiere que se pase a un plan pago (lo que en muchos casos debería suceder cuando la aplicación ya está generando dinero).

Por otro lado, Heroku es una de la plataformas en su tipo con mayor simpleza para el despliegue y mantenimiento de las aplicaciones. Fuertemente basada en los flujos de trabajo de GIT, el sistema distribuido de control de versiones (creado por Linus Torvalds), para las plataformas soportadas directamente, desplegar una aplicación es tan simple como ejecutar desde la línea de comandos, parados sobre nuestro repositorio de GIT local:

git push heroku master

Y listo. Heroku se encarga de resolver todas las dependencias de acuerdo a las convenciones de cada plataforma (bundle en Ruby, NPM en Node, etc), lo que usualmente es muy rapido, y hace que nuestra aplicación esté disponible en segundos.

Bueno, esto ya debe ser conocido por la mayoría de los lectores de este blog. La novedad es que Ben Hall, un colega desarrollador que trabaja regularmente en ASP.NET y Rails, encontró la manera de desplegar en Heroku una aplicación basada en Mono (la implementación abierta y gratuita de .NET).

La aplicación de prueba está escrita en C# y basada en el framework Nancy (basado en Sinatra, un framework web minimalista para Ruby; Nancy es el nombre de la hija de Frank Sinatra). Como Ben explica en este post, este mecanismo no está soportado en lo más mínimo por Heroku, pero abre el camino para que eventualmente sea soportado (nótese que todos los lenguajes soportados además de Ruby fueron agregados en los últimos seis meses, aproximadamente).

Aunque el proceso es bastante experimental (requiere desplegar unas cuantas piezas de infraestructura sobre el stack Cedar de Heroku, que es el más nuevo de los sabores, y provee proceso sobre Ubuntu 10.04, y sobre el que corren todos los nuevos lenguajes.

La prueba final de que esto puede pasar de ser un experimento a algo más es que Chris Kemp, del equipo de Soluciones Técnicas de Salesforce.com (la compañía dueña de Heroku) grabó este video (en inglés) en el que muestra cómo poner en práctica la receta de Ben. Disfrutenlo, y esperemos que dentro de un tiempo podamos tener soporte más directo para Mono en Heroku.

C++ sigue siendo relevante (y está de moda de nuevo)

Mientras que el Assembler (mi primer lenguaje de programación) perdió gran parte del brillo salvo para quienes programan para una plataforma exclusiva de hardware, C y C++ siguen siendo los lenguajes preferidos para gran parte del desarrollo de aplicaciones que requieren alto desempeño y optimización de recursos.

Es cierto, son lenguajes complejos y un tanto problemáticos (un gran poder conlleva una gran responsabilidad, decía el tío de Spiderman), y en la práctica pocas aplicaciones se escriben completamente en C++ pero hoy día pocas aplicaciones se escriben en un único lenguaje, de todas maneras (entre manipulación de datos, scripting, lógica, etc, casi siempre usamos dos o tres sin darnos cuenta). En el caso clásico de los juegos, por ejemplo, los motores de animación, detección de colisiones, etc, muchas veces se escriben en C++ mientras que la lógica final suele escribirse a más alto nivel, en lenguajes como LUA o Python.

Pero C/C++ siguen manteniendo un amplio reinado (como puede verse en este mapa creado por Elena Sagalaeva y Vladimir "Jim" Gorshunin), y su avance sigue siendo importante aun cuando usamos lenguajes dinámicos o compiladores a demanda (estilo Java/.NET), porque los motores por debajo son cada vez más eficientes gracias a los progresos en C++, en algún punto. También, el auge de los dispositivos móviles (teléfonos y tabletas), ha hecho que la economía de recursos y el tiempo de respuesta  (sobre todo en interfaces multitouch) sea nuevamente un tema crítico.

Entre otras cosas, estos lenguajes siguen siendo casi únicos en la capacidad de determinar el consumo de ciclos de procesador y memoria en forma explícita, y los agregados a C++ 11 lo han hecho un poco más flexible y -un poco- menos peligroso, al utilizar técnicas modernas como inferencia de tipos, mejoras en el soporte de genéricos, inicializadores, expresiones lambda, todo un nuevo modelo para ejecución de tareas en múltiples hilos, incluyendo variables por hilo de ejecución, soporte para recolección de memoria, y muchísimas otras características basada en la biblioteca estándar, como soporte de tuplas y tablas hash, expresiones regulares, punteros inteligentes, meta-programación a través de plantillas, y muchísimo más.

Para una lista completa de novedades sobre el estándar aprobado recientemente, incluyendo preguntas frecuentes, pueden leer este documento mantenido por el creador de C++, Bjarne Stroustrup.

Finalmente, demostrando que el interés por el código nativo y la nueva versión de C++ es generalizado entre los participantes más activos en la industria, en los primeros días de febrero se realizará en Redmond, Washington, EEUU (dentro de uno de los auditorios del Campus de Microsoft) la conferencia Going Native 2012, que cuenta con un interesantísimo grupo de expositores (vean debajo los nombres y las empresas de las que provienen). El evento podrá ser presenciado en vivo o más tarde a demanda, desde la misma página.

Día 1 (2 de febrero)

• (Sesión de apertura) Bjarne Stroustrup (AT&T Fellow): C++11 Style
• Hans Boehm (HP Labs): Threads and Shared Variables in C++11
• Stephan T. Lavavej (Microsoft): STL11 – Magic && Secrets
• Andrei Alexandrescu (Facebook; diseñador también del lenguaje D): Variadic Templates are Funadic
• Herb Sutter (Microsoft), Bjarne Stroustrup, Andrei Alexandrescu, y Hans Boehm: Interactive Panel: The Importance of Being Native

Dia 2 (3 de febrero)

• Chandler Carruth (Google): Clang - Defending C++ from Murphy's Million Monkeys
• Andrei Alexandrescu: Static If I Had a Hammer
• Bjarne Stroustrup y Andrew Sutton: A Concept Design for C++
• Panel de cierre donde la audiencia podrá preguntar a todos los oradores

Espero que los programadores nativos los disfruten.

El año del código abierto para .NET (+video: .NET en Chrome!)

Se va terminando el año 2011 y mirando hacia atrás desde la perspectiva de la comunidad .NET somos varios los que vemos que este año fue sumamente importante para el código abierto en ese entorno. Y no estoy hablando solamente de Microsoft, ya que .NET ya tiene entidad independiente de su creador original.

Para los que tienen ganas de leer posts más largos y en inglés, recomiendo los de Phil Haack (hasta hace poco líder del ASP.NET MVC en Microsoft, ahora trabajando para GitHub) y Miguel de Icaza (el incansable líder del proyecto Mono).

Este post es un resumen breve del contenido que ellos exponen, con algunas apreciaciones personales.

El modelo Open Source fue algo que Microsoft, con su tradición de secretos y licenciamiento complejo, tardó muchísimo en incorporar. Y más complejo aún el modelo de Free Software, que implica tanto apertura como gratuidad de los productos. Sin embargo, desde hace años, con pioneros como IronPython, el DLR, y más tarde ASP.NET MVC, varios productos de la plataforma de desarrollo empezaron a producirse bajo esta premisa. Un punto culminante de esta iniciativa fue en 2008, cuando Microsoft anunció que comenzaba a incluir jQuery en Visual Studio, colaborando con el proyecto (de manera abierta, como cualquier otro) e incluso brindando soporte sobre el mismo.

Al entender la importancia del movimiento, Microsoft finalmente generó una Fundación llamada OuterCurve (originalmente se llamaba CodePlex, pero usar el mismo nombre que su sitio de alojamiento de código resultaba muy confuso), que como la Fundación Apache, permite resguardar los derechos del código y de los autores en un ambiente controlado. Muchos proyectos hoy existen bajo OuterCurve, aunque hay muchos también directamente en Apache.

Finalmente, este año Microsoft avanzó más en ese sentido, mejorando notablemente las condiciones de búsqueda e integración de código abierto propio o de terceros, a través de NuGet, el administrador de versiones para .NET, inspirado en Ruby Gems y similares. NuGet se integra en Visual Studio o puede usarse en la línea de comando, y permite buscar en un catálogo muy abundante actualmente de componentes abiertos, instalarlos en nuestros proyectos, incluyendo todas sus dependencias, e incluso automatizar tareas relativas a su instalación y uso, como declararlos en configuraciones, generar código u otros artefactos desde la consola, etc. NuGet también facilita mantener actualizadas, si es necesario, todas las versiones de estos paquetes.

Pero como decía al principio, .NET va más allá de Microsoft (y de Windows) desde hace tiempo, y la alternativa principal es el proyecto Mono, que como Miguel comenta en su post, tuvo un año increíble, lleno de novedades. La más importante para el proyecto mismo fue la venta de Novell a Attachmate y el posterior corte del equipo completo de Mono, que rápidamente se reincorporó como Xamarin, un reflejo directo de Ximian, la compañía original de Miguel y Nat Friedman que Novell adquiriese años antes.

Más allá de la reagrupación, que no redujo en lo más mínimo el impulso del proyecto Mono, a pesar de que el equipo de Xamarin se concentró en poner en el mercado MonoTouch y Mono for Android (productos comerciales que les permiten seguir sobreviviendo). Mientras tanto, el equipo de Mono (que excede también a Xamarin, como todo gran proyecto abierto) entregó este año una avalancha de tecnologías (más allá de varias versiones del runtime mismo de Mono y de MonoDevelop, su IDE), incluyendo:

• .NET en el navegador (al menos en Chrome) a través de Mono corriendo en el Native Client de Google. De hecho, Google mostró Mono en Chrome en un evento reciente, del que dejo el video al final de este post. Aunque el año pasado ya se podía programar en mono y utilizar el compilador estático para ejecutar código dentro de Chrome, este año ya se puede ejecutar el compilador a demanda (JIT) de Mono.
• MonoMac es una extensión de Mono para programar aplicaciones para Mac OS X en .NET, incluyendo el soporte para Cocoa y todo el entorno del sistema operativo. Se programa utilizando MonoDevelop y algunas herramientas nativas como los diseñadores de XCode.
• MonoGame (ya comentado antes en este blog) es un port del entorno de desarrollo de juegos XNA de Microsoft, pero abierto y con mayor alcance en plataformas.
• Sony PlayStation Suite es un framework de Sony para desarrollar juegos en diferentes dispositivos de su línea, completamente basado en Mono.
• Phalanger es un compilador de PHP, actualmente basado en Mono, utilizando el DLR, que además de ser el motor PHP de mayor rendimiento, permite extender ejecutar cualquier aplicación PHP y extenderla con librerías o aplicaciones .NET.
• CXXI es una tecnología puente entre C# y C++ que permite ejecutar código de una a otra plataforma, pero también heredar clases entre ellas, sobre-escribiendo métodos o no, o llamando a la clase base, todo de manera muchísimo más sencilla, segura  y multi-plataforma que utilizando COM.
• Y hay bastante más (ver el post de Miguel para el detalle completo), pero como detalle final, Miguel descubrió que Microsoft mismo utilizó Mono para producir el juego Kinectimals para iOS. ¡Toda una ironía!

Dejo el video (en inglés) del evento de Google Client para que lo disfruten:

PhoneGap: un entorno para gobernar a todos (+ videos)

El terreno del desarrollo de aplicaciones para móviles es cada vez más complejo. Incluso a medida que avanza el dominio de iOS y Android, hay una cantidad de dispositivos y sistemas operativos que aun son relevantes, y las variantes entre formatos, restricciones impuestas por las tiendas de cada fabricante y demás particularidades tienden a complicar la tarea enormemente.

En estos casos siempre han surgido intentos de proveer un único entorno que permita generar aplicaciones para diferentes objetivos, pero en general los resultados no son demasiado buenos porque suelen apuntar a un denominador común que usualmente es bajo y desaprovecha el potencial de muchas de las plataformas. No es el caso con PhoneGap, una plataforma que permite desarrollar aplicaciones nativas para múltiples dispositivos, a partir de su desarrollo en HTML5 (HTML, CSS y JavaScript).

PhoneGap es código abierto y gratuito y fue creado por una pequeña empresa llamada Nitobi que fue comprada en octubre por Adobe, que mantuvo el compromiso de mantener las características abiertas de la plataforma, delegando incluso la base de código a la Apache Software Foundation.

Desarrollando en HTML/JS, PhoneGap permite acceder a todas las API nativas de cada plataforma (salvo en casos ne que no existen) y el empaquetado posterior genera aplicaciones nativas y ajustadas a los requerimientos de los mercados de cada proveedor. Las plataformas cubiertas actualmente son:

• iOS
• Android
• Blackberry (OS 4.6 hasta 6.0)
• WebOS (de hp)
• Windows Phone 7
• Symbian
• Bada (la plataforma de Samsung)

Y las APIs cubiertas cubren casi todo lo que cada tipo de dispositivo tiene disponible (muchos no tienen brújula o no soportan video, por ejemplo), incluyendo:

• acelerómetro
• cámara
• brújula (si hay)
• contactos
• archivos (en los sistemas que lo permiten)
• posición geográfica
• media (audio/video)
• red
• notificaciones visuales, sonoras o vibrador
• almacenamiento

Veamos un ejemplo rápido de cómo utilizar el acelerómetro en JS:

function onSuccess(acceleration) {
    alert('Acceleration X: ' + acceleration.x + '\n' +
          'Acceleration Y: ' + acceleration.y + '\n' +
          'Acceleration Z: ' + acceleration.z + '\n' +
          'Timestamp: '      + acceleration.timestamp + '\n');
};

function onError() {
    alert('onError!');
};

navigator.accelerometer.getCurrentAcceleration(onSuccess, onError);

Esta interfaz funciona en Android, iOS y BlackBerry OS 5.0 o superior. De manera similar puede accederse a casi todos los recursos de los dispositivos, y la funcionalidad es la mejor posible para cada uno de ellos, ya que no se reduce todo al denominador común, sino que hay soporte para toda la funcionalidad de las plataformas. Es importante entender que no hay magia y cada plataforma final mantiene sus requerimientos originales. Por ejemplo, para generar aplicaciones iOS es necesario trabajar en Mac OS, y para genera aplicaciones Windows Phone es necesario Windows; Android requiere en el SDK y Eclipse, etc.

Quedan a continuación un par de vídeos (en inglés) mostrando PhoneGap en acción para iOS y Android.

MonoGame: XNA multi-plataforma

Como todos saben, soy bastante fanático de Mono, la implementación de código libre y abierto de .NET, liderada por Miguel de Icaza.

El año pasado se inició un proyecto llamado inicialmente XNATouch, cuyo objetivo era permitir portar juegos desarrollados en XNA (la plataforma para desarrollo de juegos en XBOX y Windows Phone) a iOS (iPhone, iPod y iPad). El proyecto avanzó bastante, cambió de nombre a MonoGame, y el mes pasado llegó a su versión 2.0, extendiendo el alcance de iOS a Android, Linux, Windows y Mac OS, y de paso, mudándose a GitHub.

El proyecto es muy interesante porque brinda un mecanismo sólido de desarrollo de juegos para múltiples plataformas, algo que es cada vez más requerido por quienes producen para esta industria, sobre todo en los ambientes móviles.

Como ejemplo, este es el código de arranque para ejecutar un juego desarrollado en XNA en iOS (utilizando MonoTouch):

using MonoTouch.Foundation;
using MonoTouch.UIKit;

using Microsoft.Xna.Framework;

namespace MonoGame.Samples.Storage
{
	[Register ("AppDelegate")]
	class Program : UIApplicationDelegate
	{
		private Game1 game;

		public override void FinishedLaunching (UIApplication app)
		{
			// Fun begins..
			game = new Game1();
			game.Run();
		}

		static void Main (string [] args)
		{
			UIApplication.Main (args,null,"AppDelegate");
		}
	}
}

Por ahora el framework soporta solamente juegos 2D, y el API de 3D es el foco principal de trabajo para la versión 3.0. Si está disponible el stack de networking suficiente para permitir jugadores simultáneos dentro de un mismo segmento de red, sin importar la plataforma en que estén ejecutando el juego.

Para quienes quieran ver el proceso en más detalle, recomiendo esta serie de 4 artículos de Alfredo Machin, en las que describe el proceso de migración de un juego XNA a Mac OS (utilizando MonoMac): Parte 1, Parte 2, Parte 3, Parte 4.

 

Pragmatic Programmers: Aprovechando el poder de la web (+video)

Los lectores o conocidos desde hace tiempo ya saben que tengo mucho respeto y admiración por Andy Hunt y Dave Thomas, los Pragmatic Programmers. Su primer gran éxito en conjunto fue el libro que le dio título a su emprendimiento editorial: The Pragmatic Programmer: From Journeyman to Master, de 1999.

En este libro Andy y Dave destilaron una enorme cantidad de sabiduría aplicada a las labores, prácticas y actitudes básicas de la programación, justo antes de que algunas de ellas se convirtieran en parte del Manifiesto Agile poco tiempo después (siendo Dave uno de los firmantes iniciales).

En el libro apuntan a las premisas básicas del uso de editores, depuradores, control de versiones, generación de código, pruebas unitarias, meta-programación, cuestiones de diseño, refactorización, manejo de requerimientos, y muchísimo más.

Pero después del éxito de este libro, que es uno de los más populares de todos los tiempos en nuestra profesión (para mi, junto al decano The Mythical Man Month, Code Complete y los más recientes Clean Code y The Clean Coder), Andy y Dave fundaron una editorial bastante particular, The Pragmatic Bookshelf dedicada a publicar libros dedicados al desarrollo de software a costos realmente económicos y cubriendo una variedad de temas a los que las editoriales grandes generalmente no llegan por ser demasiado específicos.

Así llevan más de 120 títulos publicados, y además de editarlos en papel se pueden comprar en ediciones electrónicas, sin mecanismos de protección. Esto me parece destacable. A pesar de ser una editorial muy pequeña, ellos tienen un negocio que sobrevive y con altísima calidad y nivel de servicio, sin necesidad de "molestar" al usuario por temas de propiedad intelectual. De hecho, el único mecanismo que utilizan es un código de confianza: cuando uno compra un libro electrónico puede descargarlo en formato PDF, Mobi (para el Kindle) o EPub (para iOS, Android, etc). Lo único que ellos hacen es generar una copia personalizada con el nombre del cliente en los pies de página. Así, si alguien desparrama copias, al menos se hace responsable personal.

Otra cosa que les permite este modelo de negocio es permitir leer versiones preliminares de los libros mientras el autor todavía está escribiéndolo, a un precio reducido y con opción de recibir la edición impresa final o no, y por supuesto con posibilidad de ir comentando el avance con el autor y colaborar con él.

Pero toda esta publicidad gratuita (la hago sólo porque soy un cliente felíz) surgió por otro servicio sorpresa que agregaron esta semana y me comunicaron por email: ahora permiten sincronizar las sucesivas versiones de los libros con una cuenta personal de Dropbox, un servicio pionero en sincronización de archivos en la nube. Dropbox tiene la característica de ser el más exitoso de los múltiples competidores en ese área, basándose en la premisa de mantener el servicio sencillo en cuanto a características, pero siempre extremadamente funcional.

Si, también soy un cliente feliz de Dropbox, cuyo servicio básico y gratuito alcanza y sobra para uso personal y me ha permitido moverme y mantener sincronizados ambientes entre Windows, Mac OS X y móviles, y me liberó de la obsesión por los backups. Pero Dropbox también es un caso interesante para la comunidad Python, ya que usan este lenguaje para cubrir múltiples plataformas cliente, y también del lado del servidor.

Dejo para el final un video (en inglés) Rian Hunter, uno de los ingenieros de Dropbox contando detalles de la implementación en la PyCon 2011.

Ahora, volviendo al tema principal, lo que PragProg agregó a sus servicios es la integración con Dropbox, de manera que cada vez que hay una nueva versión disponible de uno de los libros que tengo comprados (ya sea una nueva versión preliminar o una nueva edición de uno ya publicado con agregados o correcciones).

Lo que me llamó la atención al recibir la noticia fue la experiencia completa como usuario de este mecanismo, que comenzó al recibir el mail con novedades de la editorial y esta noticia en particular:

Al hacer click en esta parte del mensaje, mi navegador me llevó al sitio web, a una página a con todo el detalle, donde me explicaba cómo configurar esta opción en mi perfil:

Y en esta parte de mi perfil pude seleccionar qué formatos me interesan personalmente, lo que es muy prolijo. A continuación me redireccionó al sitio de DropBox utilizando (me di cuenta porque conozco el mecanismo) oAuth. De esta forma llegué al sitio de DropBox, donde me identifiqué con mis credenciales de ese servicio (que nunca llegaron al de la editorial), y el sitio de DropBox, que soporta este protocolo, me informó que PragProg.com deseaba establecer un vínculo, compartiendo mi identidad (mi nombre de usuario de DropBox y ningún otro dato).

Lo que me sorprendió gratamente es ver cómo dos servicios muy buenos permiten potenciar sus características utilizando protocolos estándares, brindando algo novedoso, seguro y práctico. Me pareció bueno compartirlo como un buen ejemplo de aprovechamiento de la infraestructura web actual para lograr productos de software más potentes.

 

 

JavaScript dentro de .NET

Siguiendo con sus planes de dominar el mundo, JavaScript tiene desde hace un tiempo un interesante motor construido en .NET que permite ser embebido en cualquier aplicación: Jint

El proyecto es de código abierto y fue iniciado por Sébastien Ros y colaboradores antes de ingresar a Microsoft, donde trabaja en el equipo del proyecto Orchard.

A diferencia de otros proyectos que intentan emitir código IL a partir de JavaScript, lo que es problemático por el problema de no poder descargar los ensamblados generados, o de otros proyectos basados en el Dynamic Language Runtime, Jint es un intérprete completo basado en ANTLR.

Jint permite utilizar JS como lenguaje para extender aplicaciones dinámicamente, algo que en .NET muchos hicimos previamente utilizando IronPython o IronRuby. Pero JavaScript es bastante más amplio en su uso, y esta clase de recursos siempre es muy valioso, sobre todo en este caso en que el soporte es muy completo, cubriendo la especificación completa de ECMAScript 3.0, y soportando en el último release muchos elementos del estándar 5.0.

Dejo el ejemplo más básico de uso desde C# (obviamente puede ser embebido en cualquier lenguaje .NET):

script= @"
  function square(x) { 
    return x * x; 
  };
  
  return square(number);
  ";
  
var result = new JintEngine()
  .SetParameter("number", 3)
  .Run(script));

Assert.AreEqual(9, result);

Grandes noticias sobre MonoTouch y Mono for Android

Esta semana Novell / SUSE anunció que firmó un amplio acuerdo de colaboración con Xamarin, la compañía formada por el equipo que trabajaba para ellos en el desarrollo de estos productos, liderada técnicamente por el infatigable Miguel de Icaza y comercialmente por su socio de años, Nat Friedman.

El acuerdo incluye transferencia a perpetuidad a Xamarin de todos los derechos de propiedad intelectual de todos los productos de la familia Mono (incluyendo MonoTouch, Mono for Android and Mono for Visual Studio) y el control de todas las propiedades relativas al proyecto Mono, como MonoDevelop y la organización Mono en GitHub, y a cambio se compromete a brindar soporte a todos los clientes de SUSE utilizando la plataforma, lo que es un factor importante para grandes cuentas de Novell utilizando las ediciones Enterprise de Mono.

Básicamente, desde mi punto de vista, es una acuerdo de colaboración basado en el hecho de que Novell no puede hacer mucho con esos productos sin el equipo detrás, pero necesita seguir dando respaldo a muchos clientes que los están utilizando. Como menciona el gerente general de SUSE en el anuncio oficial, con este acuerdo ganan las tres partes: Novell, Xamarin y los clientes de ambos.

Inmediatamente después de sellado el trato, Xamarin puso nuevamente disponibles los productos en su tienda en línea, y en el anuncio de Miguel se entiende que gran parte del esfuerzo que Xamarin inició para construir estos productos desde cero (mientras negociaban este acuerdo) va a aplicarse directamente como correcciones e implementación de nuevas características en los productos existentes.

La noticia es muy buena también para la comunidad de código abierto, ya que aunque estos productos que permiten programar en C# en plataformas móviles son pagos, son también la fuente de financiamiento que la empresa necesita para continuar liderando el desarrollo del proyecto Mono, MonoDevelop y los demás componentes abiertos y gratuitos, que nunca se detuvieron.

Prueba de que todos estos cambios nunca afectaron demasiado a la comunidad es que este sábado 23, y hasta el lunes 25 se llevará a cabo la conferencia MonoSpace 2011, dedicada a la plataforma abierta, y alojada en el NERD Center de Microsoft en Boston. La conferencia se empezó a organizar antes de que el equipo de Mono fuera despedido de Novell, y la organización nunca se detuvo a pesar de todas las idas y vueltas que felizmente han concluido en este acuerdo que deja en completo control al equipo original.

Video: Programando de a pares con Mariano Koldobsky

Mi invitado esta vez es Mariano Koldobsky, un experimentado trabajador al que conozco desde hace años, a raíz de conocernos en una empresa en que él trabajaba y yo daba consultoría, y reencontrarnos más tarde en la comunidad ágil.

Tiempo después logramos trabajar juntos por un tiempo, hasta hace poco cuando Mariano empezó a trabajar para bvision, que tienen oficinas cerca de su casa en La Plata, capital de la provincia de Buenos Aires.

Con Mariano compartimos la pasión por la programación, la electrónica y recuerdos de nuestra generación, ya que somos los dos bastante veteranos. Pero casualmente esas dos primeras aficiones nos llevaron a elegir como tema de nuestra sesión un ejercicio de programación y cableado, utilizando una placa Arduino, que es una plataforma de hardware abierto, ideal para realizar prototipos e implementaciones sencillas y caseras de dispositivos de control.

Como verán en el video, la placa se conecta por USB (anteriormente por puerto serie) y se programa en un lenguaje de programación propio (una especie de Processing, pero basado en C++ en lugar de Java).

Algo interesante de Arduino es que es la plataforma que tomó de base Google para desarrollar su propio Android Open Accessory Development Kit, con lo que conocerla ahora puede significar algo más que un mero pasatiempo.

El video dura un poco menos de 15 minutos, y espero que les resulte tan divertido como a nosotros grabarlo. ¡Al menos por una vez van a ver algo más que código!

 

Mono: de Novell a Xamarin

A fines del año pasado comentaba en este blog la venta de Novell a Attachmate, una compañia de servicios de infraestructura.

Una preocupación desde ese momento, aunque al principio no parecía pasar nada, es qué valor iba a darle el nuevo dueño al proyecto Mono (una implementación de código abierto de .NET), liderado por Miguel de Icaza.

Las cosas empeoraron recientemente, y el 2 de mayo comenzaron los despidos de los equipo de EEUU y Candá, seguidos en la semana por el resto en Europa, Brasil y Japón.

Lejos de romper en llanto, el equipo original de Mono, con Miguel a la cabeza, pronto avanzó con un viejo plan que ya había discutido anteriormente y fundaron Xamarin, una companía con la que piensan mantener el servicio de soporte de Mono y el resto de los proyectos abiertos, y generar dos nuevos proyectos similares a Mono for Android y MonoTouch (para iOS). Al igual que los productos que generaron en Novell, éstos últimos serán productos pagos, con los que esperan mantener al equipo funcionando.

Conociendo la calidad y capacidad de producción del equipo, estoy seguro que pronto tendremos novedades al respeto. Miguel estima que en 3 meses pueden tener la versión preliminar para iOS, y en 4 la de Android, y seguramente en ambos casos, al empezar de cero, incorporarán mejoras y aprendizajes por sobre los productos que quedaron en Novell.

Vale recordar que Mono en si y sus otros derivados como Moonlight, MonoMac y MonoDevelop son gratuitos y de código abierto, por lo que no hay riesgos al respecto.

Mientras tanto, la conferencia Monospace sigue programada para el 23 al 25 de julio en Boston, Massachussets, EEUU, en el NERD (New England Research & Development) Center de Microsoft en esa ciudad.

Y de paso, el jueves 19 de mayo, estaré presentando un Webcast para MSDN Latinoamérica, en una serie que empiezo sobre Interoperabilidad, llamado "Mono lleva .NET a todas partes".

Desde este humilde blog aprovecho para expresar mi admiración y apoyo a Miguel y su increíble equipo en esta nueva etapa, y quedo a la espera de las novedades que seguramente producirán a mansalva, como siempre.

Node.js, Ruby y Python en... Windows Azure? (video)

Esta semana esta desarrollándose en Las Vegas, EEUU, la conferencia MIX11, en la que Microsoft realiza gran parte de sus anuncios para desarrolladores y diseñadores. A diferencia de PDC, que es la conferencia general para desarrolladores, MIX se orienta específicamente al desarrollo web o de aplicaciones cliente en general.

Como siempre, el criterio se amplía y aparecen, además de muchas presentaciones y anuncios esperables, algunas sesiones sumamente interesantes, como ésta de Steve Marx, uno de los personajes más innovadores dentro de Microsoft en los últimos tiempos.

En esta sesión, @smarx se dedica a subvertir Windows Azure, la plataforma de cloud computing, de la que él es el estratega técnico, para ejecutar sobre ella Node.js, Ruby, Python y también cosas como Cassandra o Tornado.

Veamos porque Steve me parece innovador:

• No usa Powerpoint (y todavía no lo echaron): estos son sus slides de la charla (puro html+css)
• Todos estos ejemplos están disponibles en su cuenta de GitHub
• De hecho, tiene construido un workflow que hace el deploy en Azure de algunas aplicaciones después del git push
• Sus diagramas son muy buenos (sólo comparables con los de @eugenio_pace, como se aprecia a la derecha).
• Y fundamentalmente, entiende y divulga la necesidad de soportar múltiples plataformas y alternativas para que Azure sea un ambiente exitoso, en contra del discurso preponderante de que se lo utilice solo en .NET o PHP.

En la sesión se muestra cómo utilizar estas herramientas sobre la infraestructura pelada de Azure, sin utilizar ni el SDK, aprovechando algunas de las características que se habilitaron recientemente a este fin como:

• Privilegios elevamos, para poder correr procesos como admin
• Startup tasks: tareas que se pueden ejecutar antes de que un rol o instancia arranque
• Control completo del IIS, incluyendo proxy reverso y FastCGI

Les dejo el video (en inglés) por si quieren entender un poco más el tema, especialmente los motivos por los cuales alguien querría hacer esto en Azure en lugar de otras plataformas. Si por alguna razón no se ve el video en este post (los mecanismos de incrustación de Channel 9 no parecen muy estables) pueden ver la sesión en la página original.

Mono 2.10 y las últimas novedades de la monada

Por si alguno de los lectores de este blog aún no lo sabe, Mono es la implementación abierta de .NET para Unix, Mac OS X y Windows.

El increíble equipo de Mono nunca se detiene, siempre acompañado por su líder Miguel de Icaza.

La última versión liberada es la 2.10 (en realidad la 2.10.1) mientras continúa el rumbo hacia el próximo gran lanzamiento, que será Mono 3.0.

Pero esta versión ya tiene grandes avances, como:

• Soporte para el Google Native Client. 
  Esta es una tecnología que permite ejecutar código nativo dentro del browser de manera segura, y que ahora incluye no sólo la posibilidad de ejecutar código compilado previamente, sino también realizar compilación a demanda (JIT), lo que permite que Mono soporte Reflection.Emit o los lenguajes dinámicos, por ejemplo.
• Nuevo motor de Profiling
  Este nuevo motor está optimizado para trabajar en entornos de múltiples hilos y es muy eficiente en todo sentido.
• Implementación mejorada de Sockets
• Mejoras en el Parallel Framework y en SGen, el nuevo recolector de basura (una increíble pieza de ingeniería)
• Se unificó el runtime de soporte para MonoTouch y MonoDroid (versiones de Mono para IOs y Android respectivamente)
• Cecil/Light es una versión mejorada de Cecil, la librería que permite generación e inspección de código en tiempo de ejecución, y que muchos utilizan incluso en .NET, donde no tiene un equivalente directo.
• Nuevo mecanismo del compilador de C# y enormes mejoras en el shell interactivo
  Mientras Microsoft lleva más de dos años preparando su compilador como servicio, Mono lo tiene disponible desde entonces, incluyendo una consola que ahora permite no sólo la ejecución de expresiones sino de programas completos. El servicio de compilación además dejó de ser estático, con lo que se pueden crear diferentes instancias del compilador con contextos separados.
• Compilador de VB que permite compilar a los perfiles de VB 2.0 al 4.0
• Soporte completo para ASP.NET MVC 3 incluyendo Razor y WebPages. Mono 2.10.1 agregó algunos detalles que permiten ejecutar el CMS de código abierto Orchard de Microsoft, que de esta manera puede ejecutarse también en Linux.
• Implementación de WebMatrix.Data, una librería de Microsoft que permite acceso a datos aprovechando los nuevos tipos dinámicos.
• Muchísimas optimizaciones para Mono en OS X, que aprovechan más los servicios particulares del sistema operativo de Apple.
• Compilador de F# e intérpretes de IronPython y IronRuby completamente integrados en los paquetes para Linux y Mac.
• Gendarme 2.10, el analizador estático de Mono, también es mucho más rápido y tiene 33 reglas nuevas.

Como ven, nadie puede decir que Mono no avanza.

Para más detalles, se pueden ver las notas de los releases 2.10 y 2.10.1 en el sitio de Mono.

O pueden ir directamente a la página de descarga, donde encontrarán paquetes de instalación para Virtual PC, VMWare, LiveCD, openSUSE, SLES/SLED, Windows, Mac OS, CentOS, Solaris u otras distros de Linux.

HTML 5 ya tiene logotipo oficial

Si, el W3C lanzó el logotipo oficial de HTML 5 como parte de la campaña para impulsar el standard.

El logo no es solo una imagen suelta. Hay detrás una serie de guías de uso, ya se han hecho stickers y remeras, y además está publicado bajo una licencia Creative Commons que permite flexibilidad al utilizarlo.

Entre otras características, el logo puede ser acompañado en una placa que puede agregarse a cualquier sitio para detallar cada una de las tecnologías del estándar que están utilizadas en esa aplicación.

Este ejemplo muestra todas las características habilitadas (los íconos de cada una son parte del paquete de diseño que acompaña el logo):

Notarán si pasan el mouse sobre la imagen la lista de las tecnologías soportadas. Los íconos corresponden a:

Conectividad: hace referencia a Web Sockets y Eventos enviados desde el servidor, que habilitan un estilo de comunicación "push" (donde el browser cliente no necesita timers para ir a buscar novedades, sino que puede recibirlas) o entre pares (browser a browser, por ejemplo).

CSS3: extiende los estilos para soportar transiciones y efectos, tipografías y muchos otros detalles de presentación.

Acceso a dispositivos: implica acceso a características específicas del hardware debajo del browser. El ejemplo actual de implementación es el Geo-posicionamiento (el API abstrae esta funcionalidad de la manera en que el dispositivo la resuelve -con una combinación de GPS, WiFi, señales de red celular, etc).

3D, Gráficos y Efectos: cubren características como SVG, Canvas, WebGL y extensiones 3D de CSS3.

Multimedia: incluye los nuevos tipos de objetos que soportan audio y video.

Rendimiento e Integración: refiere a la nueva funcionalidad de Web Workers, que permiten ejecutar scripts en paralelo, y XMLHttpRequest nivel 2, que mejora el componente original con la capacidad de manejar peticiones desde orígenes cruzados, agrega eventos de progreso y manejo de streams para envío y recepción.

Semántica: enriquece el contenido al darle significado a través de nuevos tags, RDFa, micro-data y micro-formatos.

Fuera de línea y Almacenamiento: abarca el soporte para operar en forma desconectada a través de las APIs de App Cache, Local Sotrage, Indexed DB y File.

 

Esperemos ver el logo en uso frecuente hasta que estas características sean ubicuas y se transforme en irrelevante.

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.

 

IronPython y IronRuby liberados como Open Source

Después de atravesar una situación compleja tras el alejamiento de Jimmy Schementi de Microsoft, quien lideraba gran parte de los esfuerzos por mantener las implementaciones de Python y Ruby sobre el framework .NET, y tras especulaciones y charlas de las que algún día nos enteraremos, la historia ha tenido  un desenlace positivo.

En su último post, Jason Zanders, responsable máximo del equipo de Visual Studio, anunció que ambos lenguajes, que ya habían sido cambiados a licencia Apache 2.0, quedaron definitivamente liberados para ser mantenidos por la comunidad, incluyendo los agregados recientes de integración para ambos dentro de Visual Studio.

La mejor noticia, desde mi humilde punto de vista, es que los coordinadores de los proyectos son Miguel de Icaza, Michael Foord, Jeff Hardy, y Jimmy Schementi para IronPython, y Miguel y Jimmy para IronRuby.

No quiero especular, pero es totalmente esperable que ambos lenguajes mejoren el nivel de soporte en Mono y sobre todo en MonoDevelop, lo que puede seguir potenciando Mono como motor de desarrollo multi-plataforma, cubriendo desde *nix, Windows, Mac OS, dispositivos embebidos, teléfonos y hasta consolas de juego.

Para quienes no lo han visto todavía, en el último release de IronRuby (antes de pasar el proyecto a la comunidad) el equipo ya incluye integración con Visual Studio, con una serie de templates sumamente interesantes, como puede verse en esta pantalla: