ALT.NET Hispano

Introducción a Silverlight Webcast

Mon, 21 May 2012 17:20:12 +0000

Hoy me toco dar una introducción a Silverlight en forma de Webcast.

Les dejo el material aquí.

Gracias a todos los que participaron!

Filed under: Client App Dev, Silverlight, Webcast Tagged: software-development

Mi ponencia sobre BDD para Campus Party Colombia 2012

Wed, 02 May 2012 11:51:47 +0000

Me siento muy honrado por haber sido invitado por los organizadores de Campus Party para Colombia, a presentar una ponencia para participar con una charla en la edición de este año de tan importante evento, pueden visitar su página http://www.campus-party.com.co/. El título de mi ponencia es “Eliminando la brecha entre clientes y desarrolladores mediante BDD para especificar e implementar mejor software”, lo cual ya dice mucho, pero a continuación les dejo la descripción de lo qué trataría esta charla, en caso de ser seleccionado finalmente.

Muchos, si no la mayoría, de los problemas o fracasos en proyectos de desarrollo de software se debe a que clientes y equipos de implementación de aplicaciones sencillamente no se entienden porque ven el mundo de manera muy distinta, hay una brecha entre ambas partes, dificultando materializar los requerimientos en software que realmente aporta valor para el negocio.

La metodología ágil BDD (Behavior-Driven Development) tiene precisamente el objetivo de lograr que ambas partes, cliente y equipo de desarrollo, en un proyecto se comuniquen de manera efectiva, ayudando a los primeros a especificar de manera sencilla y clara sus requerimientos, y a los segundos a entregar software que realmente cumple esas expectativas.

Tomando muchas de las buenas prácticas de desarrollo ágil de software y Lean, BDD fomenta y facilita la colaboración entre los miembros de diferentes roles, así como la integración de todas las etapas del proceso de desarrollo de software de tal manera que, aun escribiendo código fuente, nunca se pierda la referencia y conexión con las especificaciones del cliente, asegurando que el producto que se entrega coincide con ellas, es de calidad y, como un beneficio adicional, queda soportado por pruebas automatizadas.

Esta sesión mostrará, tanto a gente de negocios (gerentes de proyectos y analistas de negocios), como a gente técnica (especialistas en QA, arquitectos y desarrolladores de software), como aplicar BDD para obtener todos sus beneficios a la vez que hacen más felices a sus clientes con un proceso más eficiente y mejor producto.

Aun no es un hecho que estaré allí como presentador charlando sobre este tema, hay que esperar a que se realice el proceso de selección, pero pueden apoyarme votando por mi ponencia en la siguiente página:

http://www.csi.campus-party.org/story.php?title=eliminando-la-brecha-entre-clientes-y-desarrolladores-mediante-bdd-para-especificar-e-implementar-mejor-software-1

Allí podrán votar presionando el botón con forma de triángulo que señala hacia arriba y aparece encima del número de votos hasta el momento, tal como se señala con la flecha roja en la siguiente imagen. Para esto es necesario estar registrado, de modo que al presionar el botón de votación los conducirá a una página en la que pueden ingresar usuario y contraseña si ya lo tienen o donde podrán encontrar un enlace a la página de registro. De antemano, les doy muchas gracias por su respaldo.

Actualización:

El comentario de alguien no identificado me hace caer en cuenta que el procedimiento anterior es tan solo la primera parte del registro para poder votar una ponencia, pues hasta ahí se queda registrado en el portal de Campus Party pero luego hay que activar el registro para CSI, que es el sitio especializado en manejar las ponencias. Entonces, una vez se ha completado el registro inicial, aparecerá una página que contiene la siguiente imagen, ahí hay que dar clic en el enlace que dice “Activa tu cuenta en CSI” (señalado con una flecha roja en la imagen) y en la siguiente página se podra activar. Después de esto se podrá regresar a la página de la ponencia y votar como se indicó antes.

Introducción a jQuery (Parte 12)

Mario Cornejo — Fri, 27 Apr 2012 16:57:00 +0000

En esta ocasión no grabe un screencast, ya que solo voy a reacomodar código en base a lo explicado en los pasados posts. Creo que será más fácil apreciar esos cambios si lo muestro como estaba el código y como fue cambiando. Así pueden ver los detalles sin tener que esperar a que lo escriba.

En la parte 11 de la serie el archivo tasks.js iba de la siguiente forma:

$( function () {
    $( 'input[type="checkbox"]' ).click( function ( event ) {
        $( this ).parent().toggleClass( "done", this.checked );
        event.stopPropagation();
    } );

//    $( "li" ).click( function () {
//        $( this ).toggleClass( "highlight" );
//    } );

    $( "ol" ).on( "click", "li",  function () {
        $( this ).toggleClass( "highlight" );
    } );

    $( "a.delete" ).click( function ( event ) {
        if ( confirm( '¿Borrar la tarea?' ) ) {
            $li = $( this ).parent();
            $li.slideUp( function () { $li.remove(); } );
        }
        event.stopPropagation();
    } );

    $( "button#add" ).click( function () {
        var $input = $( "input#task" );
        var value = $input.val();

        var $ol = $( "ol" );

        var templateHtml = $( "div.template" ).html();                

        $ol.append( templateHtml.replace( "{{task}}", value ) );
    } );

} );

Expliqué el uso de “on” en lugar de usar “click” directamente en los eventos, así que lo primero que haré es cambiar los “clicks” por “on” y borrar los comentarios del código.

$( function () {
    $( "ol" ).on( "click", 'input[type="checkbox"]' ,  function ( event ) {    
        $( this ).parent().toggleClass( "done", this.checked );
        event.stopPropagation();
    } );

    $( "ol" ).on( "click", "li",  function () {
        $( this ).toggleClass( "highlight" );
    } );

    $( "ol" ).on( "click", "a.delete", function ( event ) {
        if ( confirm( '¿Borrar la tarea?' ) ) {
            $li = $( this ).parent();
            $li.slideUp( function () { $li.remove(); } );
        }
        event.stopPropagation();
    } );

    $( "button#add" ).click( function () {
        var $input = $( "input#task" );
        var value = $input.val();
        var $ol = $( "ol" );
        var templateHtml = $( "div.template" ).html();
        $ol.append( templateHtml.replace( "{{task}}", value ) );
    } );

} );

Aquí se puede ver que se esta usando varias veces el selector $( “ol” ) lo cual puede guardarse en una variable y no tener que hacer la consulta al DOM cada vez que lo necesitamos.

$( function () {
    var $ol = $( "ol" );
    
    $ol.on( "click", 'input[type="checkbox"]' ,  function ( event ) {    
        $( this ).parent().toggleClass( "done", this.checked );
        event.stopPropagation();
    } );

    $ol.on( "click", "li",  function () {
        $( this ).toggleClass( "highlight" );
    } );

    $ol.on( "click", "a.delete", function ( event ) {
        if ( confirm( '¿Borrar la tarea?' ) ) {
            $li = $( this ).parent();
            $li.slideUp( function () { $li.remove(); } );
        }
        event.stopPropagation();
    } );

    $( "button#add" ).click( function () {
        var $input = $( "input#task" );
        var value = $input.val();       
        var templateHtml = $( "div.template" ).html();
        $ol.append( templateHtml.replace( "{{task}}", value ) );
    } );
} );

Por último voy a dejar de usar funciones anónimas y especificar el ligado de los eventos en un solo lugar. Además guardo en una variable la caja de texto para agregar tareas y así no tener que buscarla cada que se necesite agregar una tarea:

$( function () {
    var $ol = $( "ol" ),
        $newTask = $( "input#task" );

    function checkbox_click ( event ) {
        $( this ).parent().toggleClass( "done", this.checked );
        event.stopPropagation();
    }     
   
    function hightlight() {
        $( this ).toggleClass( "highlight" );
    } 
    
    function deleteItem( event ) {
        if ( confirm( '¿Borrar la tarea?' ) ) {
            $li = $( this ).parent();
            $li.slideUp( function () { $li.remove(); } );
        }
        event.stopPropagation();
    }
    
    function addItem () {                
        var templateHtml = $( "div.template" ).html();
        $ol.append( templateHtml.replace( "{{task}}", $newTask.val() ) );
    }

    $ol.on( "click", 'input[type="checkbox"]', checkbox_click );
    $ol.on( "click", "li",  hightlight);
    $ol.on( "click", "a.delete", deleteItem);
    $( "button#add" ).click( addItem );
} );

Con esto, en mi opinión, el código se ve más claro.

Links Relacionados:

Introducción a jQuery (Parte 11)

Mario H. Cornejo

Conferencia sobre estandares: HTML5 y Javacript

Thu, 26 Apr 2012 13:38:25 +0000

Recientemente estuve en la Universidad Abierta Interamericana en Rosario dando un conferencia sobre Estandares Web

Pueden descargar el material de aquí.

Gracias a todos los que estuvieron presentes, y al MUG por invitarme al evento!

Filed under: ASP.NET, Conferences Tagged: software-development

Videos sobre Windows 8 y HTML5

Thu, 26 Apr 2012 11:18:53 +0000

Estoy muy contento por que se han publicado en Channel 9 una serie de el videos sobre desarrollo en Windows8 y HTML5 que hemos filmado con mi amigo Miguel Angel Saez.

La serie incluye los siguientes videos:

Espero que les gusten!

Diseño estilo Metro

Construyendo una UI estilo Metro en Windows 8

Construyendo Metro Style Apps con HTML y JavaScript

Filed under: ASP.NET, Client App Dev Tagged: software-development

Introducción a jQuery (Parte 11)

Mario Cornejo — Mon, 23 Apr 2012 13:51:00 +0000

Esta vez hago uso de una plantilla para agregar nuevas tareas a la lista y empiezo a utilizar el método “on” para ligar eventos.

Links Relacionados:
Introducción a jQuery (parte 10)
Introducción a jQuery (parte 12)

Iniciando tijuana.js

Mario Cornejo — Mon, 23 Apr 2012 12:29:00 +0000

Recientemente el uso de JavaScript ha cobrado importancia al momento de realizar casi cualquier aplicación web. Ahora hay muchas librerías y/o Frameworks desarrollados en JavaScript y empieza a no ser extraño usarlo fuera del browser.

En el pasado Super Happy Dev House Tijuana se reunieron varios desarrolladores a trabajar en diversos proyectos. Cada uno de estos proyectos estaban desarrollados en diferentes lenguajes/Frameworks (tales como RubyOnRails, PHP, ASP.NET, etcétera). Se contó con la asistencia de varias de las comunidades de la región, como la comunidad de Ruby Tijuana, Tijuana .Net, Grupo de usuarios GNU/Linux, Comunidad de PHPeros en Tijuana y Google Developer Group.

A pesar de ser desarrolladores de diversas tecnologías algo que tienen estas comunidades en común es JavaScript. De ahí la idea de iniciar un grupo donde podemos reunirnos para hablar de lo que todos los desarrolladores web tenemos en común y que cada vez tiene mayor impacto en el desarrollo de las aplicaciones.

He publicado el sitio tijuanajs.org donde espero sea un punto de encuentro para todas aquellas personas, de la región, que les guste hablar de JavaScript.

Ingresen al grupo y espero verlos en las reuniones.

Mario H. Cornejo

Introducción a jQuery (Parte 10)

Mario Cornejo — Mon, 16 Apr 2012 13:31:00 +0000

En esta ocasión muestro el uso de callback en el método slideUp y el evento ready del documento

Links Relacionados:
Introducción a jQuery (Parte 9)
Introducción a jQuery (Parte 11)

Introducción a jQuery (Parte 9)

Mario Cornejo — Thu, 12 Apr 2012 22:02:00 +0000

Decimo video de la serie, esta vez aproveché los 5 min para realizar una pequeña refactorización del código.

Links Relacionados:
Introducción a jQuery (Parte 8)
Introducción a jQuery (Parte 10)

Introducción a jQuery (Parte 8)

Mario Cornejo — Mon, 09 Apr 2012 16:27:00 +0000

En esta ocasión muestro una parte de como agregar elementos a la lista

Link Relacionados:
Introducción a jQuery (Parte 7)
Introducción a jQuery (Parte 9)

Introducción a jQuery (Parte 7)

Mario Cornejo — Thu, 05 Apr 2012 16:19:00 +0000

Octavo video de la serie. Eliminando elementos de la lista

Links Relacionados:
Introducción a jQuery (Parte 6)
Introducción a jQuery (Parte 8)

Introducción a jQuery (Parte 6)

Mario Cornejo — Wed, 04 Apr 2012 17:18:00 +0000

Séptimo video de la serie…

Links Relacionados:
Introducción a jQuery (Parte 5)
Introducción a jQuery (Parte 7)

Introducción a jQuery (Parte 5)

Mario Cornejo — Tue, 03 Apr 2012 14:08:00 +0000

Sexto video de la serie sobre jQuery.

Links Relacionados:
Introducción a jQuery (Parte 4)
Introducción a jQuery (Parte 6)

Introducción a jQuery (Parte 4)

Mario Cornejo — Mon, 02 Apr 2012 12:28:00 +0000

Quinto video de la serie

Links Relacionados:
Introducción a jQuery (Parte 3)
Introducción a jQuery (Parte 5)

Introducción a jQuery (Parte 3)

Mario Cornejo — Thu, 29 Mar 2012 16:48:00 +0000

Cuarto Video de la Serie…

Links Relacionados:
Introducción a jQuery Parte 2
Introducción a jQuery Parte 4

Introducción a jQuery (Parte 2)

Mario Cornejo — Wed, 28 Mar 2012 16:14:00 +0000

Tercer video de la serie sobre jQuery

