Para los desarrolladores en el ecosistema Microsoft, estamos en una época especialmente interesante con una apuesta muy importante, a la altura de la comercialización del IBM PC o de Windows 95.

Las novedades no paran de presentarse desde 2008, a un ritmo endiablado de sostener; mantenerse, al menos, al corriente de las principales evoluciones de los sistemas, productos y herramientas requiere estudiar permanentemente.

Por ello hoy quiero hacer un análisis de una reciente publicación que representa un impresionante manual de introducción avanzado al Desarrollo en Windows 8 y Windows Phone 8 con XAML y C#.

Sobre los autores, colaboradores y editores

Aunque este artículo va a ser acompañado en breve con una larga conversación con los autores, si quisiera señalar que entre los tres reúnen más de 30 años de experiencia en el desarrollo. Es decir es un libro escrito por y para desarrolladores.

Josué Yeray y Rafael Serna ya visitaron las páginas de GenbetaDev en un artículo sobre Windows Phone Controla, podcast y screencast de desarrollo en wp7, constituyendo una de las parejas más reconocidas del panorama nacional de Windows Phone 8. Además, Josué e Ibon Landa, son MVP (Most Value Professional); un importante reconocimiento de Microsoft a los profesionales que no pertenecen a la compañía pero que realizan un gran aporte continuado a la comunidad, que por su parte los propone y vota.

También es de reseñar que la propia Nokia ha prestado su colaboración en el trabajo de construcción del libro, reconociendo el trabajo para la comunidad de Josue al nombrarlo Nokia Developer Champion en el 2011.

Y por último, pero no por ello menos importante, el trabajo de editorial de José Manuel Alarcón (otro MVP) que, frente a Krasis Press, ha ayudado a imprimir y distribuir esta magnífica obra.

Contenido en fondo y forma orientado al desarrollo

El primer capítulo hace un resumen bastante completo sobre de dónde sale Windows 8, con su estilo de interfaz gráfico llamado inicialmente Metro Style y actualmente Microsoft Design Style. Continua, aun dentro del capítulo, con otro vistazo por encima del novísimo Windows Phone 8 – presentado hace no más de tres meses –, de porqué es como es y qué ventajas tiene sobre la versión anterior: la 7.x.

Para cerrar el contenido muestra al lector qué herramientas gratuitas tiene a su disposición para poder realizar los ejemplos incluidos, o las aplicaciones que serán publicadas a través de los diferentes Market.

A partir de aquí empezamos a disfrutar los desarrolladores ya que los dos siguientes capítulos hablan del patrón arquitectónico por antonomasia al programar para Windows 8 o Windows Phone 8 con XAML: Model/View/ViewModel, o más conocido como MVVM.

Un patrón que publicó Jhon Gossman en 2005 y que permite, como se describe en el libro con un tutorial paso a paso, construir aplicaciones robustas, desacopladas, reutilizables y que facilitan la migración y funcionamiento del código en las tres plataformas destinatarias de la obra: Windows 8, Windows Phone 8 y Windows Phone 7.5.

Aprenderemos qué es un Binding, de los interfazes IPropertyChangede e ICommand – con su implementación en DelegateCommand – y el uso del patrón Locator; desembocando en el capítulo de MVVM avanzado en donde se describe el concepto de Inyección de dependencias, el porqué de su importancia y los mejores framework que nos facilitan su uso.

Pero aún queda el final del capítulo en donde se trata temas como las Buenas Prácticas de programación en MVVM, los framework para la implementación más sencilla del patrón y una sección muy breve sobre test unitarios.

Como ves en estos dos capítulos tienes un manual de “Cómo aprender MVVM de cero a sénior en tres días”. Pero la verdad es que yo lo he utilizado en un producto real pequeño y, estás poco más de 80 páginas me han tenido estudiando durante días y días. Yendo adelante y atrás, siguiendo los ejemplos de código que, si los seguimos al detalle, permiten acabar el capítulo avanzado con una aplicación funcionando en el emulador de Windows 8 con un orden, robustez y desacople muy satisfactorio

Llega la hora de los diseñadores gráficos y UX

Así a partir de este punto se abren dos largos capítulos que se extienden por más de 120 páginas en donde se describe al detalle las capacidades de los diferentes sistemas operativos. Las diferencias de los controles más utilizados, la forma de describir y de configurar el entorno gráfico, los trucos, las Buenas Prácticas y los requisitos que debes tener en cuenta ya que te los va a exigir el Market para certificar la aplicación.

Se inicia describiendo el lenguaje XAML, que se utiliza en todas las plataformas, pero entrando al detalle de las diferencias con las que nos vamos a encontrar y cómo irlas solventándolas. Continuando con las capacidades de la plataforma .NET para la construcción de aplicaciones multiidioma, lo cual en un mercado global es imprescindible.

Para finalizar la zona de diseño puro, entramos en un capítulo dedicado a la explicación de los interfaces de usuario en ambas plataformas (incluso un poco de Windows Phone 7). Cuáles son los controles que nos ofrecen por defecto los sistemas operativos, las particularidades de cada uno y cómo soportar las diferentes resoluciones y orientaciones de los dispositivos que obliga la certificación de las aplicaciones.

Metiéndonos en las tripas del Sistema

