Planeta Código

Fetishcode

ADF Skin Editor. Apuntes

Enero 18th, 2012 - [Enlace local]

Today's problem is sharing one single virtual host with different Tomcat instances. For example, say you have your Apache (the web server) with a virtual host for intranet and you have in different Tomcat instances different applications like: monitoring, dashboard and hradmin. You want your users to be directed to the correct application if they access the URL http://intranet/dashboard or http://intranet/hradmin.

In this example I'm using three Tomcat servers and this applications:

server1:8080/monitoring/
server1:8080/dashboard/
hr1:8080/hradmin/
hr2:8080/hradmin/

The server1 Tomcat is running two different applications and the hr1 and hr2 are running the hradmin application which we want to be load balanced and since it's critical, to be always available.

The first thing to do is create the jkworkers.properties file:

# This names are the ones defined bellow

worker.list=server1,hrlb

worker.lock=P

worker.status.type=status



# Single server running monitoring and dashboard

worker.server1.type=ajp13

worker.server1.host=192.168.1.2

worker.server1.port=8080

worker.server1.disabled=false

worker.server1.socket_timeout=60000

worker.server1.connect_timeout=60000



# Two workers for two servers running a critical application

worker.hr1.type=ajp13

worker.hr1.host=192.168.1.3

worker.hr1.port=8080

worker.hr1.disabled=false

worker.hr1.socket_timeout=60000

worker.hr1.connect_timeout=60000



worker.hr2.type=ajp13

worker.hr2.host=192.168.1.4

worker.hr2.port=8080

worker.hr2.disabled=false

worker.hr2.socket_timeout=60000

worker.hr2.connect_timeout=60000



# Loadbalancer configuration for the critical application

worker.hrlb.type=lb

worker.hrlb.balance_workers=hr1,hr2

worker.hrlb.sticky_session=true

worker.hrlb.sticky_session_force=false

worker.hrlb.method=R

Of course, you should use the DNS names instead of the IP addresses. Also, there are many more options to be set here, but this should give you a good start.

Second, you need your jk.conf file:

JkWorkersFile /etc/apache2/conf.d/jkworkers.properties

JkLogFile /var/log/apache2/mod_jk.log

JkLogLevel info

JkLogStampFormat "[%a %b %d %H:%M:%S %Y]"

JkOptions +ForwardKeySize +ForwardURICompatUnparsed -ForwardDirectories

JkRequestLogFormat "%w %V %T"

JkShmFile /var/log/httpd/jk.shm

<Location /jkstatus>

    JkMount status

    Order deny,allow

    Deny from all

    Allow from 127.0.0.1

</Location>

And finally, you can set up your virtual host in the, for example, intranet.conf file:

<VirtualHost *:80>

  ServerName intranet

  RewriteEngine on



  # Here we set where we want the url http://intranet/ to go

  RedirectMatch ^/$ /dashboard/



  DocumentRoot /srv/www/htdocs/docroot

  CustomLog  /var/log/apache2/access_reports combined

  ErrorLog  /var/log/apache2/error_reports

  

  # You can even setup a jongo proxy

  ProxyPass /jongo/ http://192.168.1.5:8080/jongo/

  ProxyPassReverse /jongo/ http://192.168.1.5:8080/jongo/

  

  # It's important that this names are the same used in your Tomcat

  JkMount /dashboard/* server1

  JkMount /monitoring/* server1

  JkMount /hradmin/* hrlb

</VirtualHost>

What we're doing here is telling the Apache server to listen on port 80 for all requests to the intranet host and to forward this requests to their corresponding applications:

http://intranet/ goes to http://server1/dashboard/
http://intranet/dashboard/ goes to http://server1/dashboard/
http://intranet/monitoring/ goes to http://server1/monitoring/
http://intranet/hradmin/ goes to http://hr1/hradmin/ or to http://hr2/hradmin/

Where you put this files depends on your httpd.conf configuration.

This example will allow a vanilla Apache to serve three different applications (one load balanced) from three Tomcat servers (server1, hr1 and hr2)

» Leer más, comentarios, etc...

Fetishcode

TreeTable Editable

Enero 17th, 2012 - [Enlace local]

» Leer más, comentarios, etc...

Variable not found

Introducción a SignalR (I): Conceptos básicos

Enero 17th, 2012 - [Enlace local]

Uau!! Una aplicación que mezcla internet, asincronía, y múltiples usuarios colaborando e interactuando al mismo tiempo siempre es merecedora de un “¡uau!”. Seguro que, al igual que un servidor, en algún momento os habéis quedado maravillados con la interactividad que presentan algunos sistemas web modernos, como Facebook, Google Docs, o muchos otros, en las que estamos recibiendo actualizaciones, prácticamente en tiempo real, sin necesidad de recargar la página.

Por ejemplo, en Google Docs, si estamos editando un documento online y otro usuario accede al mismo, podemos ver sobre la marcha que ha entrado, e incluso las modificaciones que va realizando sobre el documento. O algo más cotidiano, en un simple chat vía web van apareciendo los mensajes tecleados por nuestros compañeros de sala como por arte de magia. Ambos sistemas utilizan el mismo tipo de solución: el envío asíncrono de datos entre servidor y clientes en tiempo real.

En esta serie de artículos veremos cómo podemos implementar sorprendentes funcionalidades de este tipo utilizando SignalR, un framework open source desarrollado por gente del equipo de ASP.NET, que nos facilitará bastante la tarea.

¿Cómo puede el servidor enviar eventos al cliente de forma asíncrona?

Crear este tipo de sistemas usando herramientas convencionales nos puede causar algunos dolores de cabeza, principalmente porque los protocolos que sustentan la web están basados en un modelo cliente-servidor síncrono: uno o varios clientes realizan una conexión hacia el servidor y le transmiten una acción a realizar, éste la procesa y les retorna la respuesta, cerrándose la conexión de forma inmediata.

Polling

A priori, no hay forma de que el servidor sea el que notifique a los clientes los cambios de estado (por ejemplo, la llegada en un chat de un mensaje procedente de otro usuario), salvo que éstos utilicen un mecanismo de polling, es decir, que estén continuamente estableciendo conexiones con el servidor para ver si hay algún nuevo evento a tener en cuenta.

Aunque válido en determinados escenarios, hay otros en los que se trata de una solución demasiado costosa, sobre todo cuando hay que gestionar un alto número de clientes conectados.

El ideal sería utilizar una conexión persistente, siempre abierta, entre cliente y servidor, que permitiría el envío y recepción de mensajes y eventos de forma bidireccional entre ambos. De esta forma, si el servidor tiene algo que enviar a sus clientes, simplemente tendría que transmitirlo por el canal que mantendría abierto con cada uno de ellos.

Conexión persistente

Sin embargo, hasta ahora esto sólo se podía conseguir usando sockets, lo cual, en entorno web, requería la existencia de algún tipo de elemento activo sobre la página (Silverlight, Flash, o applets Java, por ejemplo) capaz de establecer este tipo de comunicaciones.

Afortunadamente, la W3C parece dispuesta a cambiar esta situación al introducir de forma nativa los famosos WebSockets, cuya definición se encuentra todavía en borrador. Esta nueva API permitirá abrir conexiones directas desde el navegador usando Javascript, por lo que podría ayudarnos bastante una vez su implementación sea universal en los agentes de usuario. De momento no es así, aunque ya está disponible en algunos de ellos (podéis ver una demo simple aquí con Chrome).

Logo de HTML5

También existe otra iniciativa de la W3C que podría ayudar a enviar mensajes o eventos desde el servidor a los clientes suscritos, llamada Server-Sent Events. Como en el caso anterior, se encuentra en borrador, aunque ya algunos navegadores lo implementan (podéis ver una demo aquí con Chrome), por lo que todavía no podemos utilizarla de forma segura.

Por esta razón, existen hoy en día múltiples soluciones que permiten solventar las limitaciones del protocolo, como las englobadas bajo la denominación Server push o Comet, aprovechando los recursos existentes en los protocolos utilizados para crear, o al menos simular, este canal abierto continuo entre cliente y servidor utilizando polling, long polling, HTTP streaming, y otros artificios.

Por ejemplo, el mecanismo long polling utiliza peticiones HTTP para crear una conexión “pseudopersistente”. El servidor, en lugar de procesar la petición y retornar la respuesta de forma inmediata, espera hasta que haya disponible algún evento o mensaje a enviar al cliente; en este momento, lo retorna como respuesta a la petición original y cierra la conexión. El cliente, por su parte, procesa esta respuesta y realiza inmediatamente después una nueva petición al servidor, que volverá a quedar abierta a la espera de mensajes, y así sucesivamente.

En definitiva, se trata de un mecanismo más limpio y eficiente que el polling, puesto que evita gran cantidad de peticiones absurdas que se producen cuando en el servidor no hay eventos pendientes de notificar. Además, dado que utiliza HTTP estándar, es válida para todo tipo de agentes de usuario, y bastante amigable para proxies, filtros, firewalls y otros inconvenientes que puede haber por el camino entre los dos extremos.

Y en este punto es donde entra en escena SignalR, un conjunto de componentes desarrollados por Damian Edwards y David Fowler, miembros del equipo de ASP.NET en Microsoft, que nos abstrae de los detalles subyacentes y nos ofrece la visión y ventajas de un entorno conectado en el que podemos comunicar cliente y servidor bidireccionalmente, de forma asíncrona, y con una sencillez pasmosa. SignalR nos hace ver como si cliente y servidor estuvieran conectados de forma continua y facilita el envío de mensajes asíncronos bidireccionales entre ambos extremos.

Por último, es importante decir que SignalR no es específico para ASP.NET MVC, ni para WebForms: podemos utilizarlo con cualquier tipo de proyecto web. De hecho, incluso se puede utilizar en otro tipo de proyectos usando un servidor self-hosted :-)

SignalR, conceptualmente

SignalR ofrece una visión a muy alto nivel de la comunicación entre el servidor y los múltiples clientes que se encuentren a él conectados. Y cuando digo “alto nivel”, creedme que estoy hablando de muchos metros de altura ;-)

Como desarrolladores, trabajaremos sobre una conexión virtualmente siempre abierta: en servidor podremos detectar cuándo se ha conectado un nuevo cliente, cuándo se ha desconectado, recibir mensajes de éstos, enviar mensajes a los clientes conectados…, en definitiva, todo lo que podemos necesitar para crear aplicaciones asíncronas multiusuario.

Sin embargo, en realidad estas conexiones persistentes no existen, o no tienen por qué existir. Se trata de una abstracción creada por SignalR, que el que se encargará del trabajo sucio que hay por debajo, manteniendo la conexión de los clientes con el servidor mediante distintos mecanismos denominados “transportes”, que son el conjunto de tecnologías utilizadas para mantener crear la conexión continua, o al menos la ilusión de su existencia.

Lo interesante de los protocolos de transporte es que pueden ser sustituidos de forma transparente sin afectar a nuestras aplicaciones, que trabajarán aisladas de estos detalles. Nuestros sistemas funcionarán exactamente igual sea cual sea el transporte utilizado, lo que permite que éste sea elegido en cada escenario en función de la disponibilidad de las tecnologías en ambos extremos.

Por ejemplo, el transporte Websockets es capaz de crear una conexión con el servidor y mantenerla abierta de forma continua, aunque requiere que esta tecnología esté disponible tanto en el cliente (en el caso de clientes web, es necesario que el navegador implemente Websockets) como en el servidor.

Long polling, el transporte utilizado por defecto en SignalR

Long polling, el transporte utilizado por defecto en SignalR

Debido a ello, y para asegurar la máxima compatibilidad con los clientes, actualmente se utiliza por defecto el transporte denominado Long polling, que ya hemos comentado anteriormente.

Observad que, a pesar de la relativa complejidad que supondría implementar algo así a mano, nosotros no tendremos que hacer nada: SignalR se encarga de llevar a cabo todas estas tareas para ofrecernos la sensación de estar siempre conectados.

Su componente cliente será el encargado de realizar las conexiones, mantenerse a la espera de noticias del servidor, reconectar cuando se reciban eventos o cuando por cualquier otra causa se haya perdido la conectividad, etc., ofreciéndonos una superficie de desarrollo muy simplificada.

El lado servidor de SignalR, por otra parte, será el encargado de recibir la conexión y mantenerla en espera, almacenar los mensajes recibidos, realizar el seguimiento de clientes conectados, enviar mensajes a través de un bus interno, etc., y de la misma forma, ofreciéndonos un API bastante simple para implementar nuestros servicios.

Implementación de servicios con SignalR

SignalR nos ofrece dos fórmulas para trabajar sobre las conexiones que crea con el servidor:

usando “conexiones persistentes”, es la de más bajo nivel y proporciona mecanismos simples para registrar conexiones y desconexiones de clientes y comunicarse de forma bidireccional con ellos. De hecho, esta forma de crear servicios es bastante similar a como hacemos utilizando sockets.
usando “hubs”, que ofrece una abstracción aún mayor, permitiendo la comunicación entre cliente y servidor de forma casi mágica. Esta es la opción que convendrá utilizar en la mayoría de ocasiones, por la potencia que aporta y su gran comodidad de uso.

En cualquiera de los dos casos, y ya centrándonos en el entorno web más habitual, donde el servidor es una aplicación ASP.NET y los clientes van a ser las páginas o vistas en las que tendremos un motor de scripting, la implementación de servicios consistirá en:

en el servidor, crear el servicio (también llamado endpoint) con las funcionalidades que nos interese, utilizando las clases disponibles en el ensamblado SignalR.
en cliente, crear el consumidor del servicio utilizando las clases disponibles en la biblioteca de scripts jQuery.SignalR.js (o su correspondiente versión minimizada).

Cada una de las dos fórmulas citadas tiene sus particularidades, por lo que las estudiaremos mediante el desarrollo de ejemplos independientes en futuros posts de la serie.

Pero primero, veamos rápidamente cómo podemos incluir este componente en nuestros proyectos, aunque desde luego más sencillo no puede ser… ;-)

Instalación de SignalR

El sitio web oficial del producto (signalr.net), a día de hoy, es una simple redirección hacia Github, donde se encuentra la documentación y el código fuente del proyecto. Aunque podríamos descargarlo desde ahí, la opción más sencilla, como siempre, es utilizar Nuget:

PM> Install-Package signalr
Attempting to resolve dependency 'SignalR.Server (≥ 0.3.5)'.
Attempting to resolve dependency 'Microsoft.Web.Infrastructure (≥ 1.0.0.0)'.
Attempting to resolve dependency 'SignalR.Js (≥ 0.3.5)'.
Attempting to resolve dependency 'jQuery (≥ 1.6)'.
Successfully installed 'Microsoft.Web.Infrastructure 1.0.0.0'.
Successfully installed 'SignalR.Server 0.3.5'.
Successfully installed 'SignalR.Js 0.3.5'.
Successfully installed 'SignalR 0.3.5'.
Successfully added 'Microsoft.Web.Infrastructure 1.0.0.0' to SignalRDemo.
Successfully added 'SignalR.Server 0.3.5' to SignalRDemo.
Successfully added 'SignalR.Js 0.3.5' to SignalRDemo.
Successfully added 'SignalR 0.3.5' to SignalRDemo.

Esta instalación incluye, además de algún elemento infraestructural, dos componentes de SignalR:

SignalR.Server, que es la biblioteca de servidor principal para integrar en aplicaciones ASP.NET.
SignalR.Js, la biblioteca Javascript necesaria para conectar desde cliente (páginas web) con el servidor.

Existen también otros clientes específicos para .NET, como SignalR.Client (cliente genérico), SignalR.Client.Silverlight (específico para SL), o SignalR.Client.WP7 (específico para Windows Phone 7), que podemos instalar de forma independiente.

Además, tanto en Nuget como en el sitio web del producto podéis encontrar otros paquetes interesantes a los que vale la pena echar un vistazo, como SignalR.Sample, un ejemplo completo de uso de este componente, SignalR.SelfHost, que permite activar el servidor sin usar ASP.NET, o SignalR.Websockets, un adaptador (o transporte, en argot SignalR) para usar Websockets para el mantenimiento de la conexión entre cliente y servidor.

Observaréis que en todos los casos se trata de versiones muy preliminares pero que podemos ir probando y disfrutando desde ya, porque funcionan bastante bien. Podéis comprobarlo accediendo a http://jabbr.net/, un chat implementado sobre SignalR donde podréis encontrar charlando hasta a los mismísimos padres de la criatura. :-)

En el próximo post veremos cómo implementar clientes y servicios SignalR utilizando conexiones persistentes, el enfoque de menor nivel ofrecido por este fantástico componente.

Publicado en: Variable not found.

» Leer más, comentarios, etc...

Picando Código

ArchLinux: pacman 4 en el repositorio principal

Enero 16th, 2012 - [Enlace local]

pacman

Llegó la hora de actualizar nuestros sistemas operativos ArchLinux a pacman 4. En esta versión trabajaron 24 personas creando 893 commits. Pueden ver todos los cambios en este enlace. La característica más esperada de esta versión es el firmado gpg de los paquetes, algo que generó bastante controversia en su momento en la comunidad de Archers.

De todas formas, esta característica viene deshabilitada por defecto en la configuración de pacman. Esto será así hasta que se pulan algunos detalles de la nueva funcionalidad. Para probar la verificación de los paquetes, tenemos que antes darnos una vuelta por la wiki de Arch e informarnos sobre Pacman-key.

pacman 4

En algunas ocasiones, la actualización de pacman puede requerir intervención manual. Por ejemplo en mi sistema:

error: failed to prepare transaction (could not satisfy dependencies)
 :: package-query: requires pacman<3.6
 :: pyalpm: requires pacman<3.6

Al intentar desinstalar el paquete pyalpm, encontré otras dependencias hasta que pude corregir la instalación completa haciendo:

[fernando@hoth ~]$ sudo pacman -R pyalpm namcap package-query yaourt

Ya luego no hubo problemas para instalar pacman:

[fernando@hoth ~]$ sudo pacman -S pacman

Y ya con la nueva versión volví a instalar yaourt y demás

» Leer más, comentarios, etc...

xailer.info (esp)

Quick Open

Enero 16th, 2012 - [Enlace local]

En esta ocasión traemos a un complemento para el IDE similar a SessionManager SessionManager, pero que en vez de manejar grupos de archivos como sesiones nos permite filtrar y abrir archivos de un proyecto rápidamente.

Al seleccionar la opción del menú:

Quick open menu

Se lanza un formulario que contiene un control de edición y la lista de archivos que forman parte del proyecto.

En el control de edición se puede escribir una máscara para filtrar los archivos. Se permite el uso de comodines como ? y * y su funcionamiento es idéntico a la función Directory() estándar de Harbour.

Quick open

En la lista de archivos se pueden seleccionar más de uno con Ctrl+Click o varios seguidos con Shift+Click/Shift+Cursores. Su funcionamiento es idéntico a un control Listbox estándar.

Haciendo doble click o pulsando [Enter] sobre el nombre de un archivo se abrirá en el editor de código o se seleccionará si ya estaba abierto. Si hay varios archivos seleccionados al pulsar [Enter] se abrirán todos en el editor.

Si se cambia a otro proyecto, al hacer click en el formulario se recarga automáticamente la lista de archivos del nuevo proyecto por lo que no es necesario cerrar y volver a abrirlo para actualizarlo.

El formulario se puede redimensionar y mover al lugar de la pantalla que se prefiera y su posición y tamaño será recordado la próxima vez que se utilice.

El plugin sólo funciona con Xailer 2.5 y Xailer 2.5.1

El enlace para la descarga: QuickOpen

» Leer más, comentarios, etc...

carlosrovira.com

Propuesta Apache Flex Logo Contest

Enero 16th, 2012 - [Enlace local]

Estos días se está celebrando el Apache Flex Logo Contest. Ante todo decir que el cambio de Adobe Flex a Apache Flex se está realizando de forma estupenda y toda la comunidad está apoyando el proyecto de forma amplia haciendo que todo el mundo esté muy sorprendido de la aceptación que tiene este cambio tan importante en la tecnología Flex superando con creces las expectativas o los pronósticos que muchos tenían.

Como parte de las iniciativas de Apache Flex se encuentra el nuevo blog y el “rebranding”. Es evidente que el logo de Adobe Flex es parte de la estratégia de marketing de Adobe y es crucial definir un nuevo estilo para la marca. Para esta razón este Adobe Flex Logo Contest de donde saldrá el logo final por elección popular.

Os dejo mi propuesta y si os gusta os pido que la votéis! .

Go! Apache Flex Go!

» Leer más, comentarios, etc...

Escuela De Codigo

Git, una guía básica para el que no sabe nada de control de versiones

Enero 16th, 2012 - [Enlace local]

Git, el afamado sistema de control de versiones……¿control de versiones?? Si tu sabes un sistema de control de versiones, Subversion? Mercurial? Git? Un control de versiones….creo que no sabes de lo que hablo…muy bien…hagamos las preguntas correctas primero: ¿Que es un control de versiones? y ¿que es un sistema de control de versiones?

Se llama control de versiones a la gestión de los diversos cambios que se realizan sobre los elementos de algún producto o una configuración del mismo

Un control de versiones no es mas que llevar un registro de las modificaciones de tus archivos, asi por ejemplo cuando haces una pagina web y la envías al cliente, este te dice que le cambies algo pero, tu siendo precavido antes de hacer algún cambio piensas “¿Y si mi cliente después se arrepiente y quiere que deje todo como esta?” y es en ese momento que se te ocurre la muy acertada idea de copiar el archivo antes de modificarlo y guardarlo por ahí con algún nombre que lo identifique como el archivo original. Y sobre la copia haces los cambios, y ese proceso se repite siempre que tu cliente te pide una modificación. Una y otra vez. Pues bien eso que haces es un control de versiones, eso si uno muy primitivo.

Esa forma de llevar tu control de versiones esta muy lejos de ser la manera correcta, la ideal, la soñada. Al contrario con el tiempo tener copias de copias de archivos es insostenible, es una locura, un completo infierno!! sobre todo cuando trabajas con proyectos grandes o con múltiples clientes. Es en ese momento que te preguntas: ¿No hay una mejor forma de hacer esto? Si, existe. Se llama Sistema de Control de Versiones.

Un sistema de control de versiones tiene que proporcionarte:

Mecanismo de almacenamiento de los elementos que deba gestionar (ej. archivos de texto, imágenes, documentación…)
Posibilidad de realizar cambios sobre los elementos almacenados (ej. modificaciones parciales, añadir, borrar, renombrar o mover elementos)
Registro histórico de las acciones realizadas con cada elemento o conjunto de elementos (normalmente pudiendo volver o extraer un estado anterior del producto)

Un sistema de control de versiones, hace lo mismo que tu haces copiando archivos, solo que mucho mejor, los ordena, los cataloga, lleva un registro de cada minúsculo cambio, guarda todas las versiones, puedes revertir a cualquier punto en cualquier momento, etc, etc.

Ahora si.

Habiendo dejado claro que es el control de versiones…

Git, el afamado sistema de control de versiones, nació un día como cualquiera en el que Linus Torvalds se dijo “Carajo necesito llevar un control de todos los archivos del kernel de Linux” ”Que sea rápido, muy rápido, fácil, bonito y espectacular” Bueno algo asi tuvo que haberse dicho. Y fue así como inicio Git, un sistema de control de versiones distribuido es decir, cada usuario tiene su propio repositorio. No es necesario tomar decisiones centralizadamente. Los distintos repositorios pueden intercambiar y mezclar revisiones entre ellos.

Instalación

Linux

 apt-get install git-core

Mac Os X

Primero Instala HomeBrew y luego en una terminal escribe

 brew install git

Windows

Descarga Git para Windows y lo que sigue no es nada del otro mundo, next, next, finish.

Configuración Inicial

Lo primero que deberías hacer cuando instalas Git es establecer tu nombre de usuario y dirección de correo electrónico. Esto es importante porque las confirmaciones de cambios (commits) en Git usan esta información, y es introducida de manera inmutable en los commits que envías:



git config –global user.name “Fulano de Tal”

git config –global user.email fulanodetal@example.com

De nuevo, sólo necesitas hacer esto una vez si especificas la opción –global, ya que Git siempre usará esta información para todo lo que hagas en ese sistema. Si quieres sobrescribir esta información con otro nombre o dirección de correo para proyectos específicos, puedes ejecutar el comando sin la opción –global cuando estés en ese proyecto.

Comandos básicos para empezar

Luego de instalar, configurar y que Git ya esta corriendo en tu computadora. Ahora veremos los comandos mas básicos y las acciones mas comunes que se realizan cuando trabajas con Git.

Crear un repositorio nuevo

Con una terminal crea un directorio nuevo, abrelo y ejecuta

 git init

Y ya con eso has creado un nuevo repositorio

Hacer checkout a un repositorio

Para crear una copia de un repositorio local

 git clone /path/to/repository

Si el repositorio esta en un servidor remoto el comando cambia un poco

 git clone username@host:/path/to/repository

¿Repositorio? Un repositorio no es mas que un almacén de archivos, es un sitio donde tu sistema de control de versiones organiza, almacena y lleva el historial de cambios de tus archivos.

Antes de seguir con los comandos es buen momento para explicar un poco la manera en que trabaja Git. Basicamente tu repositorio local esta compuesto por 3 “arboles” que son administrados por Git. El primero es tu Directorio de trabajo el cual contiene los archivos. El segundo es el Index el cual actúa como un area intermedia y finalmente el HEAD el cual apunta a el ultimo commit realizado.

add y commit

Cuando cambias tus archivos o quieres agregar nuevo (es decir agregarlo al Index) ejecuta

 git add

O si son muchos los archivos que quieres agregar puedes ejecutar

 git add *

Este es el primer paso en el flujo de trabajo basico. Para en realidad hacer commit a estos cambios usa

 git commit -m “Tu mensaje”

Ahora el archivo esta incluido en el HEAD, pero no aun en tu repositorio remoto.

¿Commit? Es una confirmación de cambios. Es como decirle a Git “Oye! he modificado este archivo! Así que prepárate que pronto lo enviare al repositorio remoto”

push, enviar cambios a repositorio remoto

Si todos los cambios que hicieramos quedaran en nuestra computadora no tendria ningún sentido, ya que uno de los motivos por los que existe un sistema de control de versiones, es permitir trabajar colaborativamente con otras personas y compartir el mismo codigo de manera organizada. Y eso lo hacemos con push, enviar nuestros cambios al repositorio remoto para que este a disposicion de cualquiera que clone el repositorio.

git push origin master

master es la rama principal del repositorio, si deseas enviar tus cambios a otra rama sustituye master por el nombre de tu rama.

Se puede dar el caso que tu repositorio no lo hallas clonado, sino que has sido tu quien lo ha iniciado, entonces para subirlo inicialmente a tu servidor debes usar el siguiente comando

git remote add origin

Ahora ya puedes subirlo utilizando push

Ramas o branches

¿Ramas? Una rama o branch es una copia de tu repositorio que sirve cuando quieres agregar una nueva funcionalidad a tu proyecto pero, sin afectar el código principal, de esa manera programas en la rama y cuando estés listo, todo ese código lo integras una vez mas a la rama principal

Crea una nueva rama llamada “feature_x” y cambiate a ella usando

git checkout -b feature_x

regresa a la rama principal

git checkout master

y borra la rama

git branch -d feature_x

una rama no esta disponible para los demas a menos que subas (push) la rama a tu repositorio remoto

git push origin

Ya cuando estas seguro de los cambios en tu rama, y deseas que esten en la rama principal, simplemente te mueves a master y haces una fusion de archivos de la siguiente manera

git merge

Si ha leido con paciencia y atencion te daras cuenta que solo hemos hablado de enviar nosotros el código y los cambios al repositorio remoto, para que este disponible a los demás, evidentemente si trabajamos en equipo no seremos los únicos que haremos cambios, así que necesitaremos actualizar periódicamente nuestro repositorio con los cambios que los demás hallan hecho ¿Como hacemos eso?

Pull , actualizando

Para actualizar tu repositorio local al commit mas nuevo, ejecuta

git pull

Cuando actualizas tu repositorio local y cuando fusionas ramas, Git intenta auto fusionar los cambios pero, es muy común que existan conflictos (debido a que alguien a parte de tu persona, estuvo trabajando sobre el mismo archivo e inclusive sobre las mismas lineas de código) Cuando eso sucede entonces Git espera que arregles el problema manualmente y una vez lo has hecho marcar los archivo como fusionados ejecutando

git add

Y ahora ya el archivo esta listo para que lo envíes al repositorio remoto.

Me cagu#$%”% en todo!! Revirtiendo cambios

¿Un errorcito a cualquiera le pasa no? y por eso es que utilizamos un control de versiones: para regresar a un punto donde todo funcionaba como relojito suizo. Perfecto. Para viajar en el tiempo (de manera figurada) en nuestra repositorio local, y volver así a una copia del archivo, donde este aun no se habia corrompido o nosotros lo hallamos arruinado. Lo hacemos ejecutando

git checkout —

Esto reemplaza los cambios en tu árbol de trabajo con el ultimo contenido de HEAD.

Por otra parte si consideras que todo tu trabajo local es un enorme error (esperemos que eso no suceda muy a menudo), fácilmente puedes traerte de nuevo una copia del repositorio remoto y sustituirla.



git fetch origin

git reset –hard origin/master

Eso fue lo básico, hoy viene lo bueno!!

Si te ha parecido algo extenso el articulo y te has aburrido, dejame decepcionarte aun mas: lo que hemos visto es apenas lo básico, para los nuevos, para los principiantes. Hay muchooooo camino por recorrer y mucho por aprender. Sobre Git hay mucho escrito ya, asi que te dejare aquí varios enlaces para que profundices en el tema.

» Leer más, comentarios, etc...

Variable not found

Enlaces interesantes 68

Enero 16th, 2012 - [Enlace local]

Estos son los enlaces publicados en Variable not found en Facebook y Twitter del 9 al 15 de enero de 2012. Espero que os resulten interesantes. :-)

Y no olvidéis que podéis seguir esta información en vivo y en directo desde Variable not found en Facebook, o a través de Twitter.

Publicado en Variable not found

» Leer más, comentarios, etc...

Koalite's blog

Serialización ultra-rápida con Protobuf-net

Enero 16th, 2012 - [Enlace local]

Cuando no nos queda más remedio que preocuparnos por la serialización para aumentar la eficiencia de nuestra aplicación, ya sea reduciendo el tamaño de los datos serializados o disminuyendo el tiempo empleado en la serialización, nuestra mejor baza a día de hoy es utilizar Protocol Buffers:

Protocol buffers are a flexible, efficient, automated mechanism for serializing structured data – think XML, but smaller, faster, and simpler.

Protocol buffers son un mecanismo flexible, eficiente y automatizado para serializar datos estructurados, algo como XML pero más pequeño, más rápido y más simple.

En .NET hay varias librerías para usar Protocol Buffers. Las más utilizadas son el port de la versión java realizado por Jon Skeet y la versión de Mark Gravell, protobuf-net. De estas dos, me quedo con la protobuf-net por su sencillez de uso, su eficiencia y su compatibilidad con casi todas las versiones de .NET (de 2.0 en adelante, incluyendo Mono, Compact Framework y Silverlight).

¿Cómo de eficiente es?

Para ver realmente de qué estamos hablando, es interesante comparar la eficiencia de este protocolo de serialización con otros más conocidos. En la página de protobuf-net encontramos la siguiente comparativa serializando datos de Northwind:

Comparativa de algoritmos de serialización

La mejora de rendimiento, tanto en tiempo como en tamaño, es muy elevada. Con respecto a DataContractSerializer, podemos llegar a conseguir:

Reducir en un 60% el tiempo al serializar.
Reducir en un 80% el tiempo al deserializar.
Reducir en un 80% el tamaño del resultado de la serialización.

Obviamente estos resultados dependen de la naturaleza exacta de los datos que estemos manejando, pero en general las mejoras se mantienen en rangos parecidos a esos.

¿Cómo se usa?

Lo primero que necesitamos es descargar la última versión y añadir en nuestro proyecto una referencia al assembly protobuf-net.dll que necesitemos (en el paquete de descarga se incluyen versiones para distintas versiones de .NET).

Aunque protobuf-net soporta el uso de ficheros .proto para definir los mensajes, existe una forma mucho más sencilla: usar los atributos ProtoContract/ProtoMember para decorar las clases que queremos serializar:

[ProtoContract]
public class Person
{
    [ProtoMember(1)]
    public int Id { get; set; }
    [ProtoMember(2)]
    public string Name { get; set; }
    [ProtoMember(3)]
    public Address Address { get; set; }
    [ProtoMember(4)]
    public Person[] Friends { get; set; }
}

Lo único que hay que tener en cuenta es que cada propiedad decorada con ProtoMember debe estar identificada por un número diferente (tag, en terminología de protocol buffers). Como se ve en el ejemplo, es posible tener jerarquías de objetos complejas o incluir colecciones.

Además de esta opción, protobuf-net permite usar los atributos DataContract/DataMember, evitando así tener que referenciar protobuf-net desde el assembly donde se almacenan las clases a serializar. En ese caso, podemos dejar que sea protobuf-net el que asigne directamente los tags, o asignarlos nosotros manualmente usado la propiedad Order del atributo DataMember:

[DataContract]
public class Person
{
    [DataMember(Order = 1)]
    public int Id { get; set; }
    [DataMember(Order = 2)]
    public string Name { get; set; }
    [DataMember(Order = 3)]
    public Address Address { get; set; }
    [DataMember(Order = 4)]
    public Person[] Friends { get; set; }
}

Una vez que tenemos marcadas nuestras clases con unos atributos u otros, serializarlas es tan sencillo como usar un par de métodos estáticos de la clase Serializer:

// Serializar
var outputStream = GetOutputStream();
Serializer.Serialize(outputStream, person);

// Deserializar
var inputStream = GetInputStream();
var person = Serializer.Deserialize(inputStream);

Y no hay mucho más. Existen un par de sobrecargas para serializar/deserializar usando un prefijo que indica el tamaño de los datos que, aunque penalizan algo el rendimiento (sobre todo al serializar), permiten usar de forma más segura el protocolo a través de una conexión de red.

¿Por qué es tan eficiente?

Protocol Buffers es un protocolo muy eficiente por varios motivos. El primero de ellos es que se trata de un protocolo binario, en lugar de estar basado en texto como XML o Json. Esto supone directamente un menor consumo de memoria y un menor número de operaciones para convertir desde/hacia texto valores numéricos, fechas, etc.

Además, el resultado de serializar algo con protocol buffer no incluye meta información sobre lo serializado. Por ejempo, para almacenar un campo llamado “age” de tipo entero en XML o Json, tendríamos:

En XML:
    15
En Json:
    { "age" : "15" }

Sin embargo, en protocol buffers únicamente tendríamos el valor binario del tag y el valor binario del campo. Esto hace que nos ahorremos repetir continuamente los nombres de los campos serializados, pero a cambio nos impide interpretar un mensaje si no conocemos cómo está definido y qué tag se corresponde con qué campo.

El principal problema que podemos encontrar al trabajar con protocol buffers es precisamente ese, y es que los mensajes están diseñados para ser eficientes, no para ser legibles, por lo que no será tan sencillo depurar lo que está ocurriendo a partir del contenido de los datos generados.

En cualquier caso, si necesitas un protocolo de serialización rápido y fácil de manejar, pruébalo. Seguramente te sorprenda.

Compartir enlace:

Posts relacionados:

La importancia de la serialización

» Leer más, comentarios, etc...

Picando Código

Webcomics uruguayos: Mi Vida sin un Jetpack y Marche un Cuadrito

Enero 14th, 2012 - [Enlace local]

La producción de cómics uruguaya viene en aumento desde hace un buen tiempo. Como parte de esta cultura, no podían quedar afuera los webcómics. Hoy voy a compartir con ustedes un par de webcómics que sigo y vale la pena que conozcan.

Mi vida sin un jetpack

Mi Vida sin un Jetpack

Es un webcómic de MaGnUs quien como no ha obtenido el jetpack que le prometieron, decidió hacer cómics. MaGnUs es escritor, y ha participado de varios proyectos en el mundo de los cómics. Para esta ocasión se alió con Federico Taibó (más conocido como Taibox) para traernos pequeñas dosis autobiográficas en formato webcómic semanal. Ambos compañeros de foro en Multiverseros.

El sitio se actualiza todos los viernes con versiones en inglés y español. Cada historieta viene acompañada del relato de MaGnUs y una canción elegida para acompañar la tira. Los invito a entrar al archivo donde también pueden ver la galería de arte de invitados que aportaron sus interpretaciones de Mi Vida sin un Jetpack.

En algún momento pensé en copiarle la idea a MaGnUs y hacer mi propio webcómic: Mi Vida sin un Lanzallamas. ¿Por qué? Porque no tengo un lanzallamas (aunque nadie me ha prometido uno por ahora), y muchas cosas en la vida serían mas fáciles teniendo un lanzallamas…

Marche un cuadrito

Se trata de un proyecto que reune a varios artistas y dibujantes del entorno local y regional. Marche un Cuadrito ofrece una página de historieta por día. Cada día de la semana estará a cargo de uno o más historietistas, en su mayoría miembros de AUCH.

Las historietas:

Lunes
Regreso a las montañas de la locura
Guión: Rodolfo Santullo | Dibujo: Alejandro Rodríguez Juele
Adaptación libre de la obra de HP Lovecraft
Martes
Vientre
Guión: Roy | Dibujo: Lauri Fernández & Nacha Vollenweider
Dos mujeres, dos puntos de vista sobre la maternidad.
Miércoles
La liga latina
Guión: Silvio Galizzi | Dibujo: Matías Bergara
Anécdotas de viajes por iberoamérica en forma de historieta.
Jueves
El loco de los pájaros
Guión: Federico de los Santos | Dibujo: Sebastián Martínez
Una leyenda sobre la libertad en alta mar.
Viernes
Fedra
Guión y dibujo: Maco
El mundo interior de Fedra y su hermano Nino.
Sábado
La mudanza
Guión y dibujo: Nicolás Peruzzo
Una historia sobre seguir siguiendo
Domingo
Sacrificio
Guión y dibujo: Esteban Caballero
Luego de un horrendo crimen, ¿qué hay verdaderamente tras los hechos de Paso Cuarto?
Domingo
Ladoga Maldito
Guión y dibujo: Nahus
Para los que pueden contar el cuento, es un ángel, es un mártir, es el mismísimo diablo.

Espero que se den una vuelta por los respectivos sitios y con suerte se enganchen con estos webcomics

» Leer más, comentarios, etc...

Monocaffe

Python and Jongo

Enero 14th, 2012 - [Enlace local]

For some reason or another, I've always found Python support for RDBMS lacking behind Java, specially in the ORM area. Just imagine, there are no officially supported Python drivers to connect to an Oracle database and you must install the Oracle client... ugh!

Anyway, by having a Jongo server connected to your database you don't have to worry about installing any Python modules, you'll only need a standard Python 2.4+ installation with simplejson or Python 2.5+ which already support JSON.

Let's see, for example, an application which accesses the CIDB database and the Car table:

import jongo



class Car(jongo.JongoModel):

    def __init__(self, id=None, model=None, maker=None, fuel=None, transmission=None, year=None):

        jongo.JongoModel.__init__(self)

        self.id = id

        self.idCol = "cid"

        self.model = model

        self.maker = maker

        self.fuel = fuel

        self.transmission = transmission

        self.year = year



class CarStore(jongo.JongoStore):

    def __init__(self):

        jongo.JongoStore.__init__(self)

        self.model = Car

        self.proxy = jongo.Proxy("localhost:8080","cidb","car", Car)



if __name__ == '__main__':

    carstore = CarStore()

    carstore.load()

    for car in carstore.data:

        print car



    c1 = Car(None, "206cc", "Peugeot", "Gasoline", "Manual", 2008)

    carstore.add(c1)

    carstore.sync()



    c1 = carstore.getAt(carstore.count() - 1)

    c1.set('model', "206")

    c1.set('maker', "PPegoushn")

    carstore.update(c1)

    carstore.sync()



    # We need to refresh the object since it has changed after the sync

    c1 = carstore.getAt(carstore.count() - 1)

    carstore.remove(c1)

    carstore.sync()

Since this is Python, the code is pretty straightforward and self documented, right? For more information and examples on working with Python and Jongo check this page.

» Leer más, comentarios, etc...

xailer.info (esp)

Gestionando Sesiones

Enero 13th, 2012 - [Enlace local]

El IDE de Xailer nos permite guardar el estado del proyecto en el que estamos trabajando de modo que la próxima vez que arranque se carguen los mismos archivos que teníamos abiertos y podamos seguir en el mismo punto donde lo dejamos.

La única pega de esta opción es que no nos permite agrupar los archivos del proyecto para poder trabajar con ellos más cómodamente. En el caso de proyectos grandes o con muchos archivos solemos tener muchas pestañas abiertas en el editor de código para no tener que estar acudiendo continuamente al gestor de proyectos para abrir y cerrar archivos.

Para resolver esta incomodidad vamos a usar un plugin escrito expresamente para gestionar grupos de archivos comunes a los que llamaremos sesiones.

Una sesión estará formada por aquellos archivos que nosotros queramos y podemos agruparlos como mejor nos convenga o más cómodo nos parezca. Por ejemplo, supongamos un proyecto que contiene los siguientes archivos:

Clientes.prg
FrmClientes.prg
LstClientes.prg
EtiClientes.prg
Articulos.prg
FrmArticulos.prg
LstArticulos.prg
EtiArticulos.prg

Según la manera de trabajar de cada uno, habrá quien prefiera tener abiertos sólo un par de archivos como Clientes y Artículos, otros se decantarán por tener siempre abiertos todos los archivos relacionados con el módulo de Clientes o Artículos y otros abren y cierran archivos según se necesita.

Si a la lista anterior le añadimos los módulos de Agentes, Proveedores, Pedidos, Albaranes, Facturas, etc., la cosa empieza a complicarse exponencialmente y el manejo de los fuentes se vuelve incómodo y propenso a errores.

Aquí es donde entra en acción el plugin SessionManager para poner un poco de orden:

El plugin añade una nueva opción “Sesiones” al menú Archivo que nos permite guardar la lista de archivos abiertos en el editor de código en un momento dado (una sesión) para poder usarla cuantas veces queramos.

Siguiendo con el ejemplo anterior, podemos abrir todos los archivos del proyecto que estén relacionados con el módulo de Clientes:

Clientes.prg
FrmClientes.prg
LstClientes.prg
EtiClientes.prg

Y mediante la opción Archivo->Sesiones->Guardar sesión podemos grabar esta lista como “Clientes.ses” de modo que cuando queramos editar alguno de estos archivos sólo hay que abrir la sesión con Archivo->Sesiones->Cargar sesión y volveremos a tener los archivos abiertos igual que en el momento en que creamos la sesión.

La opción Guardar sesión graba la información relacionada con los archivos abiertos en el editor en un archivo de sesión pero no graba los archivos del editor que puedan haber sido modificados.

Además de las opciones para cargar y guardar sesiones, el menú ofrece una lista de archivos recientes que muestra las últimas sesiones a las que se ha accedido:

Y un gestor de sesiones para organizarlas a nuestro gusto:

El gestor muestra todas las sesiones disponibles para el proyecto, incluyendo el número de archivos que hay en cada sesión y la fecha/hora de su grabación.

Para cargar una sesión se puede utilizar tanto el botón [Cargar] como el doble click sobre un elemento de la lista de sesiones.

El botón [Renombrar] (y la tecla F2) permite cambiar el nombre a un archivo de sesión.

El botón [Duplicar] crea una copia del archivo seleccionado.

El botón [Eliminar] borra el archivo de sesión seleccionado pero no borra los archivos contenidos en la sesión y antes de eliminar se pide siempre confirmación.

El checkbox [X] Cerrar todos los archivos abiertos indica si al cargar una sesión se deben mostrar en el editor de código sólamente los archivos que están incluidos en la sesión o si se quieren conservar abiertos los archivos que ya están abiertos al cargar la sesión.

Para instalar el plugin, se debe descomprimir el ZIP en la carpeta Plugins que esté configurada en Herramientas->Opciones generales->Directorios->Archivos de usuario->Plugins y reiniciar el IDE.

Si se ha cargado correctamente aparecerá la nueva opción Archivo->Sesiones tal como se explicó antes, el plugin será visible desde Componentes->Gestor de plugins y haciendo doble click sobre su nombre aparecerá información sobre su nombre, versión, créditos, etc.

El plugin sólo funciona con Xailer 2.5 y Xailer 2.5.1

El enlace para la descarga: SessionManager

» Leer más, comentarios, etc...

Ingenieria de Software / Software Engineering / Project Management / Business Process Management

IIL’s Full Suite of PMP Preparation Tools

Enero 13th, 2012 - [Enlace local]

Estupendo material de apoyo para la preparación al examen de PMP

http://www.iil.com/pmp-preparation.asp

» Leer más, comentarios, etc...

Ingenieria de Software / Software Engineering / Project Management / Business Process Management

Steve Wozniak en SAP Forum México

Enero 13th, 2012 - [Enlace local]

Los primeros días de febrero se llevará a cabo el evento SAP Forum en Ciudad de México, en este evento estará participando uno de los cofundadores de Apple Steve Wozniak, sin duda alguna será muy interesante oir a este icono de la industria de Software

http://www.sg.com.mx/content/view/1247/2/

http://www.sap.com/mexico/about/events/sapforum2012/index.epx

» Leer más, comentarios, etc...

Picando Código

Global Game Jam: Encuentro mundial de creación de juegos

Enero 13th, 2012 - [Enlace local]

Global Game Jam

Uruguay se suma al Global Game Jam: Un hackatón de 48 horas para crear videojuegos. Gracias al groso de Rodrigo Fernández de UruguayGamer.com, Fernando Sansberro de Batovi Studios y el Dr. Gonzalo Frasca, el Jam le dió recientemente la bienvenida a nuestro país en su blog.

El evento cuenta con presencia en 212 ubicaciones en 46 países, entre los cuales se encuentran varios de habla hispana: Argentina, Colombia, Costa Rica, España, Méjico, Panamá, Perú, Uruguay y Venezuela.

Para el video introductorio, se anunció una lista de oradores impresionante: Will Wright, Baiyon, Gonzalo Frasca, Brenda Garno Brathwaite y John Romero. Si conocen ALGO del mundo de los videojuegos, tienen que conocer al menos uno (o dos) de esos nombres.

¡Cuenten conmigo! Siempre hay que aprovechar las oportunidades de este estilo. Voy a intentar repasar algo de PyGame para poder ir con alguna idea de desarrollo por lo menos. La creación de videojuegos es un tema en mi lista, pero no he hecho mucho al respecto más que algunas pruebas con PyGame mismo. Espero poder estar al nivel

Tengan en cuenta que el desarrollo de videojuegos es una actividad multidisciplinaria (bah, como casi todo en el mundo del desarrollo), donde no se necesitan solo programadores. Artistas, diseñadores, modeladores, gamers con muchas ideas, todos estos perfiles son bienvenidos y aportan a cada equipo.

Un video presentación del evento para entender un poco más de qué va la cosa:

Los dejo con el anuncio y la información de la incorporación de Uruguay al evento:

Uruguay ahora es parte del evento mundial de creación de juegos en 48 horas: El Global Game Jam!
Juntate con amigos, conocé más gente en la movida y venite a crear juegos junto a todo el mundo!

¿Qué es el Global Game Jam?
El Global Game Jam (GGJ) es el mayor encuentro mundial de creación de juegos. Dura 48 horas y tiene lugar cada año a finales de enero. El GGJ reúne a miles de entusiastas de los videojuegos, los cuales participan desde sedes repartidas por todo el mundo.

Un encuentro cuyo objetivo es colaborar para crear juegos. Los participantes elaboran diseños de juego y desarrollan rápidamente un prototipo, con la intención de aportar nuevas ideas para ayudar a crecer a la industria. Compartimos un tema y limitaciones comunes. Se pide a los participantes que creen un juego de principio a fin en un tiempo preestablecido (en el GGJ son 48 horas). La brevedad del plazo pretende fomentar el pensamiento creativo para obtener juegos experimentales pequeños pero innovadores.

¿Cúando es?
El fin de semana del 27 al 29 de Enero de 2012

¿Dónde es?
En Montevideo la Universidad ORT estará proporcionando el lugar. Más detalles de la ubicación serán confirmados a la brevedad.
Habrá comida, bebida e internet para los participantes registrados. Se recomienda que lleven sus propios equipos.

¿Cómo me registro?
El registro es sin costo. Habrá que crear un usuario y registrarlo en esta página: http://globalgamejam.org/sites/2012/montevideo-universidad-ort

¿Dónde puedo tener más información?
En el sitio oficial del evento y sus preguntas frecuentes: http://globalgamejam.org/wiki/basic-questions/es
El sitio http://www.UruguayGamer.com estará cubriendo el evento en su web, twitter y Facebook.

Si tienen dudas pueden enviarlas a los foros de UruguayGamer.

Saludos y nos vemos!

» Leer más, comentarios, etc...

Koalite's blog

La importancia de la serialización

Enero 12th, 2012 - [Enlace local]

La serialización es algo bastante aburrido y que, además, en muchas aplicaciones no tiene demasiada importancia. Es algo que damos por hecho, en todo lenguaje que se precie tendremos al menos una forma de serializar información para poder almacenarla o transmitirla.

En .NET existen varias formas de serializar desde las primeras versiones del framework. Seguramente las más conocidas sea la serialización a XML con XmlSerializer o su primo el DataContractSerializer y la serialización binaria con BinaryFormatter. También existen otras alternativas más modernas como el DataContractJsonSerializer.

Sin embargo, hay veces en que no nos queda más remedio que preocuparnos por la serialización. Normalmente, por uno de estos dos motivos:

Necesitamos que la operación de serializar/deserializar sea más rápida.
Necesitamos reducir el tamaño de los datos serializados.

Donde se dan estos requerimientos con mayor frecuencia es en el caso de aplicaciones móviles basadas en .NET Compact Framework.

Por una parte, se ejecutan sobre dispositivos menos potentes por lo que la velocidad de ejecución es menor. Si a eso le unimos que el Compact Framework no permite usar generación de código (ni Reflection.Emit ni CodeDOM), toda la serialización/deserialización se hace por reflection, lo que implica aun una mayor penalización en el rendimiento.

Además, los dispositivos móviles suelen tener menos capacidad de almacenamiento, menos memoria y conexiones con menos ancho de banda, por lo que el tamaño de los datos serializados, ya sea para almacenarlos en memoria flash o para trasmitirlos por la red, importa y mucho.

De hecho, hay ocasiones en que estas limitaciones hacen inviables soluciones propias de otros entornos, como el uso de servicios web (SOAP) o WCF para comunicaciones en tiempo real entre dispositivos con Compact Framework y servidores.

En situaciones como esa, mejorar la capa de serialización puede ser vital. Si unimos una mejora en el rendimiento al serializar/deserializar, con un menor volumen de datos a transmitir, la ganancia final de velocidad puede ser la diferencia entre que la aplicación sea viable o no.

Para estos casos, el mejor protocolo de serialización que se puede encontrar hoy en día es Protocol Buffers, desarrollado por Google y que cuenta con varias implementaciones para .NET.

En el próximo post veremos cómo funciona este protocolo y cómo podemos usarlo fácilmente en nuestras aplicaciones.

Compartir enlace:

No hay posts relacionados.

» Leer más, comentarios, etc...

Najaraba.com: Software libre, metodologías ágiles y más.

Organización ágil

Enero 11th, 2012 - [Enlace local]

¿De qué hablamos cuando nos referimos a una organización ágil? ¿existe eso? En general oigo que es la organización que se adapta a los procesos de creación de producto basados en equipos multidisciplinares que trabajan de manera ágil. Es decir, que con un enfoque bottom-up, creamos la organización ágil. Los equipos con la nueva manera de trabajar son "raros" y acaban demandando a su propia

» Leer más, comentarios, etc...

Bitácora de Javier Gutiérrez Chamorro (Guti) » Programación

10 problemas en proyectos de software

Enero 11th, 2012 - [Enlace local]

Tras leer 10 Problems and Some Antidotes for Software Projects (2,9 Mb. en formato PDF), de Richard E. Fairley y Mary Jane Willshire, que aunque algo antiguo sigue estando muy vigente, me he encontrado con una genial tabla de antídotos a estos 10 problemas en los desarrollos de software, con lo que inevitablemente nos vamos [...]

Artículos relacionados:
Gestión de proyectos efectiva para geeks del web
De Trans Software (D.T.S.) ha muerto. ¡Viva D.T.S.!
Problemas con los permisos

» Leer más, comentarios, etc...

Preparando SCJP

Control del Flujo: Excepciones

Enero 10th, 2012 - [Enlace local]

Excepción

Es un evento excepcional que altera el flujo normal del programa. Cuando esto ocurre decimos que se ha lanzado una excepción.

Una excepción se puede generar:

en la JVM, como respuesta a una condición inesperada (Caso 1).
en el código, lanzadas explícitamente por el programador utilizando la sentencia throw (Caso 2).

Las excepciones del primer caso se llaman no comprobadas (unchecked) y las del segundo comprobadas (checked).

Ejemplo Caso 1: No comprobadas.
Por ejemplo, al intentar acceder a una posición inválida en un array.

public class PruebaOutOfBounds {
    public static void main (String[] args){
        int[] notas = new int[5];
        for (int i = 0; i<=5; i++){
            notas[i] = i*2;
            System.out.println("notas["+i+"]=" + notas[i]);
        }
    }
}

Otras excepciones no comprobadas son: ArithmeticException, ClassCastException, NullPointerException, …
En general son aquellas que descienden de la clase RuntimeException.

Ejemplo Caso 2: Comprobadas.
Cuando lanzamos explícitamente una excepción.

...
 public void reverse() throws Exception{
    if (nombre == null){
       throw new Exception ("El nombre es nulo.\n Lanzamos excepcion al intentar hacer
                             reverse().");
    }
    else
    {
        for (int i = nombre.length()-1; i >=0; i --)
            System.out.println(nombre.charAt(i));
    }
}
...

En general son aquellas que descienden de la clase Exception, excluyendo RuntimeException.

Regla del Manejo o la Declaración
Las excepciones comprobadas que un método pueda lanzar se deben declarar.

Si se produce una excepción comprobada en el código, el método debe:

manejar la excepción utilizando el bloque try-catch-finally
ó declarar la excepción y pasar la responsabilidad de declaración o gestión al método llamante.

Para declarar la excepción se utiliza la sentencia throws.

Manejando Excepciones
El manejo de excepciones en Java se lleva a cabo principalmente mediante las sentencias: try, catch y finally.

try{
.... //Código que puede provocar una excepcion
}
catch (Excepcion1){   //Puede haber 0, 1 o muchos bloques catch.
       //En caso de haber 0 debe existir bloque finally.
....
}
finally{  //Puede haber 0 o 1 bloque finally.
....   //En caso de haber 0 debe existir bloque catch.
}

En el bloque try encerramos el código que puede lanzar una excepción.
En el bloque catch definimos qué excepción y con qué código tratarla.
En el bloque finally escribimos código que siempre se ejecuta se produzca o no la excepción.

Ejemplo:

public class Alumno{
//...
   public static void main (String[] args){
        try{
         Alumno a = new Alumno("Ana", 12, 6);
         System.out.println(a);
         a.reverse();

         Alumno c = new Alumno();
         System.out.println(c);
         c.reverse();

       }
       catch (Exception e) {
           System.out.println("--> Hemos capturado la excepcion!!.");
       }
       finally {
           System.out.println("--> Siempre se ejecuta se produzca o no excepcion.");
       }
  }
}

Restricciones de los bloques try-catch-finally:

Un bloque try debe tener un bloque catch o un bloque finally asociado.
Entre un bloque try y catch no puede escribirse código.
Si hay varios bloques catch las excepciones más específicas deben colocarse antes que las más generales.

Filed under: Estudio, Tema 5

» Leer más, comentarios, etc...

Picando Código

Sass – hojas de estilo sintácticamente impresionantes

Enero 10th, 2012 - [Enlace local]

Sass - style with attitude

El paso siguiente a aprender HAML fue leer sobre Sass: Syntactically Awesome Stylesheets. ¿Qué es Sass? Para mí: CSS como debe ser:

Sass es una extensión de CSS3, agregando reglas anidadas, variables, mixins, herencia de selectores, y más.

Su sintaxis scss es un superconjunto (qué buena palabra) de CSS3 por lo que cualquier hoja de estilo CSS3 es una hoja de estilo válida scss. También soporta una sintaxis anterior basada en la simplicidad de HAML, usando la indentación para definir bloques.

Como HAML, al ver un poco de código nos damos cuenta de qué va la cosa. Este es el código que escribimos con Sass:

// Variables
$verde: #84c225;
$verde_o: #4A662F;
$verde_h: #AABF56;
 
a {
  color: $verde;
  text-decoration: none;
  // Referencias al padre
  &amp;:hover { color: $verde_h; }
  &amp;:visited { color: $verde_o; }
  &amp;:visited { color: $verde_h; }
}
 
// Anidado
#header{
  width: 980px;
  position: relative;
  .logo{
    width: 235px;
    height: 80px;
    background: url(/wp-content/themes/picandocodigo-4.0/images/picandocodigo.png) no-repeat;
    margin: 20px;
    float: left;
  }
}
 
// Mixins
@mixin float_right($margin){
  float: right;
  margin: $margin;
}
 
.image_right{
  @include float_right(15px);
}
 
.text_right{
  @include float_right(10px);
}
 
//Este comentario no va a aparecer en el CSS
/* Este comentario va a aparecer en el CSS */