Links relacionados:
Introducción a jQuery (Parte 1)
Introducción a jQuery (Parte 3)

Introducción a jQuery (Parte 1)

Mario Cornejo — Tue, 27 Mar 2012 16:54:00 +0000

Segundo video en la serie de Introducción a jQuery.

Links Relacionados:
Introducción a JQuery (Parte 0)
Introducción a jQuery (Parte 2)

Introducción a jQuery (Parte 0)

Mario Cornejo — Mon, 26 Mar 2012 22:24:00 +0000

En la pasada reunión de la comunidad .Net Tijuana presenté el tema de jQuery, Mostré que es y como usar lo básico de esta librería, aunque faltó tiempo para presentar todo el temario que había preparado. Se grabó la presentación pero al final de la misma nos dimos cuenta que el audio no se grabó así que decidí grabar una serie de screencasts donde muestro el uso de jQuery al realizar una aplicación de ejemplo. Los videos son de 5 minutos o menos. Espero los disfruten.

Links Relacionados:
Introducción a jQuery (Parte 1)

Run 2012

Thu, 22 Mar 2012 14:00:20 +0000

Mañana voy estar presentando en el Run 2012 dos tecnologias muy interesantes: Web API y SignalR. El Run 2012 es el evento técnico mas importante de la comunidad de tecnologías Microsoft en la Argentina.

Se pueden registrar aqui.

Espero verlos ahi!

Filed under: ASP.NET, Conferences

Material de ultimas conferencias

Sun, 04 Mar 2012 15:49:21 +0000

Lo prometido es deuda y aqui pueden encontrar el material de mis ultimas charlas:

La primera en el Manage IT Online sobre arquitectura y estandares tomand como ejemplo HTML5 y JavaScript.
La segunda, junto a mi compaño Mariano Sanchez, en el MUG sobre Extensibilidad en ASP.NET MVC.

Pueden descargar el material de aquí y aquí.

Gracias a todos los que estuvieron presentes!

Filed under: ASP.NET, Conferences

Iniciando con QUnit

Mario Cornejo — Mon, 06 Feb 2012 21:49:00 +0000

Hace poco escribí un post sobre como iniciar con jQuery. En esta ocasión quiero mostrar como hacer el mismo ejemplo; pero escribiendo las pruebas unitarias primero (a la TDD) utilizando QUnit.

Lo primero que debo hacer es crear un archivo HTML con la plantilla que esta en el sitio de QUnit con unos cuantos cambios…. cambié la ubicación de la hoja de estilos, agregue las ubicaciones de los scripts de jQuery, QUnit y agregué un div con id “main” que es donde escribiré el HTML necesario para las pruebas. El archivo me quedo así:

<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8" />
        <title>QUnit Tests</title>
        <link rel="stylesheet" href="http://code.jquery.com/qunit/qunit-git.css" >
        <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js"></script>
        <script src="http://code.jquery.com/qunit/qunit-git.js"></script>
    </head>
    <body>
        <h1 id="qunit-header">QUnit Hello World</h1>
        <h2 id="qunit-banner"></h2>
        <ol id="qunit-tests"></ol>
        <div id="main"></div>        
        <script>
            test("hello", function() {
                ok(true, "world");
            });
        </script>
    </body>
</html>

En esta plantilla viene escrito una prueba de ejemplo llamada “hello”. Voy a modificar esa función para especificar lo que quiero probar. Para escribir la prueba voy a aplicar el estilo AAA (Arrange, Act, Assert). Primero (Arrange) especifico las precondiciones para que pueda correr la prueba, en este caso sería escribir el HTML necesario y ligar el evento clic del botón a mi función. En la segunda parte (Act) escribo el nuevo comentario en la caja de texto y disparo el evento en el botón. En la tercera parte (Assert) verifico que se haya agregado un comentario, es decir que la lista tenga un elemento con el contenido esperado. La prueba queda de la siguiente manera:

test("when click 'add' then a comment should be added to the list", function(){

    //Arrange - Agrego el HTML necesario y ligo el evento click del botón
    $("#main").append('<ul id="comments"></ul>'
        + '<input id="comment" type="text" />'
        + '<button id="add">Add</button>');            
    $("#add").click(addComment);
    
    //Act – Escribo el nuevo comentario y hago clic en el botón
    $("#comment").val("comment");                        
    $("#add").click();
    
    //Assert – Verifico que el nuevo comentario este en la lista     
    equals($("#comments").html(), "<li>comment</li>");

});

Una vez que tenemos la prueba, lo que sigue es correrla y verificar que falle para después escribir el código necesario para hacerla pasar. Para correr la prueba lo único que necesito es guardar el archivo (en este caso lo llamé test.html) y abrirlo con un navegador. Al abrir el archivo en el navegador este me muestra el error.

El error dice que no se encontró la función “addComment” que es la función que se va a ejecutar cuando se haga clic en el botón. Para definir mi función voy a crear un nuevo archivo al cual llamaré comments.js y agregar la referencia a el desde el archivo test.html. En este archivo (comments.js) es donde definiré la función addComment (por ahora haré la función global espero después escribir sobre como simular namespaces y definir funciones “privadas” en JavaScript). A continuación muestro el contenido de mi archivo comments.js

function addComment(){    
  var newCommentTextBox = $("#comment");
  var commentText = newCommentTextBox.val();
  $("#comments").append("<li>" + commentText + "</li>");
  newCommentTextBox.val('');    
}

Como puede verse es lo mismo que en el post anterior solo que ahora esta en su propio archivo js. Agrego la referencia en el archivo test.html

<script src="comments.js"></script>

y vuelvo a correr las pruebas (actualizando la página en el navegador). Veo que la prueba pasa.

Ahora puedo tener confianza para hacer modificaciones sin preocuparme de que eche a perder funcionalidad. Además de que el código JavaScript quedó en su propio archivo (comments.js) separado del HTML.

Dev3Cast sobre NancyFx

Mario Cornejo — Thu, 02 Feb 2012 16:39:00 +0000

El pasado 16 de enero Gabriel Flores y yo platicamos con Miguel Ángel Jiménez sobre el web framework Nancy. Miguel nos platicó de que se trata y a grandes rasgos como es que se usa. Además hablamos un poco sobre el open source en la plataforma .Net

Pueden escuchar la platica y unirse a ella comentando en el post del dev3cast

Dev3Cast sobre MongoDB y Redis

Mario Cornejo — Thu, 02 Feb 2012 16:28:00 +0000

El pasado 2 de diciembre se publicó un episodio del dev3cast podcast donde participé junto con Eber, Samuel y Gabriel. En esta ocasión hablamos sobre MongoDB, redis y como usar en proyectos de software estas tecnologías NoSQL.

Capsela, el juego que cambió mi vida

jfromaniello@gmail.com (José F. Romaniello) — Tue, 31 Jan 2012 22:46:00 +0000

En 1995 mis padres realizaron un viaje a Estados Unidos y como regalo me trajeron un juego bastante peculiar llamado Capsela. Solo mirando hacia atras puedo darme cuenta del impacto que tuvo este juego en mi vida y es por eso que hoy decidí escribir un artículo en forma de tributo.

Poca información he encontrado en internet acerca de este juego en estos días. Sobre su origen podría decir que fue diseñado y fabricado en principio por "Mitsubishi Pencil Co" en la decada de 1980, luego se le dió la licencia a una empresa llamada "Play Jour" y desde ese momento fue fabricado por VTech, Kidology y algunas otras subsidiarias.

¿En qué consiste el juego?

El juego consiste en interconectar cápsulas, con diferentes propósitos mecánicos o eléctricos, para crear diferentes tipos de "modelos". Estos modelos son en su mayoría vehículos tanto para el agua como para la tierra, aunque también es posible construir grúas, robots, bombas de agua e incluso una aspiradora de polvillo. Si bien el manual del juego trae una basta colección de gráficos con cada uno de los modelos que se pueden crear, mucho mas interesante es dejar volar la imaginación y armar lo que nos plazca, una "grúa aspiradora de polvillo con forma de oruga"? suena interesante.

Todo modelo parte desde una cápsula fundamental que contiene un motor y dos terminales en donde se "conectan" los cables de alimentación desde las pilas (que a su vez se colocan dentro de otra cápsula) o desde una llave que además es inversora pilas-llave-motor.

Las cápsulas mecánicas son preciosas, con sus engranajes adentro forman algunos de los componentes más comunes que existen en las cosas mecánicas que nos rodean. La explicación en el manual es algo imperdible también, por ejemplo estas tres:

Lamentablemente, el manual que tengo en este momento esta en tres idiomas Alemán, Italiano e Islandés, y ninguno es mi fuerte. Pero voy a hacer mi mejor esfuerzo:

Cápsula motor: El motor incorporado es alimentado de la pila externa. Sí usted desea cambiar el sentido de la rotación del motor, invierta la posición del cable de la batería. Sí usted desea usar la caja del interruptor, colocar los cables como se indica en el diseño. Estar bien atento de no mojar el motor, corre el riesgo de dañarlo.
Cápsula de reducción de velocidad a estado multiple: Esta cápsula reduce la velocidad del eje, y al mismo tiempo aumenta el momento de torsión o la fuerza de rotación. Para un buen funcionamiento del motor, el mismo debe ser conectado al eje de entrada. Si por error es colocado al eje de salída, el motor no se moverá. Para saber cual es el eje de entrada, hágalo rotar con el dedo. El eje de entrada es el que rota fácilmente.
Cápsula de cambio de la marcha: Esta cápsula combina la función del cambio de la velocidad con la cápsula de la rueda y diente en una sola unidad. De este modo se puede reducir la velocidad del eje y cambiar la dirección de la fuerza motriz directamente en angúlo recto.

Cápsula engranaje planetario: esta cápsula permite cambiar el sentido de la fuerza motríz en angúlo recto (90°). Sí usted instala un eje a la rueda dentada el comando puede ser transmitido en tres sentidos.
Cápsula engranaje interno: esta cápsula cambia la velocidad del eje sin cambiar el sentido del comando.
Cápsula del interruptor rotante: cuando el eje gira, el interruptor es colocado alternativamente en posición abierta y cerrada. El diseño muestra como debe colocar la lámpara con la pila.
Cápsula de fricción: esta cápsula fue concebida para conectar o desconectar el comando del motor. Los dos engranajes pueden ser desconectados mediante el dispositivo de dos puntos.
Cápsula de transmisión: esta cápsula puede ser conectada a cualquier otra capsula con el objetivo de extender la acción del cambion de la marcha sin cambiar el engranaje de la fuerza motríz.

Luego vienen un monton de partes que pueden ser conectadas a dichas cápsulas, algunas de ellas se pueden ver en esta imágen:

Para unir cada cápsula se utiliza una pieza de forma octogonal como se indica en esta figura:

Otra perla del manual es este gráfico:

Que en mi opinión sintetiza muchisimos años de la historia de la mecánica.

Lo que se pueden armar

Con las partes antes mencionadas se puede armar este tipo de cosas:

El manual de instrucciones trae muchos ejemplos más pero no es mi intención aburrir.

Comercial de televisión

También encontré esta otra perlita, un comercial de TV de los años 80' supongo.

En este video se puede ver incluso un control remoto que yo nunca tuve. Como así también leí en wikipedia que se fabricó un modelo que tenía una interfaz para conectar a Commodore 64, un antecesor Lego Mindstorms.

¿Cómo me afecto este juego?

Por empezar no estudie ingeniería mecánica. Sin embargo me abrió la cabeza, la "libertad" de poder inventar juguetes. Aprendí que por ejemplo, con ciertos componentes podía transformar la energía del motor, la relación entre la velocidad y la fuerza, etc.

Despertó en mí un deseo e interés por la ingeniería. Visto hacia atrás, encuentro muchas similitudes entre mi trabajo actual como desarrollador de software y este juego. De hecho cualquier ingeniería se asemeja; "aquí están tus herramientas y estos son los bloques que puedes utilizar, ahora construye lo que quieras! el único límite es tu imaginación!!". Tal vez ahora no se aplica "lo que quieras", mas bien lo que otro quiera. Pero como a muchos de los mejores profesionales con los que he trabajado les sucede, nuestro trabajo se convierte en nuestro hobby y es ahí cuando dejamos volar nuestra imaginación de nuevo, al igual que el José de 10 años sentado en su habitación, pensando que inventar.

Mi mamá guardó todas las partes del juego a pesar de que yo las ignoré por mucho tiempo, y hace dos años ya, encontré una persona en mercadolibre que vendía el suyo. A pesar de que era una versión que traía menos partes que el que ya tenía y de que había sido usado, estaba en excelentes condiciones. Ahora tengo 2 Capsela, y a veces armamos cosas muy alocadas con mi hija Valentina (6 años).

Para terminar este artículo, me gustaría felicitar a las personas que diseñaron este jueguete, moriría de felicidad si alguno de ellos leyera esto, y agradecer a mis padres, Gines y Franca, por haberlo comprado en Toys"R"Us en 1995.

Iniciando con jQuery

Mario Cornejo — Fri, 27 Jan 2012 09:10:00 +0000

He estado pensando en escribir alguno que otro post sobre JavaScript. No digo que vaya a empezar una serie ni mucho menos (luego las dejo a medias) pero si escribir algunos post. Así que iniciamos por el principio. Lo básico de jQuery.

El ejemplo será una lista de comentarios a la cual le quisiéramos ir agregando elementos a la lista. Tenemos el siguiente HTML:

<html>
    <head>
        <title>Comentarios</title>    
    </head>
    <body>
        <ul id="comments">
            <li>Comentario 1</li>
            <li>Comentario 2</li>
        </ul>    
        <input id="comment" type="text" /> 
        <button id="add" >Agregar</button>         
    </body>    