Windows 8, al igual que Windows Phone 8, está pensado y diseñado para dar soporte natural a su ejecución en dispositivos móviles (tabletas, ultrabooks, portátiles, híbridos, etc.) Por lo cual el Ciclo de Vida, es decir cómo se ejecuta nuestra aplicación en conjunto con el resto dentro del sistema operativo, es el contenido del 6º capítulo. Breve, pero muy importante para conseguir que funcione correctamente el software en un ecosistema “particular” como el interfaz táctil de Windows 8 o Windows Phone 8.

Por ejemplo, una aplicación puede notificar 6 estados diferentes al sistema: NotRunning, Running, Suspended, Terminated o ClosedByUser… (toma ya!!). Y cuando la cerramos debemos detener los timers, las animaciones, el acelerómetro y la localización por GPS, cerrar las operaciones por red o contra el isolated storage y apagar el sintonizador de radio FM.

La densidad del siguiente capítulo, “Acceso al sistema”, es para una lectura reposada, tomar apuntes y volver a leerlo. Se describe con ejemplos las cosas que podemos y no podemos hacer en Windows 8 y Windows Phone 8 para interactuar con el Sistema Operativo y sus servicios. Y de las que podemos hacer, cuales son los pasos que debemos realizar y de qué forma.

Interactuando con el mundo real

La realidad es que su complejidad de uso merece un capítulo completo por parte de los autores. Y en donde no solamente se describe las diferencias dependiendo el sistema operativo, lo que implica el visualizar notificaciones tanto en las live tiles como en las pantallas de bloqueo, y el generar sistemas de comunicación basados en tecnología Push para recibir la información a mostrar desde servidores remotos.

El capítulo que le sigue se centra en los sensores que incluyen los actuales dispositivos móviles, en especial los smartphone, como pueden ser los receptores Gps y el uso de librerías de Mapas, el acelerómetro, la brújula, el giroscopio y otros sensores secundarios como el inclinómetro, el sensor de orientación o el de luminosidad.

Además incluye una breve descripción de la construcción y uso de las Portable Class Libraries que son un gran invento. Básicamente es un proyecto de Visual Studio al cual le indicamos cuales son los sistemas operativos sobre los que queremos que funcione nuestra aplicación: Windows 8, Windows Phone 8 y 7, Xbox, Silverlight, etc. Así el propio IDE incluirá las librerías que son compatibles con los sistemas seleccionados y que podemos reutilizar en todos los proyectos que tengamos, asegurándonos de no introducir ningún código incompatible.

Comunicaciones: ¿se me escucha?

Y ambas unidas por la simplicidad con las que se pueden explotar desde .NET y que explican los autores con profusión de ejemplos de código real, como en todo el libro.

El segundo capítulo vuelve a un nivel técnico más profundo, similar a los iniciales de XAML y MVVM, tratando el inacabable – y me temo que inabarcable – uso de la tecnología de Windows Comunication Foundation (WCF), para realizar todo tipo de conexiones sobre los más variopintos protocolos y contra multitud de dispositivos.

Como bien indican los autores, WCF es una tecnología muy extensa sobre la que hay una abundante literatura y que sobrepasa con creces el alcance del libro. Pero aun así le dedican un buen número de páginas para explicar un sencillo ejemplo de conexión, teniendo aún espacio para revisar incluso una comunicación OnData o mostrar cómo hacer un lector RSS sencillo.

Recta final de una extensa lectura

Trata sobre Windows Azure, la Cloud de Microsoft. El sitio en donde toda aplicación con pretensiones de llegar al Gran Público (miles, cientos de miles o millones de usuarios) debe de irse para poder cubrir las necesidades de escalabilidad y disponibilidad que implica. Además de poder utilizar los servicios de movilidad (Mobile Services) que la plataforma ha publicado recientemente.

A cambio de esta visión un poco más generalista, terminamos el libro con un apéndice que es una guía detallada y llena de buenos consejos de cómo publicar nuestro software en las tiendas virtuales de MS. Ya sea en el Market de Windows 8 como en la de Windows Phone, y que se podría resumir en la última frase del libro:

“Debemos asegurarnos en todo momento que la aplicación que subamos, no contiene fallo alguno, ya que enviar una actualización implicará el mismo tiempo de publicación que si la enviamos por primera vez”

Conclusiones

Hay miles de páginas con manuales, tutoriales o post sobre conocimiento de todas las áreas de la informática, pero siempre se echan de menos obras bien escritas, con autores reconocidos en la comunidad y con un potente trabajo editorial detrás.

Este es uno de ellos.

Así puedo recomendarlo como uno de los mejores libros para la iniciación avanzada en el desarrollo sobre en una tecnología compleja y con ambiciones universales. No tanto por su fondo, sino por la forma. Se nota, y mucho, que los autores se pegan con esta tecnología de forma profesional y así hacen hincapié en lo importante, en las dudas que ellos tuvieron que resolver en su momento, dejando para libros con mucha mayor profundidad los vericuetos de conceptos, técnicas y conceptos como POO, WCF, SOLID, etc.

Pero en este acto de “jardinería”, separando el grano de la paja, es en donde tiene su mayor debilidad el texto. Se condensa tanto el conocimiento en tan poco espacio que muchas veces me he visto utilizándolo más como un libro de referencia, ese que buscas para superar el obstáculo que te impide continuar, más que como un manual al uso. O tener que profundizar en la descripción de una Buena Práctica o una pieza de código de ejemplo buscando en la infinita librería de Google, para tener un conocimiento más profundo del porqué.