Como HAML, podemos usarlo separado desde línea de comando y crear el css a partir del archivo scss, o integrado en un framework web como Rails o Sinatra. Para “compilar” a css lo que escribimos arriba, ejecutamos:

[fernando@hoth]$ sass --watch test.scss

Y el archivo css generado se ve así:

a {
  color: #84c225;
  text-decoration: none; }
  a:hover {
    color: #aabf56; }
  a:visited {
    color: #4a662f; }
  a:visited {
    color: #aabf56; }
 
#header {
  width: 980px;
  position: relative; }
  #header .logo {
    width: 235px;
    height: 80px;
    background: url(/wp-content/themes/picandocodigo-4.0/images/picandocodigo.png) no-repeat;
    margin: 20px;
    float: left; }
 
.image_right {
  float: right;
  margin: 15px; }
 
.text_right {
  float: right;
  margin: 10px; }
 
/* Este comentario va a aparecer en el CSS */

Mi primeros pasos los dí tras aprender HAML migrando los CSS de mi sitio personal a Sass. Como pueden ver el application.css.scss no es un archivo muy grande. Noté las ventajas de migrar a este lenguaje, pero fue un trabajo bastante simple y creo que no llegué a aprovechar todas las ventajas de Scss.

Sin embargo, en estos días tuve que maquetar un sitio desde cero para Ruby On Rails, y arranqué usando HAML y Sass desde un principio. Gran casualidad que el cliente pidiera específicamente que usara estas dos tecnologías, una suerte que había estado aprendiendo sobre ellas (nunca se está demasiado preparado para un trabajo). Ahí fue que descubrí las verdaderas ventajas de Scss.

No creo que pueda volver a escribir una hoja de estilo sin usar Sass. Facilita y dinamiza mucho el trabajo. Si vas a usar un valor más de una vez, creas una variable. Si el mismo formato se aplica a varios lugares distintos, creas un mixin. El anidado de propiedades permite tener un archivo mucho mas lógico (por lo menos del punto de vista de un programador) y ordenado. El hecho de poder separar los estilos en varios archivos y que Sass luego los una en un CSS solo, permite delegar y encapsular a granel sin sacrificar performance teniendo varios CSS que importar en nuestro sitio.

Sass aplica prácticas de la programación como encapsulación y DRY (no te repitas), y resulta muy ágil. Si tuviera un sello de “recomendado por picandocodigo”, Sass lo gana. Les recomiendo darse una vuelta por el tutorial y sigan con la documentación de referencia. Y empiecen a escribir sus hojas de estilo de manera impresionante con Sass.

» Leer más, comentarios, etc...

Picando Código

Cuento de terror: La muerte de la cafetera

Enero 10th, 2012 - [Enlace local]

Hace tiempo que el café no es protagonista de uno de mis posts. ¡Es hora de cambiar esto!
Buen momento para recordar uno de los posts más memorables sobre café en el blog: Ocurrencias de la oficina: {Cafetera y yo}

Nuestra cafetera en la oficina

La siguiente es una charla entre Bruno (@brAzzi64) y yo en horario de trabajo. Corregí un poco el texto para gusto del lector. Sabemos que generalmente se abrevian algunas palabras y se eluden algunas reglas en una conversación de chat, así que arreglé un poco ese aspecto. Gracias Bruno por dejarme compartir nuestra charla por acá:

@picandocodigo: novedades?
@brAzzi64: sep, está todo listo y prendida, pero el agua no calienta :-/
@brAzzi64: me suena que murió…
@picandocodigo: NOOOOOO!
@brAzzi64: hay que avisarle a pol, grrr
@picandocodigo: NOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO!!!!!!!!!!!!!!!!
@brAzzi64: jajajjajajajja
@picandocodigo: http://nooooooooooooooo.com/
@brAzzi64: una cafetera para 200… está cruel
@brAzzi64: hdp, jajajaja
@brAzzi64: xD
@brAzzi64: genial
@picandocodigo: posta?
@brAzzi64: seeeeh, no séee no tira caféeee
@brAzzi64: y no calienta el aguaaaa
@brAzzi64: está ahí, inmutable
@brAzzi64: es muy triste
@picandocodigo: NOOOOOOOOOOOOOOOOOOOOOOOO!!!!
@picandocodigo: yyy… probaste respiración boca a boca?
@brAzzi64: tsss. temía electrocutarme, pero metí el dedo en el agua…
@brAzzi64: y estaba dead cold -_-
@picandocodigo: no, no, no, no puede ser! esto es gravísimo!
@picandocodigo: perdón por la pregunta obvia, pero, la luz prende?
@picandocodigo: probaste apagarla y prenderla? capaz que tiene un sistema operativo hecho por Microsoft
@picandocodigo: qué pasó?
@picandocodigo: por que no escribís más?
@brAzzi64: jajajja
@brAzzi64: perdón. la luz prende!
@brAzzi64: el sistema operativo es monolítico, apenas un firmware
@picandocodigo: ah, temía lo peor…
@brAzzi64: tssss

@brAzzi64: habría q reinstalarla, en ese caso
@picandocodigo: mmmh, reinstalarla? y si la flasheamos y le metemos algún firmware open source?
@picandocodigo: http://www.emacswiki.org/emacs/CoffeeMode
Hay que fijarse si ese modelo podría responder al Hyper Text Coffee Pot Control Protocol (HTCPCP)
@picandocodigo: y mandamos a hacer café con Emacs
@brAzzi64: yo creo que sí. y si no lo soporta como está, solo sería necesario reescribir algunos módulos del kernel…
@brAzzi64: que teniendo el hardware posta, es algo teóricamente posible
@picandocodigo: ah bien
@picandocodigo: ahora, sigue muerta… no?
@picandocodigo: porque ya me quedé sin ideas y necesito café…
@brAzzi64: jaja, no volví a fijarme, pero por los pasillos se escucha el murmullo de la misma cosa…
@brAzzi64: “la cafetera dejó de funcionar”
@brAzzi64: la gente busca alternativas
@picandocodigo: en la cantina de Antel venden café?
@brAzzi64: jaajaj… en charly, capaz?

@picandocodigo: debe ser peor que la máquina dispensadora de café el café de Charly
@brAzzi64:

@picandocodigo: qué hacemos?
@brAzzi64: jaja, no sé xD alguna aleación entre los cafeces de las distintas máquinas, sería mágicamente tomable?
@picandocodigo: no sé :’-(
@brAzzi64: bujú. lo suplimos con cerveza hoy después del laburo? ja ja ja.
@picandocodigo: y bué..
@picandocodigo: si no queda otra…
@picandocodigo:

La cafetera no ha sido arreglada al momento de escribir este post. Pero por suerte, encontramos que en otro piso de la empresa había otra cafetera que había permanecido desconocida para nosotros. Así que piso diferente, pero volvimos a tomar café

» Leer más, comentarios, etc...

Variable not found

Establecer el foco automáticamente, versión declarativa

Enero 10th, 2012 - [Enlace local]

Hace poco escribía un post en el que mostraba cómo se podía conseguir establecer el foco inicialmente en un control de edición, algo que era posible con Webforms pero no directamente con las herramientas que ASP.NET MVC trae de fábrica.

La solución propuesta consistía en introducir en la vista código de script para desplazar el foco hasta el control indicado mediante una llamada al helper Html.SetFocusTo(), que implementábamos en el mismo post, aunque hay otras formas para conseguirlo.

Unos días después, un amigo de Variable not found preguntaba en un comentario si no había una forma de conseguir lo mismo utilizando una sintaxis más declarativa, al estilo de la especificación de metadatos o validadores basados en atributos o data annotations.

En primer lugar he de decir que no creo que sea muy conveniente hacerlo, puesto en casi todos los escenarios posicionar el foco en un elemento es pura presentación, no suele haber decisiones de negocio tras ello, y por tanto no es algo que debamos sacar de la Vista. Pero bueno, independientemente de eso, vamos a ver cómo podríamos conseguirlo.

Una forma relativamente sencilla de hacerlo sería utilizando atributos de metadatos personalizados de forma muy similar al ejemplo que vimos también en un post anterior.

Lo primero que necesitamos es definir un atributo que implemente IMetadataAware, lo que indica que incluye información sobre metadatos, y aprovechar el método OnMetadataCreated() para introducir en la colección de metadatos adicionales una señal que permita más adelante detectar la propiedad a “enfocar”:

public class FocusedAttribute : Attribute, IMetadataAware
{
    public const string MetadataKey = "Focused";
    public void OnMetadataCreated(ModelMetadata metadata)
    {
        metadata.AdditionalValues[MetadataKey] = true;
    }
}

De esta forma, para activar el foco inicialmente sobre el editor de una propiedad concreta, simplemente deberíamos marcarla con el atributo [Focused], como se muestra en el código siguiente:

public class Friend
{
    [Focused]
    public string Name { get; set; }
 
    public string Email { get; set; }
    public string Phone { get; set; }
    public string Fax { get; set; }
 
}

Una vez finalizados los preparativos, tenemos que ver cómo implementarlo en la vista. Lo más sencillo en este caso sería crear el helper Html.Autofocus(), que será encargado de localizar la propiedad con el atributo [Focused] y generar sobre la vista el script que mueva el foco a la misma:

public static class HtmlExtensions
{
    public static MvcHtmlString Autofocus(this HtmlHelper html)
    {
        var template = html.ViewData.TemplateInfo;
        var focusedProperty = 
             (from property in html.ViewData.ModelMetadata.Properties
              where property.AdditionalValues.Any(
                     a => a.Key == FocusedAttribute.MetadataKey && (bool) a.Value)
              select template.GetFullHtmlFieldId(property.PropertyName)
             ).FirstOrDefault();
        if (focusedProperty != null)
        {
            return createAutofocusScript(focusedProperty);
        }
 
        return null;
    }
 
    private static MvcHtmlString createAutofocusScript(string focusedProperty)
    {
        string script = "<script type='text/javascript'>" +
                        "$(function() { $('#" + focusedProperty + "').focus(); });" +
                        "</script>";
        return MvcHtmlString.Create(script);
    }
}

Por último, basta con introducir en la vista la siguiente llamada. O mejor aún, si queremos que esta funcionalidad esté activa en todas las vistas, podemos añadirla al final del Layout que estemos empleando para ellas:

@Html.Autofocus()

Hay que tener en cuenta que nada impide que el atributo Focused sea empleado en más de una propiedad, en cuyo caso el foco se establecerá en la primera ocurrencia localizada. Esto se podría evitar llevando el atributo a nivel de clase e indicando como parámetro el valor de la propiedad (algo así como [DefaultProperty("Name")] sobre la propia entidad). En el proyecto de demostración podréis encontrar también esta implementación.

Descargar proyecto de demostración (VS2010+MVC 3) desde Skydrive.

Publicado en Variable not found.

» Leer más, comentarios, etc...

Picando Código

Resumen del 2011 en Multiverseros

Enero 9th, 2012 - [Enlace local]

El sitio amigo Multiverseros hizo un repaso de lo que fue el año 2011 reviviendo 5 notas de cada uno de los autores.

Por si no han leído artículos anteriores sobre Multiverseros en el blog, les comento: Es un lugar donde además de publicar artículos del tema, nos juntamos un grupo particular de personas a conversar sobre cosas que nos gustan: cómics, libros, cine, televisión, ciencia ficción, fantasía, videojuegos, etc.

Multiverseros

Los invito a unirse es un grupo abierto y todos son bienvenidos. O pueden leer el post al respecto que publiqué en su momento sobre Multiverseros para conocer más.

RinTinTin - Repaso 2011

RinTinTin, además de aportar con sus propuestas al rico contenido de lectura que provee el sitio, es el sysadmin y desarrollador. Eligió los siguientes momentos del calendario que se fue para recordar el año creando una nota sin tener que limpiarse la arena de los pies:

Batman – The Long Halloween: Análisis de una obra que el autor define como de las mejores escritas sobre Batman. Historia de detectives con guión maravilloso acompañado por un dibujo aún mejor. Un artículo que le pelea pelo a pelo al Carrito Alegórico del Chaná.
Load”" – Sir Fred: Por acá les comenté sobre la columna dedicada a los juegos de ZX Spectrum, RTT también eligió el artículo sobre Sir Fred para Spectrum, esta aventura de caballeros andantes, princesas enjauladas, pirañas hambrientas y oportunas patas de pollo.
10 momentos clave en la vida de Green Lantern: Habiendo leído Marvel toda la vida, apenas conocía algo de la existencia de este personaje. Multiverseros fue responsable de que me volviera seguidor de la serie y este artículo de RTT fue uno de los que me llevó a descubrir más al respecto:
Un gran personaje se merecía una gran película, no fue el caso de Green Lantern, pero este recorrido por sus mejores momentos del cómic intentó homenajear a Hal de la mejor manera posible
Inútiles – Quiz #2: Spider-FAQs: Diversión en forma de quizes para el niño que llevamos dentro, amante de las “multiple choices”. Trivia centrada en la etapa más reciente de Spidey, inmediatamente posterior al controversial (y lamentable) “mephistazo”. Se hicieron un par de “quizes” más en el año sobre Swamp Thing y Los Eternos.
Todo acerca de la nueva Justice League: Con el nacimiento del Nuevo Universo DC, RTT mantuvo a los lectores informados con los datos que fueron apereciendo sobre cada personaje. Con informes bastante periódicos sobre los regresos, reinterpretaciones y actualizaciones de cada héroe. El primer informe se trató nada más y nada menos que de la única e inigualable Liga de la Justicia de América.

Destaco además la incorporación de un sistema de dados en el foro. Mediante unos cómodos botones en el menú de herramientas para postear, se pueden hacer tiradas de dados con resultados al azar. Pueden ver una generala que se armó en su momento a nivel del foro para probar el nuevo sistema.

Nick Constantine - Repaso 2011

Nick Constantine el encargado de la ludopatía congénita en Multiverseros, referente en juegos de rol, pero también adicto a la fantasía, ciencia ficción, cine… bueno, igual que los otros 3… Los 5 artículos elegidos por Nick:

Ludopatía Congénita – 15 preguntas sobre RPGs: La guía de introducción al juego de rol para ignorantes. Si no tienen ni idea de cómo va la cosa con los juegos de rol, este es un buen punto de arranque. El artículo según Nick: no sólo cosechó respuestas interesantísimas, sino que me hizo sentir esperanza por mi hobby predilecto, los hoy agonizantes-mañana no tanto juegos de rol.
Entrevista a Cam Banks: Un hito personal del 2011, una entrevista exclusiva de Multiverseros al diseñador encargado del desarrollo de los juegos de rol de Margaret Weis Productions.
Una vez más, con sentimiento: Si hay algo que se aprende a muy poco de conocer a Nick, es su afición por las series televisivas de Buffy y Angel. Era de esperarse que no fuera a dejar afuera este artículo donde comenta algunos de los mejores momentos de la serie.
Multiminecrafteando: Una propuesta que nos cambió a muchos. Uno de los juegos que más jugué este año fue Minecraft, y esto gracias a la iniciativa de Nick de arrancar un servidor en el sitio. La nota repasa un poco los inicios de esta aventura virtual, a la que respondí en este blog con Minecraft. Al igual que él, espero retomar pronto esta experiencia en forma regular. Si alguien sabe dónde podemos alojar un servidor gratis/barato, se escuchan recomendaciones
Malaz: El Libro de los Caídos: Un talento que tiene Nick es de “vender” algo. No al estilo vendedor de humo, sino que expresa su pasión con tanta behemencia hacia sus afinidades, que te despierta la necesidad de conocer lo que está recomendando. Así lo hace con Malaz: Mucho hablamos de “A Song of Ice and Fire”, pero si le preguntan a este humilde redactor por la serie de fantasía que define a este género en su expresión moderna, sin dudarlo, por magnitud, resonancia épica y calidad general de la obra, remarco a la serie del antropólogo canadiense. Malaz es una obra inmensa, épica, profunda, críptica, frustrante e hipnotizante.

Si tuviera que cambiar algo, agregaría también la nota sobre Hellblazer, que me orientó un poco en mi entrada al personaje. Así también la recomendación con autoridad del grupo de superhéroes The Authority que recién arranqué a conocer pero se viene perfilando como un muy buen cómic.

El Hijo de Chuck Norris - Repaso 2011

Hijo de Chuck Norris (Chuck Jr. para algunos foreros) compartió las siguientes cinco notas del 2011 que rescato del barro de mediocridad en el que retozo cual cerdito feliz. Intentando no pecar de chupamedias, puedo afirmar que las notas publicadas hasta el momento en Multiverseros son de una muy alta calidad, lejos de la mediocridad a la que alude humorísticamente Chuck Jr. en su descripción:

Planeta Clarín: Un Juego de Trolos: Parte de la columna Planeta Clarín donde se publican noticias humorísticas y falsas con el toque personal del autor: “Gay of Thrones: Un Juego de Trolos”, en donde Guillermo Francella y Emilio Disi interpretaban a Lord Eduardo Estareche y el rey Roberto Baratelli, respectivamente.
Reseña: WildCats 3.0: Otra de esas notas que lo convencen a uno de empezar a leer un determinado cómic. En este caso otro supergrupo en un volumen que hizo al autor sentir desbordado por una historia adulta en el mejor de los sentidos, en donde los “héroes” buscaban lo mejor para la humanidad desde la dirección de una compañía y gracias a la creación de una pila muy particular.
Entrevista: Rob Guillory: Otra entrevista exclusiva de Multiverseros. En este caso se trata del dibujante de “Chew”: uno de esos cómics de Image que logró establecerse (y ganar importantes premios de la industria) gracias a un guión muy original y a un personalísimo dibujo.
Editorial: Salven una tierra para mí: ¿Qué pasa cuando tu empresa de cómics favorita decide hacer borrón y cuenta nueva en el universo con el que tan familiarizado estás? Esto fue lo que le pasó a Hijo de Chuck Norris con “The new 52″ de DC. Su respuesta al evento surge en forma de editorial pidiendo una sola cosa, que guarden una tierra para aquellos como él: treintañero que creció con el Universo Post-Crisis y tiene un montón de amigos ahí, que corren el riesgo de desaparecer.
Informe: The Corps: Una nota imperdible para adultos-con-mentalidad-de-niño-y-salario-de-adulto que todavía coleccionamos “macaquitos”, mejor conocidos como “figuras de acción”. Los Corps son una línea de juguetes parecida a los G.I. Joe pero mucho más barata. Chuck Jr nos cuenta cómo conoció y comenzó su colección en una saga que había comenzado ya en su blog un tiempo atrás.

Otros recuerdos del autor que agregaría son: Su reseña de The Nightly News, un cómic sumamente interesante que procedí a adquirir tras leer su opinión al respecto. También el cómic corriendo atrás del cine, donde se analiza cómo un cómic cambia cuando nos encontramos ante el inminente estreno de una película basada en él.

El Penitente - Repaso 2011

El Penitente encargado de la columna del pito, definió las siguientes cinco notas como “lo menos peor” de todo el contenido volcado por su persona en tan honroso portal como lo es Multiverseros. Como comprobarán, un fiel fanático de los cómics:

El Pito de Lázaro – La Ruta del Cómic: Un viaje en el tiempo y espacio a los 90′s por las calles del barrio Cordón en Montevideo y sus librerías de saldo, en la odisea de comprar cómics.
Tomo Uno – Asterios Polyp: La columna que busca reseñar ediciones destacadas por su contenido pero también por su forma. En esta ocasión Penitente se encargó de contarnos acerca de “Asterios Polyp”, una obra de David Mazzuccheli que define como “una de las grandes novelas gráficas de la última década”.
La Viñeta de la Semana – Thor: The Mighty Avenger: Aprovechando el estreno de la película de Thor, Penitente se hizo cargo de reseñar uno de los títulos del personaje: La serie de Langridge y Samnee, con su tono totalmente distinto a lo que es la media del cómic superheroico actual, fue un alivio para aquellos que estamos cansados de tanta solemnidad y personajes sufridos. Además de Thor, recibió el mismo tratamiento el Capitán América con un repaso de sus mejores momentos y el ya mencionado artículo de Green Lantern.
El Pito de Lázaro – Entrevista a Patrick Meaney: Como fundador de la Iglesia Morrisoneana en Uruguay, se dió el lujo de entrevistar a Patrick Meaney, otro entusiasta de la obra de Grant Morrison. Autor del libro “Our Sentence Is Up” y los documentales “Grant Morrison: Talking With Gods” y “Warren Ellis: Captured Ghosts”. Contestó preguntas de sus obras, guionistas y más.
Recordando a Barreto: El 15 de diciembre de 2011 falleció Eduardo Barreto, uno de los historietistas más importantes del Uruguay. Fue emocionante ver la repercusión internacional que tuvo este triste evento y la cantidad de menciones que tuvo en los grandes medios del cómic, viendo que mucha gente -tanto creadores como lectores- lo apreciaba mucho como artista, pero más como persona. Este artículo muestra algunas de estas repercusiones.

Como comenté en el foro, además de haber conocido muchos títulos interesantes, le debo a Penitente el haberme presentado a Irredeemable. Me volví seguidor de esta serie gracias a su recomendación. También se podrían agregar El top 20 de cómics de los 2000 y Cómics Nacionales de la columna El Pito de Lázaro.

También habría que agregar la destacada participación de Arqui con su columna El Arquiólogo. En ella investiga profundamente a sucesos y personajes como El Increíble Hulk o el Sorprendente Hombre Araña. No se puede quedar afuera Robotman con sus publicaciones esporádicas como las que nos hizo conocer a Doom Patrol (parte 1, parte 2) o cómo es La Cosa (parte 1, parte 2). Varios usuarios más aportan con mucha información, reseñas y opiniones.

Se generó una comunidad muy buena con intercambios, amigos y discusiones demasiado interesantes y divertidas. Incluso se coordinaron durante el año dos reuniones “oficiales” del foro, viéndonos las caras los participantes y llevando la charla a una mesa compartiendo unas muzarellas y cervezas (y bebidas cola también). Esperemos que el 2012 traiga más reuniones presenciales.

En fin, con este post comparto con mis lectores parte de la experiencia que ha sido unirme a Multiverseros, y espero poder reclutar algún miembro más para unirse a nuestra aventura en el Multiverso. Aprovecho para agradecer a los Multiverseros por el excelente ambiente generado en multiverseros.com. Los espero por ahí también…

» Leer más, comentarios, etc...

Koalite's blog

Resolución de tipos genéricos con Castle Windsor

Enero 9th, 2012 - [Enlace local]

Llevo utilizando Castle Windsor como contenedor de inversión de control durante bastante tiempo, pero hasta hace poco no me había fijado en la forma en que resuelve tipos genéricos.

Cuando registramos un tipo genérico abierto, Castle es capaz de resolverlo usando los parámetros de tipo que sea necesario. Por ejemplo, si tenemos un repositorio genérico de esos que no me gustan, podemos hacer algo así:

public class Customer {}
public class Product {}

public interface IRepository {}
public class Repository {}

[TestFixture]
public class ResolveTest
{
    [Test]
    public void Resolve_Generic_Open_Type()
    {
        var container = new WindsorContainer();
        container.Register(Component.For(typeof(IRepository<>))
                                    .ImplementedBy(typeof(Repository<>));

        Assert.That(container.Resolve>(),
                    Is.TypeOf&gt));
    }
}

Esto es algo bastante normal en cualquier contenedor de inversión de control. Lo que no sabía es que si se ha registrado una implementación cerrada del interface genérico, tiene prioridad sobre la implementación abierta.

Siguiendo con el ejemplo anterior, si tuviéramos una implementación especial para IRepository, quedaría:

public class Customer {}
public class Product {}

public interface IRepository {}
public class Repository {}
public class CustomerRepository : IRepository {}

[TestFixture]
public class ResolveTest
{
    [Test]
    public void Resolve_Generic_Closed_Type()
    {
        var container = new WindsorContainer();
        container.Register(Component.For(typeof(IRepository<>))
                                    .ImplementedBy(typeof(Repository<>));
        container.Register(Component.For(typeof(IRepository))
                                    .ImplementedBy(typeof(CustomerRepository));

        Assert.That(container.Resolve>(),
                    Is.TypeOf>));

        Assert.That(container.Resolve>(),
                    Is.TypeOf));
    }
}

En este caso, Castle podría resolver el primer componente registrado (que además es el componente por defecto, debido al ordern de registro), pero es lo bastante listo como para darse cuenta de que hay un componente “mejor” registrado y usarlo.

Esta técnica nos permite configurar de forma fácil implementaciones genéricas de componentes y especilizarlas sólo para aquellos componentes que sea necesario.

Compartir enlace:

Posts relacionados:

» Leer más, comentarios, etc...

Meta-Info

¿Que es?

Sponsors

¿Cómo puede el servidor enviar eventos al cliente de forma asíncrona?

SignalR, conceptualmente

Implementación de servicios con SignalR

Instalación de SignalR

Un sistema de control de versiones tiene que proporcionarte:

Ahora si.

Habiendo dejado claro que es el control de versiones…

Instalación

Linux

Mac Os X

Windows

Configuración Inicial

Comandos básicos para empezar

Crear un repositorio nuevo

Hacer checkout a un repositorio

add y commit

push, enviar cambios a repositorio remoto

Ramas o branches

Pull , actualizando

Me cagu#$%”% en todo!! Revirtiendo cambios

Eso fue lo básico, hoy viene lo bueno!!

.Net

Asp.net

Azure / Cloud

Data access

Html/Css/Javascript

Visual Studio/Complementos

Otros

¿Cómo de eficiente es?

¿Cómo se usa?

¿Por qué es tan eficiente?