</html>

La intención es que cuando el usuario haga clic en el botón “Agregar” se agregue lo escrito en la caja de texto a la lista de comentarios.

Lo primero que debemos hacer es agregar la referencia al código de jQuery. Podemos usar una copia local o hacer uso de alguna red de distribución de contenidos (CDN).

<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js"></script>

con esto ya podemos hacer uso de jQuery. Así que agregamos un bloque de script a nuestra página para agregar la funcionalidad que requerimos.

<script>
    $(function () {
        $("#add").click(function () {
            var newCommentTextBox = $("#comment");
            var commentText = newCommentTextBox.val();
            $("#comments").append("<li>" + commentText + "</li>");
            newCommentTextBox.val('');
        });
    });
</script>

Lo primero que hacemos es pasar como parámetro a la función “$” de jQuery una función que queremos que se ejecute al cargarse la página. Dentro de esta función tenemos la línea $(“#add”).click(function () { que lo que hace es primero buscar al elemento con id=“add” (en este caso el botón) después llamar el método click y pasarle la función que queremos ejecutar cuando se haga un clic en el elemento.

Dentro de la función buscamos el elemento id=“comment” (que es la caja de texto) y obtenemos su contenido con la función val(). Después agregamos un elemento más a la lista de comentarios (id="comments") con el texto que obtuvimos de la caja de texto. Por último limpiamos la caja de texto con newCommentTextBox.val('');.

Espero que este post sirva para que quienes aun no se animan a entrarle a JavaScript vean lo fácil que es, empiecen a perderle el miedo y aprovechen las ventajas que tiene.

Probando sin mocking framework

Mario Cornejo — Tue, 24 Jan 2012 17:08:00 +0000

Al estar trabajando en un proyecto sobre ASP.NET MVC pequeño. Pensé que sería mas fácil animar a escribir pruebas, a personas que no están acostumbradas, si al escribirlas no necesitaran usar librerías externas. Como son los mocking frameworks y las librerías para las aserciones. Así que decidí escribir las pruebas unitarias usando solo las herramientas que me brinda Visual Studio. Eso significa usar msTest y escribir implementaciones falsas de las dependencias de los sistemas bajo prueba.

Llegué a pensar que eso significaría escribir mucho más código ya que tendría que proporcionar varías implementaciones que un mocking framework me ahorraría. Sin embargo he notado que la cantidad de código no es mucho más. Ya que con las mocking frameworks necesitaba hacer más setups dentro del test. Es claro que tiene sus ventajas y desventajas.

Noté que para un programador, que no esta acostumbrado a escribir pruebas unitarias, es fácil entender qué es lo que pasa cuando usamos una implementación falsa donde puede ver el código. A la vez es fácil que escriba sus implementaciones que solo le sirven para pruebas. En ocasiones cuando trataba de explicar TDD (a gente que no esta acostumbrada) usando un mocking framework, u otra librería, notaba que varios se perdían un poco tratando de entender el código de setups de moq o de NSubstitute. Con implementaciones falsas escritas por ellos mismos (o que pueden ver lo que pasa) es más fácil concentrarse en (y encontrarle más sentido a) la prueba.

El método de prueba puede centrarse en los efectos secundarios del sistema bajo prueba, en lugar de la implementación. Es decir no pruebas que realice llamadas a ciertos métodos de las dependencias sino que tenga los efectos secundarios que se espera.

Una de las desventajas es que se necesita escribir la implementación falsa para que la prueba pueda correr y eso hace que pierda un poco el flujo de lo que se esta probando. Al tener que abrir otro archivo y escribir algo de código. Además que terminas con más código que mantener.

Otra es que a pesar de tener una implementación falsa que se puede compartir. De cualquier forma se necesita algo de código en la prueba para cumplir con las precondiciones que la prueba requiere y terminas con la implementación falsa además de código de setup. Otra vez más código que quizás el mocking framework me hubiera ahorrado.

¿Seguir usando Delphi?

Mario Cornejo — Fri, 13 Jan 2012 15:22:00 +0000

Aun mantengo y agrego nueva funcionalidad a una aplicación que desarrollé hace algunos años usando Delphi. Específicamente con Turbo Delphi, basado en la versión 2006 del entonces conocido como Borland Developer Studio. En realidad no se trata de una sola aplicación sino de una familia de aplicaciones para la administración de un negocio de venta al menudeo y medio mayoreo.

Sigo agregando nuevas características, conforme las necesidades de la empresa, lo cual no es muy seguido. Cada vez que tengo que agregar alguna funcionalidad me pregunto ¿Debería migrar el código fuente a alguna otra tecnología?

¿Por qué cambiar?

Bueno si funciona ¿Para que cambiar? es la otra pregunta que me hago inmediatamente después de pensar en migrar. Las razones son:

Mi forma personal de programar ha cambiado: al usar Delphi debo regresar a usar objetos como datasets, escribir SQL a mano (Sin ORM’s), mucho arrastrar y soltar para después modificar propiedades en el object inspector. Cuando lo que quisiera hacer es utilizar características de lenguajes y frameworks nuevos.
Documentación: Ya que no es una tecnología que use todos los días, cada vez que regreso a algún proyecto y necesito agregar algo de código o modificar alguna propiedad necesito buscar documentación para saber cual es la manera Delphi de hacerlo. No quiero escribir mucho código para algo que con cambiar alguna propiedad o arrastrar un componente hubiera bastado. No es mucha la documentación que se encuentra y la mayoría de esta es vieja o trata las nuevas características que aun salen para Delphi.
Precio: Otra razón para no migrar a una versión más reciente de Delphi (ahora parte de Embarcadero) es el precio de la licencia. Es más cara que una licencia de VisualStudio y siento que con VS puedo hacer más cosas que solo escribir aplicaciones de escritorio. Además de que las puedo desarrollar de una manera “moderna”.
La tecnología puede llegar a ser obsoleta: Al seguir desarrollando en la versión actual corro el riesgo de no encontrar soporte, alguien que pueda ayudarme, cuando necesite realizar algo que no este soportado en la tecnología actual. Como puede ser la integración con sistemas más “modernos”.

¿Por qué seguir en Delphi?

Aun con las desventajas que tiene el mantener la aplicación en una tecnología “vieja” creo que tiene ciertas ventajas mantener el código donde esta:

La aplicación funciona:Esta es la principal razón por la que sigo usando Delphi para esos proyectos. Aun no se ha presentado problemas graves por estar usando esa tecnología.
Tiempo de desarrollo: Es más rápido agregar características a las aplicaciones usando la tecnología actual que reescribir todo en alguna tecnología “nueva”. Además el código no esta mal/feo es relativamente fácil de seguir o de modificar para después agregar nueva funcionalidad.
Costo-Beneficio: Al final todo se reduce al costo beneficio. No estoy convencido que el costo que implica reescribir toda (o gran parte) de la aplicación tenga un beneficio que valga la pena el gasto. Si bien es posible que en un futuro sea más fácil seguir usando una tecnología moderna; por el momento no ha causado un problema seguir desarrollando en Delphi. Solo alguno que otro enojo (como programador) por no poder usar lambdas o cosas así.

Conclusión

Al no poder justificar completamente el gasto creo que seguiré desarrollando (por el momento) las aplicaciones principales en Delphi mientras me sea posible. Quizás haga proyectos pequeños, relacionados, usando alguna otra tecnología (como .Net) para ir migrando poco a poco. Pero sin descuidar que el desarrollo principal en estos proyectos es en Delphi. Aun sigo considerando también comprar la versión más reciente de Delphi aunque es lo menos probable.

Software en español

Mario Cornejo — Thu, 29 Dec 2011 22:13:00 +0000

Aunque uso principalmente solo software en inglés, seguido tengo la tentación de usar software en español. Tanto en el sistema operativo como en las herramientas de desarrollo y de base de datos.
Esto me pasa más cuando se trata de software administrativo, de entretenimiento o aplicaciones donde necesito escribir en español. En esos casos creo que sí tiene sentido usar aplicaciones e incluso el sistema operativo en español. Porque lo que realizo es en español y el programa (al estar en el mismo lenguaje) puede ofrecerme ayuda adicional. Por ejemplo prevenir faltas de ortografía, de gramática, etc.
El problema viene al tratar de usar herramientas de desarrollo que no están en ingles, ya que el desarrollo debe ser en inglés y si la herramienta de desarrollo esta en español es una desventaja. Tanto en los mensajes de error como en la terminología utilizada. Puede ser difícil encontrar información sobre términos técnicos en español o por lo menos encontrar información reciente.
Hace tiempo instalé la versión en español de visual web developer y se sentía raro usarlo, algunos mensajes arrojados por las excepciones no me eran familiares por estar en español. Pero fue algo divertido y quizás lo vuelva a intentar pero siento que podría haber problemas de compatibilidad con el resto del equipo.
¿Es común usar software completamente en español? Por lo menos en frontera no lo he visto así; pero me gustaría saber como sería la experiencia. Quizás el próximo año me anime a hacer el experimento e instale todo en español para saber que se siente. Aunque presiento que no será posible tener las versiones más recientes.
Post relacionado: Teclado en Español Latinoamérica

Usando varios atributos en C#

Mario Cornejo — Fri, 23 Dec 2011 10:40:00 +0000

Al trabajar en proyectos sobre ASP.NET MVC, al crear los modelos he estado usando Data Annotations las cuales consisten en agregar atributos a las propiedades de tu modelo para indicar algo de meta datos que pueden ser usados por la vista. Además de que al usar entity framework code first he necesitado en alguna ocasión usar atributos, aunque últimamente he optado por configurar eso en el mapping del DbContext. También en lo controladores hay necesidad de escribir algunos atributos para los Action Filters.

He visto que la forma más común para agregar más de un atributo a una clase, propiedad o método es escribiendo uno abajo del otro. Con lo que al declarar una propiedad que tiene varios meta-datos se termine con varias líneas de código. O al definir una acción en un controlador donde necesitas que se ejecuten varios action filters termines con varias líneas en la declaración del método, lo cual (en mi opinión) se ve igual que si se ejecutan las llamadas de los filtros dentro de los métodos.

[Required]
[DataType(DataType.Password)]
[Display(Name = "Current password")]
public string OldPassword { get; set; }

En mi caso me ha gustado más el escribir los atributos uno a un lado del otro separados por coma dentro del mismo par de corchetes. Esto hace que sean menos líneas la declaración de un método, propiedad, etc. Y lo principal es que (para mi) se ve más claro. Es decir no es por ahorrarme líneas, las líneas son gratis, sino para quitar ruido en el código.

[Required, DataType(DataType.Password), Display(Name = "Current password")]
public string OldPassword { get; set; }

Como todo es cuestión de gustos y si todo el equipo decide usar uno abajo del otro me tendré que alinear; pero por lo pronto prefiero escribir uno después del otro.

CoffeeCamp: El año en revisión

Mario Cornejo — Thu, 15 Dec 2011 16:50:00 +0000

La comunidad .Net de Tijuana organiza un CoffeeCamp el próximo Sábado 17 de diciembre de 2011 en el café Starbucks que esta frente a las torres. El tema es "El Año En Revisión". La idea es reunirnos y platicar de software mientras nos tomamos café (u otra cosa). En la página del evento pueden encontrar más información.

Si eres desarrollador y estas en Tijuana el Sábado 17/12/11, esperamos verte por ahí.

Proxima VAN, HTML5 para los no iniciados y curiosos

Tue, 13 Dec 2011 12:28:34 +0000

Este sabado 17 de diciembre tendre el placer de compartir con la comunidad de Alt.Net Hispano el codiciado tema “HTML5 para los no iniciados”, si, eso que esta sonando por todos lados acerca de HTML5, que tan raro es? como se come? me curara la caries? Tantas preguntas, tanto material.

HTML5 es muchisimo mas que un estandar, mucho mas que un simple buzz, va bastante mas alla de un simple lenguaje de markup. Tratare de explicar HTML5 desde el punto de vista de un desarrollador web, especialmente que implica para un developer de ASP.NET.

El evento pueden encontrarlo en el link de Google Calendar, no olviden hacer la transformacion en su huso horario.

Ultimas Conferencias: HTML5 y Silverlight

Thu, 01 Dec 2011 13:03:09 +0000

Las últimas semanas di 2 presentaciones sobre desarrollo Web:

La primera en la Universidad Nacional de La Matanza sobre HTML5.
La segunda en el MUG sobre desarrollo en Silverlight.

Pueden descargar el material de aquí y aquí.

Gracias a todos los que estuvieron presentes!

Filed under: ASP.NET, Client App Dev, Conferences

Code Camp 2011

Tue, 25 Oct 2011 14:47:48 +0000

La semana pasada se realizó la edición 2011 del Code Camp. Como todos los años fui speaker, aunque en esta oportunidad me toco hablar sobre un tema que creo nunca estuvo presente en ningún Code Camp: C++. Con este lenguaje está programado casi toda la tecnología que usamos diariamente, y con la llegada de Windows 8 y WinRT tendrá especial preponderancia en los próximos años.

Me sorprendió la cantidad de gente que asistió a la charla y el interés que despertó, luego de la charla recibí muchas consultas y preguntas.

Pueden descargar el material desde aquí.

Filed under: Conferences

Invitación a Webcast MSDN: “Prueba de automatización en todas partes”

Tue, 19 Jul 2011 23:50:11 +0000

El jueves 21 de Julio de 2011 a las 10:00 a.m. de Bogotá (Colombia) estaré presentando vía web, con Live Meeting, durante una hora, el tema “Prueba de automatización en todas partes” y como el nombre lo indica, estará principalmente centrado en pruebas, automatizadas, por supuesto. Ahí trataremos diversos tipos de pruebas que contribuyen a soportar el desarrollo de aplicaciones “mantenibles”.

Para demostrar las aplicaciones implementaré durante la sesión una aplicación web en Visual Studio 2010 con ASP.NET MVC 3, aunque el webcast no se centra ni en este framework ni en otra herramienta de software, sino más bien en algunas técnicas, que otros especialistas y yo hemos encontrado útiles en este ámbito de pruebas, que quisiera compartir con quienes asistan al evento.

Quienes me conocen saben de lo importante que considero el seguir un proceso ágil de desarrollo de software, así que pueden esperar que en este evento use algunos elementos de este estilo, específicamente Behavior-Driven Development.

Para asistir al evento es necesario que se registren usando el siguiente enlace:

https://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032487227

Podcast sobre “Behavior-Driven Development” (BDD) en dev3cast

Sun, 17 Jul 2011 13:06:40 +0000

El sábado 16 de Julio de 2011 estuvimos grabando con la gente de dev3cast una sesión muy amena en la que discutimos sobre algunas inquietudes relacionas sobre qué es y cómo aplicar BDD, la grabación quedó publicada en la página Behavior Driven Development, que por supuesto, los invito a visitar para que escuchen desde allí algunas de mis opiniones al respecto del tema y por qué lo considero tan valioso.

Como siempre, muchas se escapan y el tiempo no alcanza para abarcar varios asuntos interesantes, es por ello que trataré de publicar en este blog una serie de artículos detallando más esta interesante metodología ágil.

Webcast sobre API’s Web

Tue, 12 Jul 2011 13:26:02 +0000

Hoy junto a Zaiden vamos a estar dando un Webcast sobre API’s Web.

Se pueden registrar aquí

Los esperamos!!!

Filed under: .NET, ASP.NET, Webcast

ASP.NET MVC y AJAX en Channel 9

Tue, 12 Jul 2011 13:23:07 +0000

Se ha publicado en Channel 9 el video de la charla sobre ASP.NET MVC y AJAX que estuvimos dando con Z en todo el pais.

Para el que se la perdio la puede ver aquí!

Filed under: .NET, ASP.NET

RUN Web Camp 2011 Tour

Mon, 06 Jun 2011 19:45:18 +0000

La semana anterior junto a Zaiden estuvimos en la UTN Rosario en el marco del Run Web Campus dando una charla sobre desarrollo de aplicaciones Web con ASP.NET MVC y AJAX.

La misma charla la vamos a repetir en la UTN Santa Fe el día 8 de Junio, y en la ULP el día 10 de Junio.

Pueden descargar el material desde aquí.

Gracias todos los que vinieron a Rosario, y los esperamos en Santa Fe y San Luis!.

Filed under: .NET, ASP.NET, Conferences

ALM y TFS 2010

Mon, 11 Apr 2011 16:03:30 +0000

Gabriel Jara López ha escrito un excelente artículo sobre ALM con TFS 2010.

Se los recomiendo. Lo pueden leer aquí.

Filed under: Visual Studio

Run WebCamp 2011 en Buenos Aires

Martin Salias — Tue, 15 Mar 2011 19:34:00 +0000

Hoy participé en el Run WebCamp organizado por Microsoft de Argentina, en el barrio de Palermo, Buenos Aires.

Dentro de esta conferencia dedicada a desarrollo web en la plataforma Microsoft, me tocó presentar Entity Framework junto a mi viejo amigo Daniel Laco, con quien a pesar de los años que llevamos en la comunidad de desarrollo, nunca habíamos hecho un dueto.

La verdad es que más allá del resultado final, que el público juzgará, fue un placer dar una sesión con Dani y logramos completar todo el temario, que era bastante exigente, en 45 minutos exactos, con buen timing y sin pisarnos.

Como prometimos durante la charla, quedan aquí los links para descargar la presentación (recortada solo con el material importante y referencias), y los ejemplos, una solución completa con muchos ejemplos en detalle (cortesía de Dani), y una solución mínima mostrando lo básico de Code First (culpa mía).

Me siento halagado de haber participado con otros oradores muy buenos y muchos amigos, como Edu Mangarelli y Miguel Sáez, Phil Haack y Drew Robbins, Rodo Finochietti y Pablo Zaiden, y por supuesto, mis compañeros de ruta Johnny Halife y Mati Woloski.

El evento se emitió en vivo a través de UStream y espero que pronto quede disponible para verlo en video, idealmente con las charlas por separado.

MVP 2011 y objetivos para este año

Martin Salias — Tue, 04 Jan 2011 09:07:00 +0000

Otra vez, como desde hace años ya, arranco el año con la agradable noticia de que Microsoft me ha premiado como Most Valuable Professional. Siempre es un honor la distinción, aunque sigo sin saber muy bien qué es lo que consideran tan valioso en mi.

Nuevamente me premian en la categoría "C#", que por lo visto es algo así como un comodín para actividades mas bien ligadas a los lenguajes.

Como sea, es bueno sentirse reconocido, y un honor cuando uno queda cerca de la categoría de gente a la que admira. Y estas cosas refuerzan esta idea organizativa de fijarse objetivos para el año. Es cierto que es un plazo matemáticamente arbitrario, pero útil a nivel de planificación. Es como un relajado backlog personal que uno puede auto-imponerse para tratar de planificar después el corto plazo, semana tras semana o mes tras mes.

Pero hacer pública una lista de objetivos es una manera de dejar un compromiso más alto que simplemente proponerse algo. Uno sueña con un lector hipotético que algún día vendrá a reclamar si no se cumple nada de lo planeado.

Así, aquí van mis objetivos para el año, que iré atacando, por supuesto, de manera iterativa:

Lenguaje del año: como todos los años, en el 2011 trataré de aprender y comprender un lenguaje nuevo. Para mi comprender un lenguaje de programación significa conocer bastante su idiosincracia, el paradigma con el que está diseñado, sus puntos sobresalientes y problemáticos, y acercarme a la manera en que funciona la comunidad y el ecosistema detrás. Eso implica aprender, hacer katas, programar en ese lenguaje proyectos lo más reales posibles, y tratar de compartir todo lo posible lo aprendido, sobre todo haciendo algunas presentaciones en vivo o en video. Explicando a los demás, como dice el Maestro, es como más fácilmente nos "cae la ficha" y afianzamos nuestros conceptos.

El 2010 lo dediqué a Ruby (aunque personalmente no profundicé tanto como me hubiese gustado), después de zambullirme en F#, volver a Python (para quedarme -hoy lo uso cotidianamente e incluso tengo un shell de Python siempre a mano, dentro de Chrome), jugar con Boo, meterme en C# desde Generics hasta el IL generado, tratar de avanzar con Eiffel, debatirme entre Haskell y ML (sin lograr mucho con ellos por mis propias limitaciones).

A la hora de elegir un lenguaje para este año que inicia, prefiero terminar lo que empecé, y voy a dedicarme más a Ruby, pero esta vez específicamente a Rails y Sinatra, donde no hice tanto hincapié. Mi mayor avance con Ruby el año pasado fue entender el lenguaje mismo y usarlo para todas mis tareas principales de scripting y algunas aplicaciones desktop que necesitaba (si, es raro ver aplicaciones desktop en Ruby, pero se puede). Esta decisión tiene impacto directo en algunos de los siguientes objetivos, como se verá.
Me quedó pendiente, por varios motivos, dar un taller sobre Ruby, que quiero encarar este año. El principal problema fue que las veces que lo propuse lo hice junto a otras alternativas que sonaron más interesantes. Pero como es algo que personalmente quiero hacer, voy a ponerme en campaña por mi lado, y terminaré con alguna serie de videos en mi otro blog, Code & Beyond, y probablemente lo de presencialmente en el MUG o algun otro lado.
Hace tiempo tengo pendiente reconstruir mi sitio personal, que es una recopilación de servicios, links a trabajos, mis libros, películas, etc. Todo eso está armado con un antiquísimo script en Python que genera páginas estáticas ASP. En su momento no fueron HTML plano para poder incluir un par de cosas, pero en realidad son básicamente eso. No hay una base de datos detrás, nada dinámico. Los datos son fuentes diversas en mi máquina que se procesa(ba)n para generar las páginas. Y hace tiempo que no se refresca esa información, salvo lo que proviene de servicios como delicious.

Así que tengo un buen ejercicio a mano: rediseñar el sitio, pensándolo mejor (aunque el objetivo básico seguirá siendo tener consolidada una cantidad de información que está dispersa en la web) y usarlo como una práctica de Rails y también de actualizar mi conocimiento en HTML/CSS, que está algo vetusto.
Otro objetivo, a cumplir en el corto plazo, es actualizar mi hardware. Seguiré con una Mac, pero estoy cambiándola en breve por una de las nuevas MacBook Air, que ya tendrá su propia reseña.

Y en consecuencia con el cambio, también quiero aprender este año Applescript. Hasta ahora todas mis tareas en la Mac las automaticé entre un poco de bash y Ruby, pero hay muchas cosas en las que el scripting nativo de la Mac va ayudarme con seguridad. Además, la gente de Apress me regaló el libro "Learn AppleScript: The Comprehensive Guide to Scripting and Automation on Mac OS X, Third Edition", así que ¡no me quedan excusas!
Finalmente, como todos los años, sigo rumiando los bocetos de un libro (técnico), pero no quiero auto-imponerme una fecha límite para eso, porque todavía no tengo el temario final cerrado en mi cabeza. De alguna manera, Code & Beyond es una especie de lista de notas que me llevan en ese camino.

No es una lista tan grande. Espero llegar con todo terminado bastante antes de fin del año próximo, así que corto aquí y me pongo a trabajar.

EmpleosTI

Mario Alberto Chavez — Wed, 08 Dec 2010 11:18:00 +0000

El día de hoy anuncio un sitio para publicar ofertas de trabajo relacionadas con Tecnologías de Información, el sitio es empleosTI.

El sitio es muy sencillo de utilizar, no requiere de registro ni para publicar ofertas ni para consultarlas, las ofertan publicadas son enviadas automáticamente a Twitter a través de la cuenta @empleosti_dein, además de tener la posibilidad desde la vista de una oferta de enviarla por email, a Twitter o a Facebook.

Para ver el funcionamiento del sitio les dejo el siguiente video:

Actualmente el sitio aún esta en fase beta, es "usable" y funcional, y no tiene costo para publicar ofertas, así que si están buscando personal de TI.

El sitio salió como idea después de la VAN que di a @altnethispano sobre Ruby on Rails, inicialmente como una aplicación de concepto, después de verlo funcionar decidí hacerlo público como un servicio.

Resumen de posts

Mario Alberto Chavez — Sat, 04 Dec 2010 15:03:00 +0000

Posts recientes en el blog de http://blog.decisionesinteligentes.com

Video: Virtual Alt.NET Meeting sobre Cloud Computing

Martin Salias — Wed, 01 Dec 2010 11:49:00 +0000

Hace unas semanas participé en otra reunión virtual de Alt.NET Hispano, hablando un poco sobre Cloud Computing.

Gracias como siempre a Jorge Gamba y el resto del equipo de voluntarios, ya está publicado el video, que dejo embebido aquí abajo, pero recuerden que pueden ver cualquiera de los videos de la reuniones anteriores.

Unable to display content. Adobe Flash is required.

Wash, DRY and fold

Mario Alberto Chavez — Thu, 18 Nov 2010 16:59:00 +0000

DRY es una de las recomendaciones mas mencionadas en el desarrollo de software, DRY es el acronimo de "Don't Repeat Yourself" o "No te repitas" en español.

DRY lo que promueve es la no duplicidad de código fuente en nuestro software, ya que la duplicidad acarrea una serie de problemas de mantenimiento, inconsistencia en la funcionalidad, falta de claridad, etc.

Es por eso que en nuestros desarrollos debemos de buscar patrones de código que se repiten una y otra vez para tratar de extraerlos, abstraerlos y reutilizarlos.

El origen de este post es precisamente, que en un desarrollo en Ruby On Rails que estoy haciendo, encontre estos patrones repetitivos en mis controladores. La mayoría de ellos trabajan haciendo CRUD de manera muy tradicional, por lo tanto las acciones de: Index, Show, Edit, New, Create, Update y Destroy tienen código muy similar a excepción de las referencias al modelo sobre el cual actúan.

Buscando una solución para eliminar esto, me encontré con el proyecto de José Valim (@josevalim) Inherited Resources, el cual trata precisamente sobre como mantenerse DRY.
Algo importante es que Inherited Resources no cambia nuestra forma de trabajar al nombrar variables con nombres genéricos para que puedan ser usadas en nuestros controladores, el se encarga de nombrar las variables de acuerdo a la convención de Rails por lo tanto su uso es bastante transparente.

El post no se trata sobre Inherited Resources, por lo que aqui les dejo ligas a material de referencia para quien guste conocer mas:

¿Bueno entonces de que se trata el post? Es sobre DRY, pero mi implementación de DRY para un problema particular.

En el proyecto que estoy trabajando, tuve la necesidad de que la aplicación de Rails consumiera datos de un API de otra aplicación, la aplicación, de hecho son varias aplicaciones, que contiene lo datos no tiene API, por lo que con una aplicación de Sinatra, le cree un API Rest para que pueda ser consumida con la aplicación Rails - la aplicación de Rails y las aplicaciones sin API están en diferentes servidores/redes -. Esta API Rest puede ser consumida desde Rails a través del uso de ActiveResources, que aparentan ser modelos normales de Rails, pero que en realidad hacen llamados remotos a través de http para obtener sus datos.

En mi problema, tengo un controlador con diversas acciones, donde cada acción hace una llamada Rest a diferentes modelos y muestra los datos obtenidos, hay llamadas que traen una colección de objetos y otras que solamente traen un objeto en particular.

El patron que comencé a ver en las diversas llamadas para traer colecciones de datos fue:

así como la variación siguiente, también para traer colecciones de objetos:

La diferencia entre ellos es que en ocasiones se pasa el ID y en otras no, fuera de eso son muy similares.

Por otro lado, al traer un solo elemento el patrón era el siguiente:

Donde se pasa el ID en otro orden como parametro y la llamada ya no es al metodo all, es a find.

Este código se repetia una y otra ves en mi controlador donde solo cambiaba el nombre del Modelo, así como las variables @modelos y @modelo que es a donde se asignan los datos una vez que se obtienen.

Mi intención aquí es hacer que esto funcione DRY, y con la ayuda de un poco de metaprogramacion es fácil el lograrlo.

La idea es que pudiese hacer algo como:

fetch_resources! :modelo

fetch_resource! :modelo

Para obtener mis datos a través de Rest para el modelo adecuado y que se cargara la variable correspondiente con los datos correctos.

Así es como llegue al código que se muestra arriba. El método en singular trae un solo modelo a través de Rest y el metodo en plural trae una colección de modelos, opcionalmente ambos pueden aceptar un filtro en forma de Hash, y el modelo se indica a través de un símbolo.

El metodo fetch! es el que hace toda la magia, primero crea un Hash con el filtro default para todas las llamadas Rest, luego evalúa si a traves de fetch_resource! o fetch_resources! le estamos pasando filtros adicionales, si es así, los integra al Hash de filtro default.

En este punto es donde esta lo mas interesante, usamos en simbolo que se almacena en la variable resource para obtener la referencia a la clase del modelo sobre el cual nos interesa hacer la consulta, por ejemplo si nuestro símbolo es :cliente, asume que tenemos un modelo Cliente y sobre el queremos enviar nuestra solicitud Rest.

Acto seguido identificamos si tenemos un ID a traves del Hash params en el controlador, si es así, identificamos si debemos de llamar al metodo find o all y colocamos los parámetros de la forma correcta, mediante send hacemos el llamado de forma dinamica y el resultado lo guardamos en la variable values.

Finalmente fetch! asume que si tenemos una colección y nuestro símbolo es :cliente, esperamos tener una variable @clientes con los datos, en cambio si tenemos un solo modelo como respuesta y nuestro símbolo sigue siendo :cliente, asume que esperamos una variable @cliente con el dato.

De esta forma en nuestras vistas podemos hacer uso de @clientes o @cliente según corresponda.

Si bien no hubo un ahorro significativo en lineas de código, si hubo la eliminación de lineas de código repetidas y susceptibles a errores o cambios, las cuales fueron reemplazadas por otras instrucciones mas simples que manejan el mismo escenario para cualquiera de mis modelos.

Arquitectura de Software en el Ciclo de Vida Agil

Martin Salias — Mon, 08 Nov 2010 17:20:00 +0000

Durante el mes de octubre tuvimos nuevamente la oportunidad de facilitar nuestro auditorio en Southworks para otro desayuno de arquitectos de los que organiza Microsoft.

Esta vez, a diferencia de los últimos, en que sólo me tocó oficiar de anfitrión, Guada me pidió que presentara, ya que el tema elegido por el grupo tenía que ver con documentación y validación de arquitectura, algo sobre lo que vengo trabajando bastante fuerte, incluyendo el artículo que publicamos al respecto con Diego Fontdevila en el número 23 del Architecture Journal.

Casualmente, la sesión estuvo basada en la que presentamos con Diego en Agiles 2010, un par de semanas antes, en Lima, adaptada ligeramente a este público que tiene un perfil diferente.

Gracias a Julián Scopinaro, la sesión quedó capturada en video, que comparto aquí abajo.

Architects' Breakfast: Architecture in Agile Life Cycle - Part 1 from Southworks Showcase on Vimeo.

Architects' Breakfast: Architecture in Agile Life Cycle - Part 2 from Southworks Showcase on Vimeo.

Ruby on Rails este mes de Noviembre

Mario Alberto Chavez — Thu, 04 Nov 2010 10:50:00 +0000

Al parecer un mes mas activo en cuanto a mis actividades en Ruby y Rails este mes de Noviembre.

Primeramente Alt.NET Hispano me ha invitado este sábado 6 de Noviembre a dar una VAN sobre Rails, la dirección para conectarse aparecera ese mismo dia en el sitio o traves de la cuenta de twitter @altnethispano, la VAN sera a las 18:00 UTC/GMT.

El domingo 7 participare en el evento "Latam en Rails" de Rails.mx, con la platica "Uso de Steakrb para BDD", la platica en es linea y sera a las 5:30pm hora del centro de Mexico.

Finalmente el proximo sábado 13 de noviembre estaré en el evento "Software Freedom Day 2010" del grupo de usuarios linux de Tijuana, este evento sera en el Museo del Trompo y estaré a las 10:00am hora del pacifico platicando sobre Rails.

ConfORMando NHibernate 3 (the day after)

Fabio Maulo — Wed, 03 Nov 2010 14:58:00 +0000

Fue un placer ayer mostrar lo que se puede llegar a hacer con NHibernate 3.0 y alguna otras “cajita feliz”. La verdad es que pensaba que fuese un poco mas desafiante especialmente por el hecho que la mayoría de los asistentes son actualmente usuarios de NHibernate. En dos horas no pudimos ver mucho porque me dejaron hablar demasiado… Tal vez, si lo piden al MUG, podamos hacer otra session del

Code & Beyond: hablando muchos lenguajes, pero en español

Martin Salias — Wed, 03 Nov 2010 11:09:00 +0000

Para quienes han sido fieles lectores de este blog algo abandonado, no podía dejar de invitarlos a seguir mi nueva iniciativa: Code & Beyond.

El objetivo de este blog (que pronto contará con videos además de noticias) es difundir contenido interesante sobre desarrollo de software en cualquier plataforma y lenguaje, inicialmente al menos, apuntando al mercado hispano-parlante.

La idea es algo que venía rondándome hace tiempo, y que se impulsó por una serie de posibilidades y también gracias al soporte y perseverancia de mi amigo Julián Scopinaro, con quien compartimos tareas de comunicación en Southworks.

Hay una breve introducción en el primer post, pero aprovecho este blog, más personal, para exponer porqué me parece importante cubrir el espectro "multi-plataforma":

Por un lado, buena parte de mi carrera la dediqué de una manera u otra a proyectos con problemática fuerte de interoperabilidad, y es una especialidad que me ha sido valiosa y me ha generado muchas oportunidades. Incluso a lo largo de 20 años de relación con Microsoft, ellos mismos me han elegido varias veces para ayudarlos en proyectos que involucraban piezas más allá de su plataforma, y a medida que pasa el tiempo, veo que es cada vez más raro que una solución se pueda diseñar para un entorno homogéneo.

Desde otro ángulo, creo que entender y apreciar otras plataformas nos hace más sólidos y aumenta nuestra capacidad de discernimiento sobre las que estamos usando principalmente en un momento u otro. Desde el punto de vista de la arquitectura de software, por definición no deberíamos permitirnos tomar decisiones con un sesgo específico. Por supuesto, esto no significa que al evaluar alternativas para una solución no consideremos el valor de una plataforma que está más afianzada en la organización, o el equipo domina más. El tema es evitar la decisión por temor o ignorancia (si es que no son al final la misma cosa).

Tal vez el ejercicio y la disciplina que me exige Code & Beyond me haga escribir más frecuentemente en éste y otros blogs. Éste en particular seguirá siendo un punto donde hablar desde una perspectiva más personal, o compartir material o contenido de actividades mías no relacionadas directamente con el otro.

ConfORMando NHibernate 3

Fabio Maulo — Fri, 15 Oct 2010 16:07:00 +0000

El dia 2 de Noviembre estaré presenciando una charla en el auditorium del MUG (Microsoft Users Group) de Buenos Aires, Rivadavia 1479 1º A. Ver mapa más grande La intencción es la de mostrar un uso “distinto” de NHibernate. Para asistir no se necesita ninguna experiencia previa con NHibernate y si nunca lo han usado verán cuan simple es su uso. Si ya están usando NHibernate, aunque sea

Ahora soy MVP de Microsoft, es una buena oportunidad para decir gracias

Thu, 14 Oct 2010 13:44:25 +0000

Quiero expresar mi satisfacción al haber recibido el pasado 1 de Octubre de 2010 el reconocimiento como Profesional Más Valioso (MVP) de Microsoft en el mundo, en el área de C#. En el correo de notificación que recibí de Microsoft se mencionaba lo siguiente:

En Microsoft creemos que las comunidades técnicas mejoran la vida de las personas y el éxito del sector gracias a que expertos independientes, como usted, ayudan a otros a obtener un mayor valor de los productos y las tecnologías mediante el intercambio gratuito y objetivo de conocimientos. Como MVP de Microsoft forma parte de un grupo muy selecto de expertos que representan lo mejor y lo más brillante de la tecnología y que comparten un compromiso profundo con la comunidad y la voluntad de ayudar a los demás.

En nombre de Microsoft, le agradecemos su contribución a las comunidades técnicas.

Yo contesto a eso “muchas gracias Microsoft, yo también creo firmemente en las comunidades técnicas y también valoro el apoyo que nos dan ustedes a quienes trabajamos por ellas”. Si bien esto exige que hagamos algunos sacrificios en tiempo, energías y hasta en dinero, no es una labor meramente altruista, más bien es el medio que algunos hemos escogido para crecer tanto profesional como personalmente, a través de la colaboración con nuestros pares, otros desarrolladores de software, sean estos principiantes o gurús.

Ha sido muy buena la experiencia con la participación en la comunidad ALT.NET Hispano, para mi y se que para un montón de gente también, que hemos coincidido en el ánimo de hacer algo juntos por nosotros mismos, para mejorar nuestras habilidades técnicas en el desarrollo de software. Es bonito ver cómo si alguien dice “quien nos puede ayudar en [tal cosa]” luego alguien contesta “yo puedo colaborar”. Ha sido grato compartir con personas que cuentan no solo con un altísimo nivel técnico sino también con excelentes valores humanos.

Sería imperdonable no dar las gracias a mi esposa, Johana Cárdenas, no es que yo sacrifique mi familia por estar trabajando por las comunidades técnicas, la familia está primero, pero digamos que en algunas ocasiones ella ha tenido que ejercer cierta paciencia por los compromisos que exige mi ocupación. También debo expresar mi agradecimiento a quien yo y otros tantos consideramos nuestro mentor, Fabio Maulo, siempre listo a ayudar a quienes necesitamos una guía; a quien ha sido un gran influyente en mi pensamiento, Ángel “Java” López, con su filosofía Don’t be a canuto; y no podría dejar por fuera de esa lista a mis dos amigos José Romaniello y Cristian Prieto, quienes a parte de tener unas excelentes habilidades técnicas disfrutan dando la mano a otros para que también puedan obtenerlas.

Quienes me conocen saben que soy un firme creyente de lo que se promueve en el movimiento ALT.NET y que entonces valoro más las prácticas que las herramientas, que me esfuerzo por no caer ni en el fundamentalismo ni en tener una fe ciega en una tecnología específica o empresa, simplemente trato de usar y recomendar el mejor recurso disponible en el momento para mis necesidades y de acuerdo a las circunstancias; en otras palabras, trato de ser equilibrado y cuando se puede, neutral. Siendo coherente esta posición, en cuanto a Microsoft les puedo garantizar de que mantendré mi criterio independiente, para señalar sus aciertos y desaciertos cuando corresponda, siempre de una manera respetuosa.

Trataré de corresponder con el reconocimiento que me otorga Microsoft y la comunidad manteniendo y de ser posible mejorando mi contribución a la gente a quienes puedan interesar mis aportes, especialmente quiero relacionarme más con las comunidades presenciales (cara a cara) en donde no he tenido mucha participación hasta ahora, generar más contenido técnico y aportar más a proyectos Open Source.

Workshop: Desarrollo ágil de software en .NET, Segunda parte – Desacoplamiento

Tue, 12 Oct 2010 13:15:49 +0000

Hoy, martes 12 de octubre de 2010 presentaré la segunda sesión de una serie de 3 en un workshop sobre “Desarrollo ágil de software en .NET”. Esta sesión se podrá atender tanto presencial como virtualmente. Este evento se realizará en las instalaciones de Microsoft Colombia en la ciudad de Bogotá en la Carrera 7 # 71-21 torre B piso 15, a las 6:30 p.m. hora local, lo que corresponde con la hora internacional 23:30 UTC/GMT (meridiano 0), con una duración aproximada de 2 horas.

Esta sesión se titula “Desarrollo ágil de software en .NET: Diseñando componentes desacoplados” y al igual que la anterior, se presentará en un modo introductorio, puesto que el objetivo es presentar las opciones que tenemos a la hora de definir la arquitectura lógica y diseñar las clases siguiendo prácticas recomendadas para desarrollar aplicaciones mantenibles. No es requisito haber atendido la sesión pasada, pues al inicio haremos un repaso muy rápido, pero suficiente, de la técnica ágil que emplearemos para el desarrollo (BDD). Los ejercicios se realizarán en Visual Studio 2010 empleando con lenguaje C#. La descripción es la siguiente:

Para desarrollar aplicaciones de calidad se requiere la aplicación de principios, patrones y prácticas de diseño orientado a objetos, sin caer en la trampa de la sobre ingeniería. Pero en lugar de las aburridas explicaciones teóricas de programación orientada a objetos con los ejemplos típicos como Animal – Perro – Gato y similares, esta sesión será totalmente práctica, solucionando mediante código problemas y errores comunes a los que nos enfrentamos cuando construimos software. El resultado será conformar una arquitectura lógica sólida y elegante para nuestra aplicación de referencia y ejemplo, con objetos de alta cohesión y bajo acoplamiento.

Quienes deseen asistir presencialmente deberán inscribirse mediante un formulario de registro para evento presencial y los que deseen atender virtualmente (mediante Live Meeting) deberán usar este otro formulario de registro para Webcast.

Como iniciarse en Ruby/Rails

Mario Alberto Chavez — Tue, 05 Oct 2010 17:38:00 +0000

En varias ocasiones me han hecho esta pregunta y generalmente no tengo una respuesta sencilla, ya que no creo que exista una receta para lograr esto.

Creo que lo primero es obviamente tener interes por Ruby y/o Rails, un buen lugar para comenzar con Ruby es el sitio de Ruby Lang. Un libro muy bueno es Programming Ruby. Realmente no conozco muchos recursos en español sobre Ruby en particular. Otro libro interesante es Learn to Program donde enseña como programar desde el punto de vista de Ruby.

Una buena recomendación, antes de moverse a programar en Rails es aprender a programar con Sinatrarb, ya que que Sinatrarb a diferencia de Rails, no agrega tanta "magia" y hay que conocer mejor el lenguaje para hacer una aplicación con este DSL.

Sobre Rails igualmente no conozco mucho contenido en español sin embargo puedo recomendar seguir y estar pendiente de las siguientes comunidades y eventos:

Rails.mx, comunidad de Rails en México
OnRails, comunidad de Rails en Argentina
Rails Hispano, podcast en español sobre Rails
Conferencia Rails, conferencias de Rails en España, hay videos de conferencias pasadas.
Tambien porque no seguir a @tijuanarb en lo que esta el sitio listo en tijuanarb.org
Mario Cornejo tiene algunos videos introductorios en español sobre Rails

Una buena opción también es buscar si seguir a los tweeteros sobre temas de Ruby/Rails es español.

En cuestión de libros el único que puedo recomendar es Agile Web Development with Rails, aunque hay muchos otros.

De los recursos de podcasts y video, gratuitos y de paga puedo recomendar:

Peepcode $$, tiene por ahí varios vídeos básicos para aprender Rails
Tekpub $$, hay 2 series de videos una sobre Rails y otra sobre Sinatra y Rack
Rails3 de Gregg Pollack, videos con lo nuevo sobre Rails3
Railscasts, los videos por excelencia sobre Rails
SDRuby, videos de las sesiones de la comunidad de Ruby en San Diego CA
Ruby5, el mejor podcast sobre Ruby
Confreaks, videos de diversas conferencias de Ruby y Rails

Por ultimo y porque aun hay tiempo, bueno no mucho, Magma Rails es la primera - creo - conferencia de Rails en México y al parecer van a tener varias sesiones interesantes.

Como dije al principio no hay una receta especifica, pero si hay muchos recursos en Internet sobre Ruby y Rails, aunque la mayoría en ingles.

NOTA: En los comentarios me han pasado algunas referencias en español para comenzar en Rails.
Antonio me hace referencia RailsTutorial, el cual es un buen libro en linea
Obelich recomienda "El maldito libro de los descarrilados" ademas de recomendar la comunidad GuateOnRails de Guatemala y su curso de Rails. Tambien recomienda ASCII Casts en Español y un tutorial de Ruby.

Por otro lado desde algunas semanas me ha estado rondando la inquietud de hacer un taller de Ruby y Rails de unas 3 o 4 sesiones donde podamos aprender y construir aplicaciones, pero de momento no se que tanto interés habría aquí en la ciudad.

Workshop: Desarrollo ágil de software en .NET, Primera parte – BDD

Mon, 04 Oct 2010 19:36:50 +0000

Mañana martes 5 de octubre de 2010 estaré presentando la primera sesión de una serie de 3 en un workshop sobre “Desarrollo ágil de software en .NET”. Esta sesión se podrá atender tanto presencial como virtualmente. Este evento se realizará en las instalaciones de Microsoft Colombia en la ciudad de Bogotá en la Carrera 7 # 71-21 torre B piso 15, a las 6:30 p.m. hora local, lo que corresponde con la hora internacional 23:30 UTC/GMT (meridiano 0), con una duración aproximada de 2 horas.

Esta primera sesión se titula “Desarrollo ágil de software en .NET: Behavior-Driven Development (BDD)” y se presentará en un modo introductorio, de tal manera que no es requisito tener bases de desarrollo ágil de software, es más bien para quienes desean iniciarse en él, conocen la plataforma .NET, Visual Studio y los principios básicos de desarrollo de software. la descripción es la siguiente:

Desarrolle aplicaciones de calidad aplicando la metodología ágil BDD, que cubre todo el proceso básico de desarrollo de software, desde la captura efectiva de los requerimientos del cliente, que se traducen en pruebas de aceptación en el código y nos guían en la implementación del comportamiento de la aplicación que desarrollamos, de a pequeños incrementos, por medio de ejemplos de prueba. Crearemos una aplicación de negocios del mundo real, en C# usando los recursos que nos provee la plataforma .NET, que a su vez constituirá una pequeña aplicación de referencia y ejemplo que publicaremos como open source para la comunidad, en codeplex.com.

Podcast sobre Behavior-Driven Development (BDD) en 32MINUTOS.NET

Mon, 04 Oct 2010 18:59:55 +0000

El pasado 20 de septiembre de 2010 fue publicada la grabación de una sesión de audio del podcast 32MINUTOS.NET en la que el tema discutido fue uno que en lo personal me apasiona bastante y sobre el cual cada día aprendo más, Behavior-Driven Development (BDD) , que tiene como objetivo diseñar e implementar buen código, mediante la creación, en el mismo código tal vez por medio de una herramienta de software, de especificaciones (pruebas o ejemplos) automatizadas, que resultan de la definición de historias de usuario descompuestas en criterios de aceptación, que también pueden constituir las pruebas de la aplicación desarrollada.

Esta sesión de charla o discusión surgió del intercambio de opiniones por correo electrónico con Hadi Hariri, quien también es especialista en la materia, y al tornarse interesantes y extensas estas opiniones, acordamos pasar a algo más fluido y que pudiera servir de utilidad para la comunidad de desarrolladores, así que decidimos grabar la discusión de voz, a lo que se sumó David Vílchez, quien no solo hizo las veces de moderador y participó asumiendo el papel de recién iniciado en el tema; a ellos muchas gracias. La grabación quedó publicada en la página 01×02 BDD con Jorge Gamba.

Heroku y MongoHQ con Mongoid en Rails3

Mario Alberto Chavez — Tue, 28 Sep 2010 10:47:00 +0000

He tenido la necesidad de mostrarle en linea a un cliente un prototipo de una aplicación Rails3 que usa MongoDB como base de datos, para mi la opción por excelencia para estos prototipos es usar Heroku, un hosting de aplicaciones en la nube para Rails muy fácil de usar.

Lo interesante de Heroku es que tiene cuentas gratuitas - aunque con ciertas limitaciones -, que son perfectas para mi propósito. (En la primera reunión de @tijuanarb, @bitfon platico sobre Heroku).

Pero Heroku no tiene soporte directo para bases de datos MongoDB, aunque si ofrece un addon para integrarse con MongoHQ, servicio también en la nube para este tipo de base de datos, y al igual que Heroku, también tiene cuentas gratuitas, excelente también para prototipos. (También en la primera reunión de @tijuanarb, @fcastellanos hablo sobre MongoDB)

Hasta aqui todo bien, mi detalle vino al revisar la documentación de Heroku de como configurar la conexión a MongoHQ, ya que se requiere de una variable ambiente MONGOHQ_URL donde se coloca una URL que MongoHQ proporciona para cada base de datos, la forma de agregar esta variable en nuestra aplicación de Heroku es la siguiente:

$ heroku config:add MONGOHQ_URL="mongodb://mi-url-de-la-db-que-me-dio-mongohq"

Nota: a comentario de @fcastellanos, a la url de MongoHQ ha que agregarle el usuario y clave que tiene acceso a la base de datos, ejemplo:

$ heroku config:add MONGOHQ_URL="mongodb://[usuario]:[password]@[url_mongohq]"

Mi detalle viene a partir de que la documentación de Heroku no indica ningún paso adicional para configurar MongoID, la libreria de Ruby que mi aplicación usa para comunicarse con una base de datos MongoDB, sin embargo si hay pasos adicionales para otras librerías similares.

Así que asumí que todo estaba bien, me conecto a la aplicación y me indica un error, al revisar el log veo que no encuentra la base de datos, por lo tanto al parecer MongoID no estaba haciendo uso de la variable de ambiente MONGOHQ_URL.

Revisando el archivo config/mongoid.yml donde se configura la base de datos veo que espera obtener los valores de varias variables de ambiente:

host:
port:
username:
password:
database:

Así que lo que procedí a hacer es cargar esas variables al momento de iniciar mi aplicación para esto modifique el archivo config/applicacion.rb y justo a partir de la segunda linea y antes de los "require" agregue el siguiente código:

# MongoHQ Setup
require 'uri'
if ENV["MONGOHQ_URL"]
mongo_uri = URI.parse(ENV["MONGOHQ_URL"])
ENV["MONGOID_HOST"] = mongo_uri.host
ENV["MONGOID_PORT"] = mongo_uri.port.to_s
ENV["MONGOID_USERNAME"] = mongo_uri.user
ENV["MONGOID_PASSWORD"] = mongo_uri.password
ENV["MONGOID_DATABASE"] = mongo_uri.path.gsub("/", "")
end

Después de esto, volví a lanzar mi aplicación y ahí estaba finalmente funcionando, por fin Heroku y MongoHQ estaban trabajando juntos.

Manos, un framework ligero para aplicaciones web en .NET/Mono

Mario Alberto Chavez — Sun, 26 Sep 2010 12:27:00 +0000

Hace unos días platicando con @fcastellanos, me hizo notar un nuevo framework para el desarrollo de aplicaciones web para .NET/Mono, el framework es Manos.

Manos esta siendo desarrollado por el hacker de Mono Jackson Harper, quien comenta en su manifesto que le gusta desarrollar aplicaciones web y le gusta el lenguaje C#, pero no le gusta ASP.NET, cree que ASP.NET en general hace que las cosas sencillas sean muy complicadas y por eso decidió crear Manos y dejar a ASP.NET fuera de la ecuación.

Los objetivos de Manos es ser un framework:

Escalable y de alto rendimiento
Con un sistema "pipes" que permita conectarse y extender cualquier punto de la solicitud HTTP
Un sistema de rutas facil y simple, por medio de concordancia de texto y expresiones regulares
Auto conversion de parámetros en la ruta o post
Que funcione con HTML5 por omisión
Un sistema de plantillas basado en HTML
Linea de comando simple para la creación de aplicaciones, construcción y "hosteo" de aplicaciones, sin necesidad de IDEs
Basado en la reutilizacion de componentes, modular y facil de probar.

Si estuviese leyendo estos puntos y no sabría que se esta hablando de C# y .NET, pensaría que me están describiendo Rack y muy probablemente la combinación con Sinatra, pero no es así.

Estuve viendo los ejemplos y no puedo evitar pensar en términos de Rack/Sinatra, por ejemplo:

$ manos -init myapp # Crea un directorio con mi aplicación con jquery, algunos css y el modulo .cs

En nuestro modulo podremos escribir nuestra aplicación "Hola mundo" tan fácil como:

Get ("/", ctx => ctx.Response.Write("Hola mundo!"));

Lo compilamos, por ejemplo con Mono:

$ gmcs -target:library -out:myapp.dll myapp.cc StaticContectModule.cs

Y finalmente dentro del directorio ejecutamos

$ manos -server

Navegamos a localhost:8080 y nuestra aplicación debe de responder.

Increíblemente sencillo y facil, en el sitio de Github hay un ejemplo mas elaborado, junto con 2 tutoriales sobre Manos, tutorial1 y tutorial2.

Por cierto Manos es Open Source con licencia MIT X11, bastante permisiva.

Reunion del grupo tijuana.rb

Mario Alberto Chavez — Thu, 23 Sep 2010 08:00:00 +0000

El dia de ayer miércoles, se llevo a cabo la 1ra reunion de grupo de usuario de ruby/rails tijuana.rb, en la cual Sergio Lopez (@bitfon) habló sobre Heroku y el flujo de trabajo para publicar aplicaciones en ruby en la nube y Fernando Castellanos (@fcastellanos) sobre mongodb y como usarla en Rails.

El lugar fue la parte exterior del Starbucks Lucerna en zona rio, y tengo que admitirlo llego mucha mas gente de la esperada, en un punto éramos alrededor de 15 o poco mas, y aunque las condiciones del lugar no fueron las optimas - no nos alcanzo el espacio donde estábamos -, creo que estuvo bastante bien para la primera reunión. Así que para la siguiente reunión vamos a tratar de tener un lugar adecuado.

Ambas platicas interesantes y con muchas preguntas por parte de los asistentes.

En la reunion tambien nos acompañaron Jed Sundwall (@jedsundwall), Edward O'Connor (@hober) y Patrick Crowley (@mokolabs) del grupo de @SDRuby y SANDPYT - San Diego Phyton -. Y aunque solo uno de ellos hablaba español participaron de manera activa; y trajeron algunos regalos para rifar con los asistentes.

De lo interesante de que ellos nos acompañaran, es que tuve la oportunidad de platicar con Patrick, y salió la posibilidad de realizar eventos en conjunto, ya sea aqui en Tijuana o San Diego, lo cual es de lo mas interesante. De entrada ya veremos la posibilidad de realizar un "carpool" para asistir a la próxima reunión de @SDRuby.

Gracias a los que asistieron y esperamos verlos el siguiente mes, con mejores condiciones de espacio y gracias a @bitfon y @fcastellanos por su participación.

Calcular fechas laborables con Ruby

Mario Alberto Chavez — Wed, 22 Sep 2010 16:00:00 +0000

Hoy me encontré con este post llamado "Calculate Business Days using LINQ" donde explican como usar C# y LINQ para de un rango de fechas obtener solo las fechas que son laborables, es decir excluir las fechas que caigan en sábado y domingo.

El código se muestra a continuación donde se haca primero una llamada al método GetAllDates y se le pasa una fecha inicial y otra final, después con Where de LINQ se evalúa cada fecha un método que regresa falso o verdadero si la fecha cae en fin de semana o no, obteniendo al fina un arreglo con las fechas laborables.

Después de revisarlo, me pregunte, que tan complicado es hacer lo mismo en Ruby. Después de unos minutos me di cuenta que es ridículamente simple hacer lo mismo que LINQ y C# en solo 1 linea de código.

A mi metodo wroking_days se le pasa una fecha inicial y una fecha final y como resultado tenemos una arreglo de fechas excluyendo las que caen en fin de semana.

La complejidad de Ruby On Rails

Mario Alberto Chavez — Mon, 20 Sep 2010 11:25:00 +0000

A raíz de mi post anterior y algunos comentarios expresados en él acerca de la complejidad para tener una aplicación de Ruby On Rails funcionando con MongoDB, he decidido escribir este post, el cual lo voy a tratar desde la vista de un ex(o casi)-desarrollador de .NET y aunque quizás algunos de mis comentarios parezcan un ataque a un .NET, no es esa mi intención, así que por favor tomenlos relajados. Ni tampoco es mi intención decir cual es mejor o cual es peor, ese es un ejercicio que cada quien forma personal debe de realizar

Comencé a desarrollar en .NET desde las versiones beta del mismo, ya hace mas de 10 años, e inclusive desarrolle para Web desde antes, ya sea con código escrito en C a modo de cgi-bin o Perl, al igual me toco desarrollar para Web en Visual Basic 4 - 6. En esos tiempos era realmente algo complejo hacer paginas dinámicas y era muy sencillo tomar decisiones incorrectas y hacer que el desarrollo se complicara enormemente.

Con la llegada de .NET Microsoft proponía otro paradigma un tanto diferente de como desarrollar a Web, proponía hacerlo tal y como se escribían aplicaciones de escritorio, solo haciendo "drag and drop", "right click", configurar aqui y alla y listo, tener aplicaciones sin - o casi sin - escribir una linea de código, digo cuantas veces no hemos visto a empleados de Microsoft haciendo este tipo de demos en eventos de la empresa.

Desde mi punto de vista - si desde mi punto de vista y experiencia - esto funcionada super bien para aplicaciones muy simples y predecibles, mi problema siempre venia cuando se quería hacer "algo mas" con la aplicación, la complejidad de desarrollo iba en aumento y en ocasiones se convertía en algo nada trivial. Durante ese tiempo también me toco hacer desarrollo con Java, varios frameworks para Web y Tomcat, y la experiencia no fue mejor.

Llego un punto en el cual casi casi decidí dejar de escribir aplicaciones para Web y únicamente escribir aplicaciones para escritorio, pero los clientes seguían solicitando aplicaciones Web, así que busque alternativas en .NET - PHP realmente nunca me gusto ni me gusta, quizás no tengo argumentos técnicos para decir porque, simplemente no me gusta -.

La alternativa que encontre fue MonoRail, comencé a ver los ejemplos y a entender sus dependencias, MonoRail es un framework para ASP.NET que trabaja con los patrones de MVC y ActiveRecord, inspirado por Action Pack. Al investigar que es Action Pack, descubrí Ruby On Rails, pero en ese momento le encontre un problema, tenia que aprender otro lenguaje de programación y tenia algunas semanas para entregar una aplicación Web para un cliente.

Así que me decidi por MonoRail, pero había algunos "detalles", tenia muchas dependencias, no tenia "Wizards" ni componentes o controles como se les llama en ASP.NET WebForms, en lo personal no lo vi como problema ya que en lo personal es raro que use los "Wizards" o que utilice controles de 3ros, así que para mi no había perdida ahí, aunque si me ha tocado conocer y dar cursos a desarrolladores de .NET que si no tiene un "Wizard" o no pueden poner su "Grid" súper "fancy" no son capaces de desarrollar una aplicación.

Por otro lado, si bien la configuración de un ambiente de trabajo con MonoRail requeria de un poco de trabajo y entendimiento por arriba de "Drag and Drop" y "Right click", no me pareció gran cosa y mas cuando es algo que solo haces una sola vez. MonoRail me permitió entregar varias aplicaciones de manera muy rápida, quede impresionado y eso me llevo a investigar sobre Ruby On Rails. Por cierto hace algunos días anunciaron, parte de "Roadmap" de MonoRail.

El motivo por el cual MonoRail me permitió entregar aplicaciones muy rápido fue porque no tuve que tomar decisiones, MonoRail lo hizo por mi, por ejemplo no tuve que decidir como organizar mi aplicación, no tuve que decidir como conectarme a la base de datos, todo lo decidió MonoRail, así solo tuve que enfocarme en la funcionalidad que era importante para mis clientes y ya. MonoRail al igual que Ruby on Rails es opinioted software.

Al llegar a Ruby on Rails, obviamente la primera barrera fue el lenguaje Ruby, pero es muy facil acostumbrarse a el, aunque todavia escribo código a la C#, pero creo que voy mejorando.

Para la gente acostumbrada a los IDEs hay una gran variedad de opciones a elegir, en lo personal no soy fan de las IDEs, prefiero ambientes mas ligeros y que me hagan usar la consola de comandos, por lo tanto en Windows se puede seguir esta guia y en Linux estas dos guias, puede parecer complicado, pero es algo que solo se tiene que hacer una vez, si se usa un IDE en cuestión de minutos se tiene un ambiente complete y configurado.

Es muy sencillo crear una nueva aplicación con Ruby On Rails (RoR) haciendo uso de las decisiones que el framework hace por nosotros, por ejemplo:

$ rails new mi_super_app
$ cd mi_super_app
$ rails generate scaffold client name:string, address:string
$ rails server

Dirigimos nuestro navegador a http://localhost:3000/clients y listo ya podemos comenzar a dar de alta y modificar clientes, simple, fácil y rápido.

Si bien esto funcionara tal y como esta en un gran numero de casos, la gente en RoR pensamos en la regla 80/20, hay momentos en que se tiene que hacer algo un poco diferente para configurar nuestra aplicación, donde podemos cambiar las decisiones que RoR hace por nosotros y adaptarlas al 100% de nuestras necesidades, como las modificaciones propuestas en mi post para usar MongoDB en lugar de una base de datos relacional.

Si bien la intención de mi post es servir como una guia o receta, paso a paso de como hacerlo, también podemos hacerlo sencillo con el uso de Templates - así como existen también templates en Visual Studio para crear aplicaciones con ciertas características y defaults -, en e siguiente video de Railscasts se explica el concepto. De hecho existe ya un template para pre-configurar una aplicación de RoR para usar MongoDB y Rspec, con el cual se puede omitir mi post y solo ejecutar:

$ rails new mi_super_app -JOT -m ~/path_a/mongodb_template/templater.rb

Ya viendolo así, ¿ya no se ve que sean muchos pasos no?

Sobre el tema de las dependencias, al igual que en cualquier otro framework o lenguaje podemos tener dependencias a librerías de terceros o podemos elegir no hacerlo. En el caso de Ruby y sus diferentes frameworks, hay librerías para casi todo lo que nos podamos imaginar, RubyGems es un buen lugar para descubrirlas y Bundler nos permite manejar esas dependencias de forma sencilla y a nivel aplicaciones, es decir podemos tener la misma dependencia pero hacia diferentes versiones de la librería sin conflictos, no hay "DLL Hell".

Para determinar como elegir que dependencias tener en nuestra aplicación, va en relación directa de nuestras necesidades, pero creo que puedo sumarizar algunos criterios:

Librerías que fueron extraídas del framework de RoR
Librerías mantenidas por miembros del equipo de desarrollo de RoR
Librerías que son tan viejas como el mismo framework de RoR y que evolucionan paralelamente
Librerías mantenidas por empresas de desarrollo en RoR
Librerías populares y que tengan pruebas

Con respecto al soporte de los librerías disponibles en Ruby, este varia, pero el común denominador es que son OSS y el código de casi todas esta disponible en Github. En experiencia personal no he tenido problemas con esto, ya que a través de los grupos, IRC, reportando bugs o correo directo he tenido solución cuando se me ha presentado algún problema, inclusive, he enviado parches que han sido aceptados y generalmente la corrección a mi problema puede llevar algunas horas en lugar de tener que esperar días si fuese un bug en una librería comercial.

De las librerías que he utilizado realmente no me ha tocado alguna que pierda el soporte, cuando el desarrollador principal se retira generalmente sale alguien a continuar trabajando en ella, lo que si me ha tocado experimentar es el reemplazo de librerías por otras mejores, por ejemplo, cuando entre a RoR restful_authentication era "la librería" para el manejo y autentificacion de usuarios, posteriormente authlogic la reemplazo y actualmente devise es la librería popular, no es que las otras tengan algo malo o funcionen mejor o peor, es solo la manera en como evolucionan las cosas.

Creo que personalmente lo que encontre en RoR es que no me tengo que pelear contra el framework para poder entregarle aplicaciones a mis clientes, todo lo contrario, me puedo olvidar un poco del framework y dedicarme a implementar la funcionalidad que le da valor a mi trabajo.

Y afortunadamente puedo decir que aquí en Tijuana no he sido el único que ha encontrado este valor, ya que desde que comencé a platicar sobre RoR varios amigos implementaron soluciones para sus empresas y clientes de estas que están en linea y en tiempo record, y traen todavía mas proyectos nuevos que están siendo desarrollados en RoR, de mi parte igualmente tengo un par de proyectos en RoR que pronto verán "la luz", proyectos para mis clientes. Al mismo tiempo se de empresas que están tomando cursos y evaluando RoR para el desarrollo de nuevas versiones de sus productos, todo esto solo en Tijuana.

Creo que después de esta explicación algunos estarán de acuerdo conmigo y otros no, a final de cuentas debemos de ser apasionados con el lenguaje/framework que elijamos para trabajar, porque para bien o para mal a estos le vamos a dedicar nuestro tiempo laboral; pero el ser apasionados también implica el ser críticos de lo que usamos y si es posible conocer y probar otras herramientas, aunque si trabajamos para una empresa "casada" con una compañía/tecnología va a ser un poco difícil cambiar su visión, ya que generalmente se usan x tecnología por cuestión política o de mercadotecnia o gusto personal de la persona que toma las decisiones.

Aplicación de Rails 3 con MongoDB

Mario Alberto Chavez — Sat, 18 Sep 2010 00:06:00 +0000

En los últimos días he tenido que iniciar un par de proyectos en Ruby On Rails, donde la base de datos que se ha requerido es una base de datos no relacional, en este caso MongoDB.

La idea de este post es documentar la configuración de una nueva aplicación en Rails 3 para usar con MongoDB, donde vamos a desactivar ActiveRecord e instalar las siguientes herramientas:

Generadores Rails para Mongo
Rspec para pruebas
Factory Girl para fixtures
Haml como plantilla de vistas y jQuery.

Como paso inicial es necesario crear una nueva aplicación de Rails 3 - Se asume que ya se tiene instalado Rails 3 y MongoDB -, pero vamos a pasar las opciones -O para que no se creen archivos de ActiveRecord, -J para que no se instale la librería de javascript Prototype y -T para que no cree el fólder para Test::Unit

$ rails new mi_app -O -J -T

Después de creada la aplicación, seria buena idea inicializar un repositorio de Git.

Una vez creada nuestra aplicación hay que realizarle algunas adiciones nuestro archivo Gemfile para agregar las dependencias de nuestra aplicación:

mongoid y bson_ext => Mongoid es la librería que usaremos para conectarnos a la base de datos de MongoDB y bson_ext es una extensión en C para acelerar la serializacion de BSON
haml => Lenguaje de plantilla alternativa para vistas en Rails, desde mi punto de vista menos verbal y mas "developer friendly" que html y erb.

Dentro de un grupo llamado :development agregamos las siguientes gemas:

rails3-generators => varios generadores para Rails 3, lo que nos permite ejecutar rails generate
haml-rails => generadores de haml para Rails 3
jquery-rails => generadores de jquery para Rails 3

En el grupo :test agregamos:

rspec => framework para pruebas en Ruby
rspec-rails => utilerias para pruebas en RSpec para Rails
factory_girl_rails => utileria para la creación de modelos para pruebas
remarkable_mongoid => librería para pruebas de modelos de mongoid con RSpec

El archivo Gemfile debe de quedar como se muestra a continuación.

Para instalar las gemas solo ejecutamos

$ bundle install

Para conocer mas de las gemas instaladas aquí les dejo los vínculos a sus referencias

Una vez instaladas las gemas hay que realizar algunas configuraciones, lo primero es configurar mongoid para trabajar con Rails y desactivar ActiveRecord, para eso ejecutamos el comando:

$ rails generate mongoid:config

Este comando va crear el archivo config/mongoid.yml donde vamos a configurar el acceso a la base de datos de MongoDB, también va a modificar el archivo config/application.rb y va a eliminar la dependencia de ActiveRecord, la parte superior de config/application.rb deberá quedar algo similar a:

# require "active_record/railtie"
require "action_controller/railtie"
require "action_mailer/railtie"
require "active_resource/railtie"
#require "rails/test_unit/railtie"

Ya que estamos en el archivo config/application.rb vamos indicandole a Rails que en nuestra aplicación deseamos usar haml, rspec y factory_girl por omisión, para esto dentro de la declaración de la clase Application < Rails::Application, pero al final agregamos el siguiente código

A partir de este punto instalamos el soporte para jQuery y Rspec en nuestra aplicación de la siguiente forma:

$ rails generate jquery:install #--ui para activar jQuery UI
$ rails generate rspec:install

Como ultimo paso vamos configurar RSpec para que trabaje con factory_girl y remarkable, ademas de eliminar el soporte a ActiveRecord y hacer que RSpec elimine las colecciones creadas en MongoDB por nuestras pruebas antes de la ejecución de cada prueba, esto es necesario para asegurarnos que al correr cada prueba la base de datos este "limpia" y así no crear conflictos y/o dependencias en las pruebas.

Al inicio del archivo spec/spec_helper.rb hay que requerir:

require 'factory_girl'
require 'remarkable/mongoid'

Un poco mas abajo indicamos que cargue los archivos Factory de factory_girl

Dir[Rails.root.join("spec/factories/**/*.rb")].each {|f| require f}

Después eliminamos el soporte a ActiveRecord comentando las siguientes lineas:

config.fixture_path = "#{::Rails.root}/spec/fixtures"
config.use_transactional_fixtures = false

Y finalmente dentro y al final del bloque de configuración de RSpec indicamos que antes de cada prueba elimine las colecciones de MongoDB

config.before :each do
Mongoid.master.collections.select {|c| c.name !~ /system/ }.each(&:drop)
end

El archivo spec/spec_helper.rb deberá quedar muy parecido a

Una vez en este punto ya podemos proceder a crear nuestra súper aplicación usando MongoDB como base de datos, si ejecutamos el generador para model, o controller o scaffold, Rails 3 generara modelos para MongoDB o vistas en haml y creara los archivos necesarios en spec para realizar pruebas con RSpec.

Primera Reunion de tijuana.rb

Mario Alberto Chavez — Mon, 13 Sep 2010 08:38:00 +0000

Ven y asiste a la primera reunion del grupo de usuario Ruby/Rails de Tijuana, tijuana.rb, este proximo miércoles 22 de Septiembre en el Starbucks Lucerna de la Zona Río, a partir de las 7pm.

En esta primera reunión, Sergio Lopez (@bitfon) nos platicará sobre @heroku, un hosting para Ruby/Rails con cuentas gratuitas. ~~Estamos a la espera de la confirmación de una plática más~~. Fernando Castellanos(@fcastellanos) ya se apuntó con una platica sobre como usar MongoDB con Rails.

Para los que me han preguntado sobre como iniciar con Ruby, le dejo esta liga a un post "larguísimo" que escribí con ejemplos y aunque es sobre IronRuby funciona igual con Ruby. Si alguien lo quiere ver en video aquí esta la sesión grabada en ALT.NET Hispano.

Para estar al pendiente de lo que sucede con tijuana.rb únete al Google Group o sigue a @tijuanarb en twitter.

Recursos de ASP.NET MVC

Mario Alberto Chavez — Fri, 30 Jul 2010 16:59:00 +0000

Debido a un posible próximo proyecto con un cliente, me solicito le pasara una lista de recursos para conocer ASP.NET MVC, ya que su idea original era realizar el proyecto con ASP.NET Webforms, pero después de hablarle un poco de MVC y realizarle algunos demos, su interés por el mismo crecio.

De algunas de las platicas que tuve con él, al principio no estaba muy convencido, debido a que como él me lo comento "parece que en MVC tienes que hacer las cosas a mano", ya que no haríamos uso del "drag and drop" ni de la suite de controles web de Infragistics como él deseaba. Mis puntos para que se interesara en MVC fueron los siguientes:

El patrón de MVC es una "receta" probada por varias décadas
El usar MVC generalmente implica el uso de otra serie de patrones adicionales para resolver otros problemas en la aplicación
Aplicando estas "recetas" ayuda a que el desarrollo de la aplicacion sea mas uniforme si se siguen ciertos lineamientos, los cuales creo que son mucho mas claros si los comparamos con una aplicacion de Webforms
El usar MVC crea una linea de complejidad de la aplicacion mas estable, la cual puede ser un poco alta para pequeños proyectos, mas no asi para medianos y grandes, donde esta complejidad es mas uniforme, en cambio con Webforms la complejidad si es muy baja en proyectos pequeños, pero esta se va incrementando casi exponencial con proyectos mas grandes.
Otro punto importante es que en MVC se puede desarrollar y probar funcionalidad de la aplicación de manera aislada, mediante el uso de tecnicas y herramientas como: mocks, stubs, TDD o BDD, lo que permite ir creando bloques estables de la aplicacion e irla creciendo organicamente.

A final de cuentas, no se cual sea la decision del cliente con respecto al proyecto, espero me sea favorable, pero mientras tanto aqui les dejo el listado de recursos que le hice llegar sobre ASP.NET MVC esperando que les sirva de algo.

Libros interesantes

- ASP.NET MVC in Action 1 y 2 http://www.manning.com/palermo/ y http://www.manning.com/palermo2/

- Brownfield Application Development in .NET http://www.manning.com/baley/

Herramientas y arquitectura

- SharpArchitecture, framework para MVC http://sharparchitecture.net/

- NHibernate, ORM para .NET http://blogs.hibernatingrhinos.com/nhibernate/Default.aspx

- Arquitectura de Cebolla, parte 1 y 2 http://mario-chavez.blogspot.com/2008/07/la-arquitectura-de-cebolla-parte-1.html y http://mario-chavez.blogspot.com/2008/08/la-arquitectura-de-cebolla-parte-2.html

- El patrón MVC http://mario-chavez.blogspot.com/2008/09/programacin-web-patrn-mvc.html

Videos

- ASP.NET MVC http://www.asp.net/mvc

- Comunidad ALT.NET Hispano http://altnet-hispano.pbworks.com/Historial-de-reuniones

- Videos de MVCConf http://www.viddler.com/explore/mvcconf/videos

- Comunidad C4MVC.NET http://www.c4mvc.net/Home/Events

- Tekpub, videos de paga http://tekpub.com/production/aspmvc

Recursos de sitios y páginas interesantes

- Blog de HeadSpring http://www.headspringsystems.com/community/blogs/

- Blog de Mario Cornejo @mhcornejo http://www.developeando.com/search/label/ASP.NET%20MVC

- Links de Gabriel Flores @gabo http://delicious.com/gabofr/mvc

- Links de Mario Cornejo @mhcornejo http://delicious.com/mhcornejo/mvc

- Links de Eber Irigoyen @ebersys http://www.google.com/reader/shared/user/00321597721557820145/label/aspnetmvc

- Anuncio de ASP.NET MVC 3 http://weblogs.asp.net/scottgu/archive/2010/07/27/introducing-asp-net-mvc-3-preview-1.aspx

Presentando Southworks Professional Improvement Program

Martin Salias — Fri, 14 May 2010 16:54:00 +0000

Muchos de ustedes ya habrán leído sobre el proyecto Hogwarts en el blog del Maestro.

La motivación de este proyecto es aportar a la comunidad las prácticas de desarrollo de software que creemos fundamentales en Southworks, y que consistentemente vemos ignoradas o utilizadas parcialmente.

Esto cubre un abanico de metodologías, técnicas y espacios conceptuales bastante amplio, dentro de los cuales arrancamos con un primer curso cubriendo estos temas:

Test-Driven Development
Inversión de Control e Inyección de Dependencias
Mocking
Principios SOLID
Ejercicios generales utilizando todas la técnicas

Para cada uno de estos temas tenemos un conjunto de presentaciones, material de soporte para el instructor, proyectos de ejemplo con complejidad creciente y ejercicios de distinta dificultad incluyendo algunas soluciones de referencia.

También tenemos prevista la evaluación posterior a cada curso sobre los resultados de los ejercicios y una serie de preguntas para verificar los conceptos teóricos.

Nuestro plan inicial se enfocaba principalmente en generar todo este contenido para ejecutar clases presenciales, pero siempre pensamos en compartir en línea una buena parte para llegar a personas interesadas que no podemos alcanzar físicamente.

Sin embargo, la recepción que ha tenido lo que publicó Angel hasta ahora (por ejemplo el primer y segundo videos), nos impulsó a acelerar el avance de la faceta en línea del proyecto. El resultado es que estamos muy cerca de abrir a la comunidad el proyecto, basado en la plataforma de entrenamiento Moodle, funcionando por supuesto desde nuestra infraestructura en la nube.

Por supuesto, no descuidaremos la interacción cara a cara. La diferencia es que las sesiones presenciales serán complementarias al contenido en línea, para despejar dudas y realizar prácticas en conjunto. Y obviamente no sólo estarán a cargo y cerca nuestro. Esperamos que diversos grupos puedan replicarlas en forma local.

Interesados: permanecer atentos a este blog y el de Angel. La semana próxima deberíamos estar publicando el sitio final del proyecto. Hogwarts es el nombre de código del proyecto (otra práctica recomendable), pero el nombre oficial, que estamos presentando en sociedad es el del título:

Southworks Professional Improvement Program

CloudCamp Buenos Aires

Martin Salias — Wed, 12 May 2010 18:12:00 +0000

El 7 de mayo, la semana pasada, tuvimos la oportunidad de presentar en nuestras oficinas de Southworks el primer CloudCamp en Buenos Aires.

El evento salió muy bien, desde mi punto de vista y por el feedback de la gente, y esperamos compartir muy pronto algunos videos grabados durante el evento.

Tuvimos la presencia de uno de los fundadores del CloudCamp, Dave Nielsen.

Dave realizó la apertura del evento, explicando la estructura y la mecánica del evento, que contó con presentaciones relámpago (de 5 minutos) de cada uno de los sponsors: Microsoft, Southworks y Globant.

Luego de estas presentaciones pasamos al Unpanel (un anti-panel), con expertos que se propusieron como voluntarios en el momento mismo y contestaron a las preguntas de los asistentes.

El trío de expertos quedó conformado por:

Matías Bagini de JRapid (y organizador del Amazon User Group de Argentina)
Scott Densmore de Microsoft patterns & practices (en la foto junto a él, Eugenio Pace, también de p&p, haciendo de intérprete).
Johnny Halife de Southworks

A ellos se sumó parcialmente Dave en algunas respuestas del público, y de muchas de las preguntas se perfilaron los temas para las sesiones de los Open Spaces posteriores, a las que se sumaron algunas propuestas que el público votó en el momento.

Los temas que quedaron fueron:

Private clouds
Migrando aplicaciones a Windows Azure
NoSQL (y otros patrones de acceso a datos)
Seguridad en la nube
Google App Engine

En la foto aparecemos quienes quedamos a cargo de los temas, aunque en general se trató de discusiones participativas. De izquierda a derecha, Beto Ortega (Southworks), Scott Densmore (Microsoft), Fabio Maulo (NHibernate), yo (Southworks) y Pablo Francavilla (GetSense).

Quiero agradecer especialmente a Julián Scopinaro por su trabajo impecable coordinando todas la actividades necesarias para que el evento haya salido perfecto, a Mariano "Pocho" Szklanny por sus fotos (las de este post son apenas una muestra), y a nuestro cameraman exclusivo, Guido Maliandi, quien capturó en video la mayor parte del evento, para que pronto podamos compartirlo con el resto del mundo.

Video de mi VAN sobre Automatización

Martin Salias — Tue, 02 Feb 2010 13:44:00 +0000

Gracias nuevamente a los amigos de Alt.NET Hispano, y sobre todo a Fernando Claverino, quien se tomó el trabajo de redactar el resumen disponible en la Wiki del grupo, si quieren ahorrar una hora y media, que es lo que dura el video.

MVP otra vez

Martin Salias — Thu, 07 Jan 2010 13:34:00 +0000

Ya se me hizo costumbre, como sucede desde 2002, empezar el año con el mensaje de felicitación anunciando el premio MVP.

Como siempre, la sensación es de cierto orgullo y un poco de perplejidad porque no me parece que mi contribución sea tan grande, sobre todo comparándola con la de otros MVP alrededor del mundo a los que admiro.

Pero en fin, sigo en la musical categoría de C#, supongo que porque es el paraguas en el que agrupan a quienes estamos alrededor de otros lenguajes que no tienen aún su propia categoría (tal vez por ser aún más proyectos que productos completos).

Como todos los años, espero dedicarme principalmente a aprender más sobre otro lenguaje. La década pasada la dediqué con mayor o menor profundidad a Eiffel, C# mismo, ML, Boo (poco), Python (después de años de mis primeros contactos), el 2009 me concentré en F#, y este pienso dedicarlo seriamente a Ruby.

La decisión tiene que ver con dos hechos principales: uno es tener cerca un fanático de Ruby como Johnny Halife, y por otro lado el hecho de que la implementación de Ruby en .NET, IronRuby, haya llegado al RC1 (primer Release Candidate, lo que significa que está muy cerca de la versión final).

Por esto, sería de esperar (y aquí tomo un compromiso personal que espero poder cumplir) que este año publique unos cuantos post y de algunas charlas sobre Ruby (la versión multiplataforma, basada en C) y sobre IronRuby (la versión basada en el DLR), y la interoperabilidad entre ambas.