Espero que lo disfrutéis tanto como lo estoy haciendo yo.

Enlace en Krasis Press | Desarrollo en Windows 8 y Windows Phone 8 con XAML y C#
En GenbetaDev | Entrevista a Jousé Yeray, Rafael Serna e Ibón Landa

Gracias a las plantillas de proyecto que forman parte de la instalación de Visual Studio 2012 tenemos la posibilidad de crear una primera Aplicación Metro que sea más sofisticada y completa que el típico “Hola Mundo” al que estamos acostumbrados en otras tecnologías.

Para crear esta primera aplicación empezaremos por abrir Visual Studio 2012 y navegar al menú File -> New -> Project.

Deberemos navegar al nodo donde se encuentren las plantillas de proyecto de JavaScript y seleccionar un proyecto de tipo Grid App y darle nombres a la solución y el proyecto. En caso de no estar familiarizado con VS, es importante saber que en este IDE el código se organiza soluciones que pueden contener uno o más proyectos. Cada proyecto puede ser, a su vez, una aplicación en sí mismo, una librería de clases, un servicio web, una definición de un esquema de base de datos, etc. De esta forma, para una aplicación con código en cliente y servidor, podríamos tener una única solución con varios proyectos representando todas las piezas necesarias para su correcto funcionamiento.

Tras dar valor a los campos solicitados y pulsar OK tendremos que esperar unos segundos mientras Visual Studio crea la nueva estructura de código, con una solución y un proyecto en ella.

Estructura de los proyectos

Para poder ver la estructura de ficheros y proyectos que Visual Studio crea por nosotros al usar una plantilla de proyecto, simplemente tenemos que ir a la ventana de Solution Explorer. Nos encontraremos algo similar a lo que muestra la siguiente imagen.

Algunas ideas que es importante tener en cuenta.

• En la carpeta References podemos encontrar las referencias a código externo que va a requerir la aplicación. Por defecto Visual Studio nos carga una referencia a WinJS, que es la librería base para la creación de Aplicaciones Metro con JavaScript. A través de ella podremos invocar a WinRT.
• En la carpeta pages podemos encontrar las distintas páginas de que se compone la aplicación, organizadas en carpetas que contendrán las tres piezas que forman cada página: HTML, CSS y JavaScript.
• En la carpeta js podemos encontrar otros códigos script que la aplicación necesitará pero que no están directamente relacionados con una página concreta.
• En todo proyecto habrá ciertos ficheros obligatorios para su correcto funcionamiento, como son la página cargada por defecto al activar la aplicación (default.html), una clave para firmar la aplicación (fichero con extensión .pfx) y un manifiesto (package.appxmanifest) que permite declarar capacidades que la aplicación tiene y permisos que requiere para ejecutarse, entre otras cosas.

Por último, desde esta ventana podremos añadir nuevos elementos a los proyectos, simplemente pinchando el botón derecho del ratón para mostrar el menú contextual.

Compilación y ejecución

Compilar, desplegar, ejecutar y depurar es tan sencillo como pulsar F5. En ese momento Visual Studio compilará la aplicación, creará el paquete, lo instalará en el entorno que le hayamos indicado (nuestra máquina, por defecto), lo lanzará y conectará el depurador a la aplicación resultante. Lo que veremos, para la aplicación que acabamos de crear, será similar a esto.

En esta pantalla, la inicial de la aplicación, podemos ver elementos de información agrupados. En realidad toda esta información es simple relleno y se define en el fichero data.js contenido en la carpeta js del proyecto.

Sin embargo, es suficiente para permitirnos ver toda la funcionalidad que tiene la aplicación. Si pulsamos en el nombre de alguno de los grupos navegaremos a la página que muestra información para cada grupo.

Si, por el contrario, seleccionamos un ítem concreto, será a la pantalla de información detallada de cada ítem a donde navegaremos automáticamente.

Además la aplicación trae una implementación para Snapped View. Este tipo de vista facilita la multitarea en dispositivos táctiles, permitiendo que dos aplicaciones compartan la pantalla. Sin embargo una de las dos tendrá una vista reducida, consistente en sólo 320 pixeles de ancho, de forma que tendrá que adaptar la información que está mostrando para seguir siendo útil aún en estas circunstancias.

Para poner la aplicación en estado Snapped View simplemente tendremos que pinchar en la parte superior de la pantalla y, sin soltar, arrastrar hacia uno de los lados de la pantalla. En la siguiente figura podemos ver el resultado.

Todas las Aplicaciones Metro deben implementar este tipo de vista, puesto que gracias a ella los usuarios podrán sacarles más partido a sus dispositivos, al tiempo que los desarrolladores nos beneficiamos del hecho de que nuestra aplicación permanezca mayor tiempo en pantalla.

En Genbeta Dev | Programar aplicaciones Metro en Windows 8

Las herramientas principales con las que se va a poder crear Aplicaciones Metro son los dos productos principales para el desarrollo y diseño de software que Microsoft lleva años ofreciendo a desarrolladores y diseñadores: Visual Studio y Blend.

Visual Studio 2012

Visual Studio es un producto maduro que lleva siendo la herramienta para el desarrollo de software con tecnologías de Microsoft desde hace muchos años. En esta nueva versión, como no podía ser de otro modo, de crear Aplicaciones Metro con cualquiera de los lenguajes de programación que hemos visto en puntos anteriores.

Como en anteriores ediciones, Visual Studio 2012 no será una única aplicación, sino una familia con distintas configuraciones y distintos precios que se adapta a las necesidades del desarrollador. Tendremos desde la versión Express, gratuita y suficiente para la creación de Aplicaciones Metro, hasta la versión Ultimate con los últimos adelantos en modelado y arquitectura, pruebas, depuración, etc. En cualquier caso, durante un tiempo tendremos la posibilidad de utilizar la versión Ultimate de forma totalmente gratis, por lo que puede ser una oportunidad para conocer la versión más potente de la gama y conocer sus posibilidades.

En cuanto a las novedades que presenta VS 2012 con respecto a la edición anterior, son muy numerosas, por lo que destacaremos las tres más relevantes.

Interfaz Metro

Quizás la novedad más impactante a primera vista es el profundo rediseño que se ha hecho de la interfaz gráfica de Visual Studio. El estilo continuista que habíamos visto desde Visual Studio 2005 a Visual Studio 2010 se rompe completamente en esta nueva versión, haciendo una metroficación del IDE.

Esta redefinición a la Metro empieza con la simplificación de la interfaz, reduciendo líneas, iconos y, en general, dando paso a un aspecto mucho más minimalista que en versiones anteriores. Se abre paso, como en otras aplicaciones con estilo Metro, el espacio y la jerarquía de tipografías para darle forma a las ventanas y su contenido.

También se ha producido un cambio drástico en la iconografía, puesto que se han sustituido todos los iconos por versiones Metro de los mismos, más planos y más esquematizados. Para algunos desarrolladores acostumbrados a versiones anteriores de VS esto puede resultar un problema en una primera toma de contacto, pero el período de adaptación es menor que la diferencia con lo existente hasta ahora nos pudiera hacer pensar.

IntelliSense en JavaScript

IntelliSense es un sistema de ayuda contextual que facilita la programación al ofrecer información en línea sobre APIs, métodos, parámetros y sus tipos, resultados, excepciones, etc. Gracias a este sistema el desarrollador se evita tener que memorizar las APIs, al tiempo que facilita que el código se escriba correctamente a la primera, reduciendo errores de compilación.

Con Visual Studio 2012 este sistema aterriza en el JavaScript que usaremos para programar Aplicaciones Metro. En la siguiente imagen podemos ver un ejemplo de su uso, mostrando los métodos en el espacio de nombres WinJS, así como una pequeña explicación del que tenemos seleccionado.

Plantillas de proyecto

Con Visual Studio 2012 vamos a tener de serie una serie de plantillas de proyecto de Aplicación Metro con HTML/JS que nos van a minimizar la curva de aprendizaje de esta nueva tecnología. Las plantillas con las que contaremos son:

• Blank App: esta plantilla crea un proyecto con una única página, la que cargará por defecto el sistema operativo al lanzar la aplicación. Puede ser un buen ejemplo para conocer los ficheros mínimos que todo proyecto de Aplicación Metro necesita.
• Grid App: la más completa de todas las plantillas, muestra ítems de información agrupados. Se compone de tres páginas, una para mostrar un resumen general de información, otra para mostrar información específica de cada grupo y una tercera para mostrar información detallada de cada ítem.
• Split App: esta plantilla define un proyecto con dos páginas, una para mostrar grupos de información y otra para mostrar los elementos de cada grupo.
• Fixed Layout App: similar a Blank App, crea una aplicación con un layout fijo, a diferencia de las anteriores que lo crean de tipo adaptativo. Esta plantilla está pensada para juegos.
• Navigation App: esta plantilla es un ejemplo básico del tipo de navegación que se debe utilizar con Aplicaciones Metro.

En función del tipo de proyecto elegiremos una plantilla u otra, así como la forma en que prefiramos empezar a crear Aplicaciones Metro: partiendo de una versión mínima (Blank App) o con una aplicación ejecutable que queramos modificar para adaptar a nuestro escenario (Grid App o Split App).

Blend for Visual Studio

La otra herramienta que vamos a necesitar tener siempre a mano para crear Aplicaciones Metro es Blend for Visual Studio. Hasta ahora esta herramienta de diseño se había utilizado para crear, fundamentalmente, aplicaciones con interfaz gráfica basada en XAML.

Sin embargo con el lanzamiento de las nuevas Aplicaciones Metro para Windows 8 se ha creado una nueva versión de la herramienta que ofrece un completo soporte para la creación de interfaces basadas en HTML5 y CSS3. Entre las posibilidades que nos ofrece Blend para la creación de interfaces con estos lenguajes tenemos:

• Diseño visual, de tipo WYSIWYG (What You See Is What You Get), además de permitir emular distintos tamaños y orientación del dispositivo para el que estamos creando la aplicación.
• Modo interactivo, que permite ejecutar la aplicación dentro de Blend para poder diseñar para ciertos estados a los que sólo se llega en tiempo de ejecución.
• Arrastrar y soltar de controles y propiedades.
• Potente generación de código a partir de los elementos que se ha añaden visualmente.
• Depuración de HTML y CSS.

En definitiva, Blend es más que un simple diseñador de interfaces. Es una potente herramienta que nos permitirá definir cada aspecto de la interfaz gráfica, desde su estilo a parte de su comportamiento ante circunstancias como cambios de orientación o tamaño de ventana.

Más información | Visual Studio 2012, Blend for Visual Studio
En Genbeta Dev | Programar aplicaciones Metro en Windows 8

El ciclo de vida de las Aplicaciones Metro es bastante distinto al que ha existido en las aplicaciones en Windows hasta ahora. Si en aplicaciones clásicas tenemos, fundamentalmente, dos estados consistentes en ejecución y cierre de la aplicación, en las Aplicaciones Metro vamos a tener varios estados extra, como se puede ver en la imagen.

Veamos cómo vamos a pasar de unos a los otros y qué condiciones se tienen que cumplir en cada caso.

Activación (Activated)

Para que se produzca una activación la aplicación debe estar en un estado de no ejecución. Este estado se produce, por ejemplo, cuando se acaba de instalar, cuando la máquina acaba de arrancarse o tras producirse una terminación (como veremos en un punto más adelante).

La activación puede producirse por varias circunstancias, como su lanzamiento a través del tile de la aplicación en la pantalla Start, o a través de la implementación de contratos como Search, File Picker, Share, etc. (veremos más sobre ello en próximos puntos). En todos los casos el resultado es el mismo, Windows activa la aplicación y ejecuta su código de carga.

En ese momento la aplicación tendrá 15 segundos para completar su activación. En caso de no hacerlo Windows matará la aplicación, evitando que el usuario espere indefinidamente delante de la pantalla inicial. De este modo cada desarrollador sabe que, por diseño, su aplicación tiene que ser rápida al cargarse, evitando “abusos” frente al usuario en forma de esperas indefinidas.

Suspensión (Suspending)

Las Aplicaciones Metro se ejecutan siempre a pantalla completa y Windows les cede todos los recursos que puedan necesitar. Sin embargo, en el momento en que el usuario cambia a otra aplicación, se produce el proceso de suspensión.

Durante este proceso Windows espera unos segundos como margen por si el usuario decide volver a la aplicación, evitando una suspensión innecesaria. Pasado ese tiempo se envía la señal correspondiente para que la aplicación ejecute el manejador para el evento Suspending, si se ha implementado.

Una vez invocado el manejador, la aplicación tendrá 5 segundos para guardar su estado, pues de lo contrario Windows la matará también. Las aplicaciones suspendidas pasan a memoria y pierden el acceso a otros recursos como CPU o disco. Sin embargo, en situaciones en que el sistema se encuentre escaso de memoria, Windows 8 se encargará de ir descargando las aplicaciones suspendidas de memoria.

Por esta razón es necesario que toda aplicación guarde su estado en este punto del ciclo de vida, puesto que no hay garantía de permanecer indefinidamente en memoria y, en caso de ser descargada, Windows no envía ninguna señal. En definitiva, el evento de suspensión es la última oportunidad que tiene la aplicación de guardar su estado.

Reactivación (Resuming)

Equivalente al evento de suspensión, pero para aplicaciones que ya están suspendidas. Permitirá a la aplicación “refrescarse” antes de mostrarse al usuario, en el momento en que vuelva a primer plano.

Este evento es muy importante si queremos cumplir uno de los principios de la Aplicaciones Metro: mostrarse frente al usuario como si siempre estuvieran vivas. Gestionando correctamente los eventos de suspensión y reactivación, el usuario va a tener la sensación de que la aplicación nunca ha dejado de ejecutarse.

Por último, es importante tener en cuenta que la suspensión puede haber durado minutos u horas, por lo que es importante recargar cualquier información o recurso que pueda haber quedado obsoleta, como por ejemplo el estado de la red.

Terminación

Este evento se produce bajo varias circunstancias, como por ejemplo si el sistema entra en un estado de carencia de recursos o si el usuario cierra la aplicación explícitamente. Como comentábamos antes, la aplicación no recibirá ninguna clase de señal o notificación para ejecutar acción alguna. Simplemente se la eliminará de la memoria.

En general las aplicaciones no pueden cerrarse a sí misma, salvo bajo circunstancias muy determinadas, como detección de fugas de memoria o problemas similares. Además, está prohibido que una aplicación ofrezca al usuario un mecanismo para cerrarse; impide su aprobación en Windows Store.

En Genbeta Dev | Programar aplicaciones Metro en Windows 8

GitHub for Windows es un cliente 100% nativo que se ejecuta en Windows XP, Vista, 7 y 8. El lanzamiento de esta herramienta viene a cubrir la necesidad de simplificar la barrera de entrada que suponía Git para muchos de los usuarios de Windows que usan los repositorios de GitHub, según cifras de la compañía representan alrededor de la mitad del tráfico de la web.

Quizás muchos nos vemos obligados en nuestros lugares de trabajo a utilizar entornos windows por lo que este cliente nos va a facilitar algunas de las acciones más comunes desde su interfaz gráfica con los repositorios Git, tanto locales como los alojados en GitHub.

Funcionalidades sobre repositorios Git locales y remotos

Lo que más llama la atención es botón “Clone in Windows” que a partir de ahora nos encontraremos en todos los proyectos de GitHub, por supuesto cuando usemos un ordenador con Windows. Este botón nos permitirá clonar repositorios directamente desde la propia aplicación.

La aplicación está diseñada usando la interfaz Metro de Windows. Nada más instalarla nos pedirá nuestro usuario de Github con lo que nos permitirá consultar y realizar las acciones más comunes sobre los repositorios que tengamos alojados o estemos siguiendo en GitHub. Tanto buscar y checkear branches, crear y publicar branches, hacer merge o borrarlos.

Además buscará en nuestro equipo los repositorios locales de Git que podremos administrar desde allí también y si queremos subir a GitHub fácilmente.

Implementación del cliente Windows de GitHub

La aplicación está desarrollada en C# y ha usado una gran variedad de proyectos open source para crear una herramienta sencilla para administrar nuestros repositorios den GitHub. Entre ellos se encuentre libgit2 que proporciona un clara y potente API para interactuar con repositorios Git, msysGit que es una poderosa herramienta para gestionar Git desde línea de comandos que incluye por debajo la aplicación, además de la poderosa shell desarrollada por Keith Dahlby conocida como posh-git. Y como no podía faltar hace uso de la API de GitHub v3 que podemos encontrar en su página de desarrolladores.

Más información | GitHub para Windows
Vía | GitHub Blog

World of Warcraft, el exitoso mundo persistente de Blizzard, con sus más de 11 millones de jugadores, se ha convertido en el modelo a seguir para cualquier MMO.

En el artículo anterior de esta mini serie, hice un ejemplo de invocar a un servicio REST que transmite información en Json. De una forma asíncrona, en C#, construí dos métodos que me devolvían los datos de forma bruta.

Ahora voy a mostrar cómo resolví el cargar los datos en mi aplicación. Parseando la cadena Json y utilizando una librería gratuita muy útil para realizar estas operaciones de forma muy sencilla.

Creando estructuras

string uri = “http://eu.battle.net/api/wow/character/los-errantes/bendemfalar?fields=stats”;

Osea, me traigo del reino “Los Errantes”, el personaje “Bendemfalar” y sus estadísticas. Pero, claro, esta información me va a llegar en bruto y lo que yo quiero es guardarla para poder ser utilizada más adelante. Para lo cual me hago dos clases que van a adoptar el papel de POCO; es decir, meros repositorios de información.

    public class Personaje


    {


        public double lastModified { get; set; }


        public String name { get; set; }


        public String realm { get; set; }


        public int Clase { get; set; }


        public int gender { get; set; }


        public int level { get; set; }


        public int achievementPoints { get; set; }


    }





    public class Estadistica


    {


        public double health { get; set; }


        public string powerType { get; set; }


        public double power { get; set; }


        public double str { get; set; }


        public double agi { get; set; }


        public double sta { get; set; }


        public double intelecto { get; set; }


    }

He modificado ambas clases para hacerlas más pequeñas y útiles para este ejemplo. Y ya tengo los objetos en donde almacenaré la información.

Pero, como soy un vago, rápidamente me doy cuenta que voy a necesitar una clase que contenga las dos anteriores para que me sea más sencillo mover la información.

    public class DatosPersonaje


    {


        public Personaje Personaje { get; set; }


        public Estadistica Estadistica { get; set; }


    }

Json.Net

Por suerte en CodePlex, existe un fantástico proyecto que trata justamente de una librería de facilita en gran medida el trabajo de manipulación de este formato:

Json.Net de @JamesNK

Siguiendo los consejos del sitio CodePlex, instalo la librería, por medio de NuGet, directamente en el proyecto WP7 en donde estoy escribiendo esta práctica. Y creo una clase específica que tenga la responsabilidad de parsear la cadena de información y cargarla en la clase adecuada.

using Newtonsoft.Json;


using Newtonsoft.Json.Linq;





namespace Model


{


    public class GestorDeJson


    {


        public DatosPersonaje RecuperaDatosPersonaje(string jSonString)


        {


            DatosPersonaje datosPersonaje = new DatosPersonaje();


            JObject jPersonaje = JObject.Parse(jSonString);





            datosPersonaje.Personaje = JsonConvert.DeserializeObject(jPersonaje.ToString());


            datosPersonaje.Personaje.Clase = (int)jPersonaje.SelectToken(“class”);





            datosPersonaje.Estadistica =


                JsonConvert.DeserializeObject(jPersonaje.SelectToken(“stats”).ToString());


            datosPersonaje.Estadistica.intelecto = (int)jPersonaje.SelectToken(“stats.int”);





            return datosPersonaje;


        }


    }


}

Como has visto, esta librería es una pequeña maravilla, y una auténtica joya. Voy a analizar cada fila importante para aclarar un poco más lo que he escrito.

DatosPersonaje datosPersonaje = new DatosPersonaje();


JObject jPersonaje = JObject.Parse(jSonString);

Como se puede ver, primero instancio un objeto del tipo Datos del Personaje, y justo debajo instancio un objeto JObject, que es de la librería, y le asigno el contenido de la cadena Json que he recogido en el artículo anterior, parseado.

datosPersonaje.Personaje = JsonConvert.DeserializeObject(jPersonaje.ToString());

Esta línea es magia pura. Lo que hace aquí es deserializar el objeto JObject y convertirlo en un objeto Personaje (que es uno de los dos que almaceno en DatosPersonaje). ¿Y cómo sabe Json.Net que campo va en donde? Pues comparando la clave de Json (“name:Bendemfalar”) con la propiedad de la Clase.

datosPersonaje.Personaje.Clase = (int)jPersonaje.SelectToken(“class”);

Esta última línea es la que he utilizado para cuando el nombre del campo Json es una palabra reservada en C#, como es el caso de Class. No puedo declarar una propiedad de Personaje como Class. Por lo cual debo coger el objeto JObject y seleccionar el campo que quiero transferir a mi clase.

Y, exactamente lo mismo hago con la información de estadísticas.

Investigar lo que ahora puedes hacer con esta información, te lo dejo a ti.

Más información | Blizzard Community Platform API Documentation, Json.net
En GenbetaDev | Api de World of Warcraft, consumir un servicio Json Cómo hacer un escaner para Twitter

World of Warcraft, el exitoso mundo persistente de Blizzard, con sus más de 11 millones de jugadores, se ha convertido en el modelo a seguir para cualquier MMO.

Su política cercana al Software Libre, en el desarrollo de extensiones para la UI del juego, ha incentivado la creación de cientos de AddOn de todo tipo de mejoras y ayudas. Cubriendo los más insospechados nichos.

Para ello Blizzard, basado en el lenguaje de programación LUA, ofrece a los desarrolladores una impresionante API para el desarrollo en el propio juego. Y una sencilla API Rest, que devuelve mensajes en formato Json. Que es la que voy a utilizar para realizar el ejemplo de lo que trata este post.

Tecnología y herramientas

Como buen programador .NET, mi IDE es Visual Studio. En este caso la versión 2010 con el SDK de desarrollo de Windows Phone 7.5. Que tiene, a mi parecer, uno de los mejores emuladores de dispositivo móvil posibles.

API Battlet.net

Aunque parezca una perogrullada, lo primero que hago cuando me enfrento a un nuevo API, es leerme su documentación y realizar los ejemplos. Así con escribir en mi navegador,

http://eu.battle.net/api/wow/realm/status

Obtengo una respuesta codificada en Json con mucha información sobre el estado de los reinos del juego de Europa. Y, leyendo el resto de la descripción del API, me hago consciente de que tengo acceso de una forma fácil y sencilla a un gran volumen de datos de mi juego favorito.

Otra cosa que hay que tener en cuenta cuando desarrollo con una API de terceros, son las condiciones de uso. Cuando, como y si hay que pagar. Y que puedes y no puedes hacer si quieres utilizar la herramienta.

En este caso Blizzard utiliza un modelo similar al de Software Libre. Es decir, el código debe estar visible; no puedes ganar dinero de ninguna forma (ni directa, ni indirectamente), si la aplicación utiliza los servicios del API; no puedes utilizar los nombres, gráficos y colores de Blizzard; y, curioso, te recuerda que desarrollar con esta API no significa que tengas un acuerdo o contrato con ellos.

Llamadas asíncronas

Esto implica que primero voy a realizar la petición a la url y, en vez de quedarme esperando la devolución de datos, espero que se lance el evento que me avisa que se ha completado la operación.

private void GetPersonaje()



	
{



  string uri = http://eu.battle.net/api/wow/character/los-errantes/bendemfalar;







  var webclient = new WebClient();



  webclient.DownloadStringCompleted += OnDownloadStringCompleted;



  webclient.DownloadStringAsync(new Uri(uri));



	
}




	
	
private void OnDownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)



	
{



  // GestorDeJson lectorJSon = new GestorDeJson();



  // lectorJSon.RecuperaDatosPersonaje(e.Result);



	
}

Aunque del primer vistazo parece complejo, realmente no lo es. Voy a desglosarlo para que sea más fácil de entender.

Lo primero que declaro es la url que voy a invocar para obtener la información.

string uri = http://eu.battle.net/api/wow/character/los-errantes/bendemfalar;

var webclient = new WebClient();

webclient.DownloadStringCompleted += OnDownloadStringCompleted;

webclient.DownloadStringAsync(new Uri(uri));

private void OnDownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)



	
{



   GestorDeJson lectorJSon = new GestorDeJson();



   lectorJSon.RecuperaDatosPersonaje(e.Result);



	
}

Más información | Blizzard Community Platform API Documentation, WebClient
En GenbetaDevv | Cómo hacer un escaner para Twitter

Los lenguajes, como casi todo en este universo que tiende a la entropía, van evolucionando y ganando complejidad con el tiempo. Así nos encontramos con la paradoja de que cuanto más completa es la sintaxis, más ilegible se puede volver el código.

Por ejemplo, la máxima que decía “escribe la menor cantidad de código, que vaya lo más rápido posible”, tiene un orden de prioridad menor frente a paradigmas de programación más modernos como Clean Code o KISS.

Por ello ahora quiero compartir una técnica para facilitar la legibilidad de nuestros programas y que trata de la sobrecarga de los métodos.

Qué es sobrecargar

Me pongo manos a la obra, creo un proyecto de consola y, en el inicio del programa, hago que escriba por consola el resultado de un método llamado suma().

using System;


namespace GenbetaDevConsola



{

    class Program

    {

        static void Main(string[] args)

        {

            System.Console.Write(suma(1, 1));

        }

    }



}

private int suma(int numero1, int numero2)



{

  return numero1 + numero2;



}

Tengo dos opciones. Una sería crear un nuevo método que se llame algo como sumaDouble() y que tenga dos números doubles por parámetros. La otra opción es sobrecargar el método suma con nuevos parámetros, pudiéndolo utilizar indistintamente en un caso o en el otro.

private int suma(double numero1, double numero2)



{

  int numero = 0;

  Int32.TryParse((numero1 + numero2).ToString(),out numero);

  return numero;



}

Es más, puedo ir añadiendo complejidad a mi método suma aceptando más parámetros y de diferente tipo como, por ejemplo, poder sumar tres cantidades o hacer sumas booleanas.

private static int suma(int numero1, int numero2, int numero3)



{

  return numero1 + numero2 – numero3;



}


	
private static int suma(Boolean numero1, Boolean numero2)



{

  return numero1 == numero2? 1 : 0;



}

Fíjate que lo importante de utilizar sobrecargas, es que encapsulo el funcionamiento de los métodos de forma que siempre llamo a suma(), y solo me debo preocupar de cumplimentar correctamente alguna de sus posibles firmas.

Por cierto, por si alguno desconoce el concepto de firma, MSDN dice:

Los métodos se declaran en una clase o struct mediante la especificación del nivel de acceso como public o private, modificadores opcionales como abstract o sealed, el valor devuelto, el nombre del método y cualquier parámetro de método.Todos esos elementos constituyen la firma del método.

Mejorando las sobrecargas

Puedo declarar un método y ponerle por defecto un valor a cada uno de sus parámetros. Por ejemplo si quiero calcular la hipotenusa puedo crear un método tal cual,

public static double calculaHipotenusa

                                      (

                                        double cateto1 = 100,

                                        double cateto2 = 100,

                                        double hipotenusa = 0
         
                                       )



{ 

  return Math.Sqrt(Math.Pow(cateto1,2) + Math.Pow(cateto1,2));



}

static void Main(string[] args)



{

  System.Console.Write(calculaHipotenusa());

  System.Console.Write(calculaHipotenusa(100));

  System.Console.Write(calculaHipotenusa(100, 50));

  System.Console.Write(calculaHipotenusa(cateto2:50));



}

Ahora fíjate en la última forma de llamar al método. Estoy introduciendo el nombre del parámetro que quiero cargar. Esto, que parece trivial, nos alivia de tener que construir un método sobrecargado para cada una de las firmas. Y tampoco debemos de invocar el método con todos sus parámetros, ya que solamente remito los que quiero enviándolos por su nombre.

Por último, y si tienes ganas de jugar más fuerte, te puedes meter en la sobrecarga de operadores. Es decir, darle comportamientos particulares y específicos a cosas como +, -, =, etc. Así puedo hacer una suma directa de valores booleanos en una clase sin tener que construir un método con esa firma.

Pero esto yo no lo he utilizado nunca y no encuentro ahora mismo donde aplicarlo.

Más información | Métodos (Guía de programación de C#), Nuevas características de C# en .NET Framework 4

Tengo que reconocer que Twiter se ha convertido en una fuente de información sorprendente. Como leí en algún sitio “desde que existe twiter, siempre leo en el periódico noticias antiguas“.

Esto viene al caso al llegarme por este medio un rumor que, al principio, no me podía creer. El rey del “spaguetti code“, el causante de inmenso dolor en los tiempos del GWBASIC, el paradigma de lo que no se tiene que utilizar; aún vive.

Y estoy hablando de la sentencia de salto absoluto GOTO.

Lo que parecía una broma, me ha llevado a la página de MSDN, en donde he leído boquiabierto que no solamente no es un recuerdo lejano de un pasado secuencial, si no que se sigue implementado en .NET.

Y para comprobar que funciona, traigo un ejemplo escrito en C# con Visual Studio 11 beta. Lo cual significa que en el novísimo framework 4.5, aún se puede utilizar.

int numero = 0;
int suma = 0;
switch (numero)

  {

    case 1:

      suma += 20;

      break;

    case 2:

      suma += 30;

      goto case 1;

    case 3:

      suma += 50;

      goto case 1;

    default:

      suma = 0;

      break;

  }

Me he quedado sin palabras…

Más información | MSDN: goto (Referencia de C#)

Como es sabido, Android se basa en Java y Java pertenece a Oracle. De momento no ha habido hostilidades pero siempre es posible que el belicoso Larry Ellison decida un día tirar de patentes y pedir dinero a espuertas Y las previsibles hostilidades entre Google y Oracle van subiendo de tono cada semana. Por eso la migración de Android a otros cimientos es algo de lo que se viene hablando hace tiempo. Pues bien, ahora la gente de Xamarin ha portado el código en Java de Android a C# (con la herramienta Sharpen) y lo han hecho correr sobre .NET pero no la implementación de de Microsoft sino sobre Mono (que la misma gente de Mono había creado antes de formar la empresa). Al resultado lo han XobotOS.

Este XobotOS es tan sólo un proyecto de investigación que no va a ser continuado por la gente de Xamarin pero al ser software open source con una licencia Apache, es posible que alguien (incluso la propia Google) se aproveche del gran trabajo previo realizado (millones de líneas de código portadas) para sacar un sistema operativo Android completo sin ningún atisbo de Java.

Pd: en Xamarin afirman que los resultados de este XobotOS son mejores que los de Java con Dalvik (el primo hermano de la JVM de Google)

Vía | Ars Technica
Foto | Xamarin
Más info | Xamarin
Descarga | Github