Mario Cornejo

Iniciando con jQuery

2012-01-27T09:10:00.001-08:00

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

2012-01-24T17:08:00.001-08:00

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?

2012-01-13T15:22:00.001-08:00

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.

Programando en laptop

2012-01-06T14:10:00.001-08:00

Llevo varios días trabajando exclusivamente desde la laptop, sin teclado ni monitor externo. Esto es principalmente porque el monitor externo ha estado fallando últimamente y porque he estado trabajando desde varios lugares de la casa.

Me ha gustado la experiencia de usar solo la laptop, lo limpio que se ve el escritorio sin los cables del monitor. Es fácil cerrar la laptop y moverme al sofá o incluso a la cocina. Además de que me estoy acostumbrando a trabajar con las limitaciones del teclado/mouse pero estoy aprovechando las ventajas de no tener que cargar con más equipo y poder trabajar desde donde sea. Ahora tecleo más lento pero no he visto que afecte el trabajo del día [soy desarrollador, no secretaria ;-)].

Algunos aspectos que he empezado a considerar tratando de decidir si debo comprar otro monitor o seguir trabajando solo con la laptop son:

Movilidad: Trabajando solo usando la laptop me permite trabajar desde cualquier parte (cualquier habitación de la casa, oficina, en una cafetería, etc.). Al trabajar con un monitor, teclado, mouse externo necesito conectar/desconectar cada que quiero moverme de lugar.

Comodidad: Es más cómodo trabajar con 2 monitores (sobre todo porque el monitor externo es grande) , con mouse y teclado externo. Sin embargo también es cómodo poder trabajar desde cualquier parte. Llegué a pensar que solo es cuestión de acostumbrarme; pero cuando trabajo varios días solo con la laptop aparece un dolor detrás del cuello que es muy molesto. Aunque supongo que hay maneras de evitarlo.

Económico: Es más barato no comprar monitor externo y trabajar directamente desde la laptop. También he considerado comprar una computadora de escritorio para trabajar en la oficina/casa y dejar la laptop para cosas personales o cuando requiera moverme, aunque para ese caso me sale más barato solo comprar el monitor externo y no toda la computadora.

Aun no he decidido que haré…

Teclado en español Latinoamérica

2011-12-30T11:15:00.001-08:00

Cuando empecé a utilizar computadoras lo hacia únicamente con teclados en ingles (EN-US) ya que al vivir en Tijuana (frontera con San Diego) era más fácil (y barato) conseguir teclados en ese idioma. Ademas todos los programas que utilizaba estaban en ingles. En esa época era común el uso de (alt+164) para las ´ñ’ y otros códigos más.

Como programador seguía con el teclado EN-US cuando trabajaba desde la “oficina” de la empresa. Como parte de un proyecto tuve que estar en sitio por varios meses en una empresa de la cuidad donde las estaciones de trabajo todas tenían teclados en español Latinoamérica. Durante algún tiempo batallé para acostumbrarme, sentía que odiaba los teclados en español. Recuerdo que un amigo en la universidad usaba un teclado en español en su casa y me llamaba la atención por qué alguien haría eso a propósito, pudiendo usar un teclado en ingles. Recuerdo, también, que me comentó lo fácil que era escribir la ‘ñ’, los acentos, signos de puntuación, etc. Ahí fue cuando empecé a ver la ventaja.

Tiempo después fue necesario reemplazar mi viejo equipo personal y al comprar una laptop en Tijuana, sin darme cuenta, venia con teclado en español. Como ya estaba acostumbrado al teclado, por el trabajo en sitio, fue fácil usarlo. Una vez que deje de trabajar en sitio seguí trabajando fuera de la oficina, ahora desde mi casa, y seguía utilizando teclado en español.

Después de un tiempo cambié de trabajo y en esta empresa nos daban a cada uno una laptop para trabajar en ella. La laptop tenia el teclado en ingles, todo estaba bien hasta que necesitaba escribir acentos o ‘ñ’ es decir texto en español. En esa época fue cuando empecé a utilizar el teclado en EN International Sort. El cual ayuda con el texto en español pero no es tan cómodo como el teclado en español sobre todo al escribir comillas, lo cual puede ser común al momento de programar.

En la actualidad cuando trabajo desde una computadora de escritorio utilizo un teclado en español (México) y cuando trabajo directamente desde la laptop lo utilizo en ingles (international sort) ya que mi laptop personal tiene teclado en ingles. Traté de comprarla en México para tener el teclado en español pero por el costo/beneficio la compré en US con teclado en ingles.

En estos años usando teclado en español no he notado que afecte mi productividad al programar, han habido detalles cuando compañeros de trabajo ingresan a mi maquina de manera local o remota y no pueden teclear; pero fuera de eso no afecta y a la vez siento que me facilita la escritura de texto en español cuando es necesario.

¡Ah olvidaba mencionar! Hace tiempo me toco usar teclado en español internacional y ese teclado definitivamente no me gustó. Será quizás que no estoy acostumbrado; pero lo sentí muy incomodo.

Nota: Esta entrada fue escrita desde un teclado en ingles (International sort).

Post relacionado: Software en español

Software en español

2011-12-29T22:13:00.001-08:00

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#

2011-12-23T10:40:00.001-08:00

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

2011-12-15T16:50:00.000-08:00

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í.

Dev3Cast (Podcast) sobre FubuMVC

2011-11-24T16:47:00.001-08:00

El pasado 12 de Noviembre participé en el podcast Dev3Cast. Donde junto con Gabriel Flores (@gabo) platicamos con Francisco Ruiz (@squidge) sobre FubuMVC. El cual es un proyecto de código abierto para el desarrollo de aplicaciones web que corre sobre .Net (es una alternativa a ASP.NET MVC).

Escucha el episodio y deja tus comentarios.

Mantenerse al día

2011-11-18T22:15:00.001-08:00

Cuando empece a programar, la forma en que aprendía era principalmente a través de libros; pero sobre todo con la ayuda que me proporcionaba el entorno de desarrollo. Buscaba ejemplos que mostraran como utilizar cierta función o ejemplos de como lograr lo que quería hacer.

Desde hace ya buen tiempo que no instalo la ayuda que viene con los entornos de desarrollo. Esto se debe, principalmente, a que es más rápido hacer una búsqueda en Internet sobre como funciona algo a buscar en la documentación que viene con los programas.

Esto también ha ido pasando con la forma en que aprendo a usar o hacer cosas nuevas. Aun sigue siendo un buen recurso el tener un libro sobre tecnología. sobre todo los que son sobre principios básicos; pero también es cierto que los libros que tratan sobre tecnologías especificas rápidamente quedan obsoletos.

Ahora para aprender sobre alguna tecnología (framework, lenguaje, librería, etc.) me ayuda el buscar información en Internet, generalmente es fácil encontrar la teoría sobre la cual esta fundada esa tecnología que quiero aprender. De ahí trato de buscar screencasts. En lo personal me ayuda mucho ver un screencast donde se vea la aplicación de esa tecnología. Para ver lo especifico y así tratar de aplicarlo en una practica.

Algo que me ayuda, también, a estar enterado de que es lo que se usa fuera de mi trabajo. Es el escuchar podcasts con regularidad. Aunque no todo lo que escucho lo trato de poner en practica, aun así me sirve para estar enterado de las opciones que hay disponibles. Y así cuando se presente una oportunidad, por lo menos sabré que preguntas hacer ya que conoceré un poco del tema. El leer blogs también ayuda -es muy incomodo tener discusiones con algún desarrollador por temas que hace años la comunidad ya resolvió-. Ademas de asistir a las reuniones de los grupos de usuarios locales y a eventos donde se pueda hablar en persona con quienes usan esa tecnología que quiero conocer.

Otra cosa que me ayuda es tratar de mantener este blog con contenido actual, eso me motiva a presentar buen contenido y por lo tanto a buscar aprender ese contenido que trataré de explicar.

Dev3Cast sobre Build

2011-10-29T21:58:00.002-07:00

El pasado 5 de octubre participé en un episodio de dev3cast (podcast) donde hablamos sobre lo que se presento en el evento build de Microsoft, en el cual se mostró lo que viene en la siguiente versión de windows y Visual Studio. Tuvimos como invitado especial a Seth Juarez, quien asistió al evento como parte de devexpress y pudo hacer varias entrevistas estando allá. También participamos en la conversación Gabriel Flores, Samuel Arellano y yo.

Dev3Cast sobre ASP.NET vNext

2011-10-27T15:52:00.001-07:00

El día de ayer participe en la grabación de un episodio del podcast de la comunidad de usuarios .net en Tijuana, dev3cast. Donde hablé, junto con Gabriel Flores y Samuel Arellano, sobre algunas de la características que vienen en la próxima versión de ASP.NET.

Rumbo a MagmaRails (parte 4)

2011-10-03T21:30:00.001-07:00

En la parte anterior de la serie, generé el modelo y controlador para los invitados, además de que modifiqué el archivo routes.rb para colocar a los invitados como recursos dentro de otros recursos:

resources :weddings do      
  resources :guests  
end

Esto hace que pueda tener una ruta como /weddings/{wedding_id}/guests/ para mostrar la lista de invitados según la boda que se pase a través del URL.

Para leer el valor de la boda dentro del controlador utilizamos la variable params la cual es como un diccionario. Así dentro de nuestro controlador de invitados podemos obtener el valor del ID de la boda de la siguiente forma:

def index    
  wedding_id = params[:wedding_id]
  @wedding = Wedding.find wedding_id
  @guests = @wedding.guests.all
end

La función del controlador es la de asignar valores a las variables que necesita la vista para mostrarse al usuario. En este caso estoy obteniendo el valor de wedding_id que viene dentro de los parámetros y lo estoy guardando en la variable wedding_id. después uso ese valor para obtener el objeto completo de la boda (usando el método de la clase Wedding). También obtengo la lista de invitados a través del objeto boda.

Una vez que asignamos los valores a variables, estos pueden ser usados por la vista para mostrarse al usuario.

ya he grabado antes screencasts donde se muestra algo de esto. En aquella ocasión usaba netbeans y una versión anterior de rails, pero los mismos conceptos aplican. Pueden verse aquí

Rumbo a MagmaRails (Parte 3)

2011-09-12T20:55:00.001-07:00

Sigo preparándome para asistir a MagmaRails, en este video genero el modelo y controlador para los invitados:

Post relacionados:
Parte 1
Parte 2

Rumbo a MagmaRails (parte 2)

2011-09-01T21:27:00.001-07:00

Siguiendo con la serie para prepararnos para MagmaRails. En esta ocasión trato de explicar en 5 minutos lo que se generó en la primera parte.

Aquí el video:

Entradas relacionadas:
- Rumbo a MagmaRails (Parte 1)
- Rumbo a MagmaRails (Parte 3)

Rumbo a MagmaRails

2011-08-30T21:59:00.001-07:00

El próximo 12 de octubre se realizará en Manzanillo la conferencia MagmaRails a la cual pretendo (junto con mi esposa) asistir. Nosotros trabajamos principalmente con tecnología .Net así que para practicar un poco de rails inicié un proyecto y estoy grabando algunas partes en screencasts de 5 minutos. Aquí el primero:

Entradas relacionadas:
- Rumbo a MagmaRails (Parte 2)
- Rumbo a MagmaRails (Parte 3)

Reunión 44 de Tijuana .Net Sobre Razor

2011-06-29T17:31:00.001-07:00

El día de hoy estaré presentando en la reunión 44 de la comunidad el tema de Razor. Hablaremos de la sintaxis de razor usando WebMatrix en webpages y después un ejemplo de un blog usando razor en asp.net mvc en Visual Studio.

Los temas serán:

Code blocks
Syntax, encoding
Code expresions
Html Helpers en razor
Layout
Sections
Html helper en C#
EditorTemplates
Partial Views
Html.Action

Esperamos grabar la presentación y mostrarla aquí y en la página del evento.

Adicción a la Refactorización

2011-06-17T22:40:00.001-07:00

Siempre que trabajo en una nueva característica, para algún proyecto, modifico el código antes de entregarlo. Tratando de hacerlo más compacto y/o fácil de leer. Esto con la intención de mejorar la calidad del código.

También cuando necesito modificar cierta funcionalidad existente, cambio el código antes de implementar los cambios. Con la intención de entender mejor la funcionalidad actual y así dejar todo listo para realizar los cambios que se requieren implementar. Una vez hechos los cambios vuelvo a buscar áreas donde haya oportunidad de refactorizar…hasta ahí creo que todo va bien. El problema viene cuando se convierte en una especie de adicción.

Hay ocasiones que al trabajar en alguna característica determinada me encuentro con algún trozo de código “malo” que no esta relacionado con lo que estoy trabajando y aun así siento la necesidad de modificarlo. A veces logro aguantarme las ganas; pero otras veces simplemente no puedo evitarlo. También me pasa cuando algún compañero de trabajo me pregunta algo especifico y al mostrarme el código quiero empezar a modificarlo, cuando ese no es el punto de la pregunta que me hicieron. Aunque estoy tratando de que el código sea mejor, puede convertirse en un problema.

A veces no se si lo hago por el proyecto o lo hago por mi. El código “malo” puede ser mucho, por lo tanto requiere algo de tiempo. Aunque hay herramientas que ayudan con la refactorización (ya sea como parte del IDE o como plugins), aun así es tiempo que le estoy quitando a tareas que el cliente espera y que están pendientes por realizar.

Estoy convencido de que La refactorización constante ayuda a la calidad del código, mantiene activo al proyecto, previene en cierta medida que el proyecto se vuelva legacy. Pero también debo aceptar que existe código que se puede mejorar y que esta bien (si funciona) dejarlo así como esta. Aunque sea difícil de vencer la tentación de mejorarlo. Es importante enfocarse en las tareas que le dan valor al usuario y en ocasiones la refactorización no da ese valor.

Como en todo lo demás: “Es bueno el uso; pero no el abuso”.

Motivación diaria

2011-06-15T12:22:00.001-07:00

Hay días en los que siento que soy productivo y tengo muchas ganas de programar. En cambio hay otros en los que simplemente no tengo ganas, estoy frente a la computadora, pero no logro avanzar en las tareas pendientes. Tratando de encontrar cuales son los factores que influyen para estar motivado y ser productivo, identifique los siguientes:

Conocer el dominio del problema: Cuando ya se lo que tengo que hacer es más rápido ponerme a hacerlo. Cuando no conozco el beneficio o la razón de una característica del sistema donde estoy trabajando, o peor cuando no se exactamente que es lo que se supone que debe de hacer, mi productividad baja. Cuando se lo que se requiere, simplemente lo hago.

Comunicación constante: Esto va ligado al primer punto, para conocer el dominio del problema es necesaria una comunicación constante con el cliente. Cuando tengo dudas y el cliente tarda mucho en contestarlas o simplemente no lo hace, en algunos de esos casos simplemente no puedo avanzar, me desmotiva y se me quitan las ganas de trabajar en eso. También la comunicación entre los miembros del equipo me ayuda a mantenerme enfocado en lo que se quiere lograr, no me aburro ni busco algo con que entretenerme en el internet.

Tareas cortas y bien definidas: Tener bien definidas las acciones concretas a realizar me permite concentrarme en esa acción, evitando la parálisis por análisis. Que las tareas sean cortas me ayuda a poder terminarlas en poco tiempo. Dándome una sensación de avance, la cual, me motiva a seguir avanzando en el proyecto.

Café: Hay días que lo más difícil es empezar. Una vez que inicio con las tareas, el resto no es tan difícil. Para iniciar con ganas un café por la mañana ha sido muy efectivo. Hay ocasiones (generalmente después de comer) que no tengo ganas de programar y lo único que pienso es en la hora de la salida. Para esos casos una bebida energética me “vuelve a la vida”, después ni cuenta me doy cuando ya es hora de irme.

Evitar interrupciones: Una vez que ya inicié a programar es fácil enracharse. El problema con las interrupciones es que me quitan esa viada que llevaba y necesito volver a empezar (que es lo más difícil). Las interrupciones pueden ser tanto internas (por mi mismo) o externas (alguien más me interrumpe). Para las externas no hay mucho que pueda hacer; pero para las internas he notado que el escuchar música me ayuda a concentrarme en lo que estoy, sin tratar de ver que dice la gente en las redes sociales o ver alguna foto graciosa.

Evitar estrés: Una mente tranquila produce más, que una mente casada o frustrada. Algunas veces el trabajo no es como quisiera, ya sea por decisiones de los managers, trabajar con sistemas legacy, “clientes especiales”, etcétera. Aunque me quejo seguido por cosas así, trato de que no me afecte al momento escribir código. Y si me pongo a pensar en esas cosas mejor me voy a caminar un rato, para que se me pase o para hablarlo con alguien más. Para evitar el estrés también ayuda estar bien con la familia, dormir bien… o no dormir .

Bueno… estos son algunos de los factores que he notado ayudan a mantenerme contento trabajando, motivado y productivo.

El ingles es parte de las mejores practicas

2011-06-02T21:06:00.002-07:00

Hace algunos años leí un comentario que no me gustó mucho. Decía algo como que todos los buenos desarrolladores sabían ingles. No me gustó, creo principalmente, porque mi primer idioma no es el ingles. Ademas conozco a personas que no hablan ingles y que son muy capaces de desarrollar. Me pareció un poco arrogante el comentario. Sin embargo en ese momento recuerdo que no pude pensar en algún programador que no hablara ingles; pero pensé que se debía a que vivo en la frontera con los Estados Unidos (Tijuana) y aquí la mayoría habla (o por lo menos entiende) ingles.

Ahora, después de ya algún tiempo, me ha tocado conocer a colegas desarrolladores que no dominan el ingles y he visto como sus opciones para buscar información, sobre cualquier tema técnico, se ve limitada comparada con la cantidad de información que se puede encontrar en ingles. Esto es más notorio cuando se trata de tecnología o técnicas nuevas (tendencias).

La mayoría de la información técnica es generada en ingles, incluso cuando para quien la genera el ingles no es su primera lengua. Esto puede causar que por la falta de información, sobre algo nuevo por ejemplo, se pierda competitividad frente a otros desarrolladores que sí dominan el ingles y pueden usar la información a su favor (más en estos tiempos donde google es una herramienta muy usada en el desarrollo).

El saber ingles ayuda a tener más opciones para resolver problemas y eso (en mi opinión) te hace un mejor desarrollador. Ademas los lenguajes de programación y las APIs estan en ingles, conociendo el ingles se puede leer, escribir... por lo tanto entender y mantener el código con mayor facilidad.

Hay varios esfuerzos para tener información disponible en español, ya que es nuestro idioma (creo que este blog es parte de ese esfuerzo). Aun así, si se desea conocer las mejores practicas y como aplicarlas, el ingles debe de estar en esa lista.

Dev3Cast Sobre Documentación Técnica

2011-05-06T22:19:00.001-07:00

El pasado cinco de mayo participé en un episodio de dev3cast junto con Eber Irigoyen, Haarón González, Samuel Arellano y Gabriel Flores. Donde hablamos sobre la documentación técnica en proyectos de software.

Pueden descargar el episodio y comentar en el sitio de dev3cast para que todos quienes descarguen el podcast puedan leer sus opiniones.

Aplicar lo nuevo lleva su tiempo

2011-03-21T22:18:00.001-07:00

Uno de los “problemas” que he encontrado al querer aplicar técnicas, usar librerías, frameworks, lenguajes, etcétera. De los que he leído e incluso usado en algún pet Project. Es que al momento de querer aplicarlo en algún proyecto real, este tienen fechas de entrega a muy corto plazo y por lo tanto lo más “seguro”, para cumplir con esas fechas de entrega, es haciéndolo utilizando lo ya conocido y probado en proyectos anteriores.

No es común que el cliente nos pida alguna aplicación y nos de el tiempo necesario para aprender la tecnología a usar. Primero porque desea el sistema lo más rápido posible y segundo porque no quiere cubrir el costo del tiempo invertido en aprender lo nuevo. Cuando al final el recibe el mismo sistema, no importando la tecnología o técnicas usadas en el desarrollo.

Pude ser que esta necesidad sea mas del desarrollador, ya que es él el que trabaja directamente con la tecnología (ya sea framework,lenguaje de programación, etc).

Para poder aplicar/implementar algo nuevo en un proyecto real requiere de un esfuerzo adicional al que se necesitaría para aplicar lo que ya se conoce. Todo, por fácil que sea, tiene su curva de aprendizaje, sus ventajas y sus desventajas y debes de haberte encontrado con algunas de ellas antes de poder usarlo en producción, para que así sepas como resolver lo posibles problemas que se presenten.

Pero entonces. ¿Como puedo aplicar o usar lo nuevo en los proyectos de mi trabajo, si nunca tengo el tiempo necesario? Algo que he tenido que hacer al querer aplicar algo nuevo en proyectos del trabajo es primero practicar por fuera en proyectos personales (a.k.a. pet projects) la tecnología/técnica que me interesa y en una oportunidad que se presente proponer el uso de tal tecnología o técnica. Esta propuesta procuro hacerla mostrando algo ya funcionando (un demo funcional), para convencer de las bondades que tiene utilizar lo nuevo.

Esto requiere dedicarle tiempo extra al trabajo, porque lo aprendido en pet projects lleva su tiempo aplicarlo en proyectos reales. Puede incluso llegar a ser frustrante tardar en realizar algo sencillo que usando lo que ya conocemos lo haríamos en minutos; pero a la larga es aun más frustrante (por lo menos para mi) el trabajar con técnicas/tecnologías viejas, con las que no puedo lograr lo que se que es posible realizar con algo nuevo.

De no dedicarle tiempo por mi cuenta a practicar lo que quiero usar, la decisión de usar algo diferente correría totalmente a cargo de alguien más, ya sea el cliente, jefe o algún programador más que hiciera la sugerencia. Para algunos eso no es problema, esperar que a el jefe/cliente se le ocurra intentar algo nuevo (a veces hasta que ya no es tan nuevo, incluso ya viejo); pero para mi conocer y no aplicarlo no es divertido.

Entonces: Si quiero usar algo nuevo tengo que proponerlo, lo mejor seria hacerlo mostrando avances donde puedan verse las ventajas. Esto requiere algunas veces dedicar algo de mi propio tiempo para aprender las nuevas tecnologías y así poder convencer a los clientes/jefes que estamos listos para usar la tecnología/técnica nueva, porque el cliente no quiere pagar la curva de aprendizaje.

La practica hace al maestro

2011-03-14T22:05:00.002-07:00

Hace unos días tuve la oportunidad de dar una capacitación (en el .Net Framework) a unos compañeros de trabajo que acaban de egresar de la universidad y que aun no tienen experiencia laboral. Algo común entre ellos era la falta de practica al momento de empezar a escribir código. Podían entender fácilmente el ejemplo escrito por mi, pero no les era igual de fácil escribir código propio.

Me di cuenta que algunos tomaban varias notas en papel sobre lo que íbamos haciendo, en lugar de ponerse a practicar. Esto me hizo pensar que el aprender (y mejorar) a programar debe de hacerse de la misma forma en la que se aprenden las matemáticas. No basta con saber los procedimientos para resolver un problema, es necesario practicar las operaciones con varios ejercicios para poder dominar el tema (y resolver los problemas mas rápido y fácil).

Cuando aprendemos a sumar, restar, multiplicar, dividir, etcétera. La parte de tomar notas es muy poca, la mayor parte del aprendizaje se da al practicar. Lo mismo pasa con la ortografía, no es solo conociendo las reglas, es con la practica constante como aprendemos a escribir mejor y cometer menos faltas de ortografía (como reconocer las palabras que llevan acento).

También se podría comparar con el aprender un segundo idioma, llega un momento en que puedes entenderlo casi perfectamente pero para poder hablarlo correctamente se necesita de practica, equivocarte constantemente hasta que puedas darte cuenta que algo no suena bien y busques una mejor forma de expresarlo. Y si dejas de practícar puede ser que algunas palabras se te olviden aunque no tuvieras ningún problema en entenderla si alguien mas la dice.

Considero para que un desarrollador profesional pueda seguir superándose es importante leer, ya sea blog posts, artículos, código de algún proyecto de código abierto, screencasts, podcasts, en fin… consumir y producir contenido técnico. Pero algo que ayuda mucho a ser un mejor desarrollador es la practica constante, escribir muchas líneas de código, cometer errores y aprender de ellos (echando a perder se aprende). Así que además de leer y tomar notas es necesario practicar constantemente, porque (ya lo dice el viejo y conocido refrán) “la practica hace al maestro”.

NuGet Manejador de paquetes

2011-03-12T12:50:00.001-08:00

Al trabajar en proyectos en .Net es común hacer uso de librerías de terceros, ya sean de código abierto e incluso de algunas con código propietario. Para usar estas librerías necesitaba ir al sitio de cada una de ellas y descargar la última versión (o la que necesitara) y descargar los archivos, después agregar una carpeta al nivel de mi archivo de solución de VisualStudio que acostumbraba llamarla “Lib” y ahí agregar los DLLs de terceros que usaría en mi solución.

Ahora con NuGet, el manejo de dependencias se simplifica. Lo primero que necesito es instalarlo, lo cual lo puedo hacer desde VisualStudio, usando el Extension Manager y buscando “NuGet”

En algunas maquinas con esto fue suficiente, sin embrago (desconozco la razón) en una de mis maquina no pude instalarlo a través del extension manager. Lo que hice fue instalarlo desde nuget.org

Una vez instalado se debe de reiniciar VisualStudio y aparece una nueva opción en el menú de Tools (Herramientas) y en el menú de View > Other Windows

Con esto se puede abrir la consola de NuGet (se necesita tener instalado PowerShell 2.0) y descargar e instalar desde ahí los paquetes (librerías) que se necesiten para el proyecto actual.

En un proyecto en particular necesitaba instalar MSpec, para eso solo ejecuté en la consola de NuGet:

PM> Install-Package Machine.Specifications

NuGet se encargó del resto: descargar dlls, agregar referencias, etc. El único ajuste que tuve que hacer en mi manera de trabajar es que nuget usa una carpeta llamada “packages” en lugar de “lib” como yo lo hacia. Pero es un pequeño cambio que bien vale la pena para aprovechar lo que hace NuGet por mi.

Al desarrollador le gusta desarrollar

2011-03-08T21:10:00.002-08:00

Seguido leo (y escribo) comentarios, tweets, posts, etc sobre lo mal que la pasamos en ciertos proyectos en los que trabajamos. Aun y cuando lo que nos gusta hacer, como desarrolladores que somos, es desarrollar. ¿Entonces por qué es que surgen estas situaciones de descontento entre los desarrolladores?

Considero que parte del problema es la falta de decisión que se tiene sobre el curso de algún proyecto, la arquitectura, metodología, framework, (peor cuando nos toca usar el intento de framework que hizo alguien más), etc. Esto hace que el desarrollador se sienta como un code monkey, alguien que hace la talacha y no como alguien que desarrolla soluciones para las necesidades del cliente. No hay motivación.

Al participar en proyectos con diferentes empresas he notado que en los proyectos que he sufrido mas frustración, al trabajar en ellos, es cuando el cliente ya eligió que usar y peor cuando ya eligió el como hacerlo. Al iniciar o continuar el desarrollo del proyecto me encuentro con que la decisión del cliente no fue la mejor, muchas veces basada en las viejas formas de hacer las cosas o basado en la tecnología que un tercero le vendió. Esto hace que haya cierta frustración en el desarrollo del proyecto porque estoy en problemas por culpa de alguien más.

Este descontento también aparece cuando no se entienden bien las necesidades del cliente. Ya sea porque se trata de un sistema ya establecido y solo se pide que se corrijan algunos errores. Y no se quiere perder tiempo en explicarle al equipo la importancia de lo que hace el sistema. Esto hace que el desarrollador no sienta el proyecto como suyo y por lo tanto no sienta motivación para mejorarlo.

En cambio cuando se trabaja en proyectos donde el cliente explica, no solo las necesidades sino también las razones por las cuales es importante. Incluso que nos explique porque eligió la posible solución y el como. De una manera en la que el equipo pueda aportar y mejorar esa idea. Es cuando se siente una mayor motivación para trabajar en ese proyecto.

Hace poco grabamos un episodio de Dev3Cast y ahí nos comentaba Iván González sobre la importancia de la confianza en el equipo. Y la importancia de la opinión de todos los desarrolladores, incluso de aquellos que aun no tienen experiencia.

Esto puede ayudar a que el desarrollador sienta el proyecto como suyo y este dispuesto a dar un poco más de esfuerzo con tal de que se logre un mejor resultado, mientras hace lo que le gusta. Los managers deben de tomar ventaja de que al desarrollador le gusta desarrollar.

La idea de nuestro propio “Framework”

2011-02-18T20:52:00.001-08:00

Creo que muchos de los desarrolladores hemos tenido la idea e incluso iniciado el desarrollo alguna vez de nuestro propio “Framework” para generar aplicaciones. No veo malo el escribir otro Framework. Pero muchas veces solo terminan limitándose, haciendo lo fácil mas fácil y lo difícil casi imposible, poco flexibles. Se vuelven una carga que mantener. Algo con lo que los desarrolladores no están muy entusiasmados en trabajar, porque prefieren usar algo nuevo.
He notado que esos pequeños Frameworks tienen algunas características en común (esta no es una receta, solo son unos de los problemas comunes que he visto en esos pequeños frameworks privados):
No se conocen los frameworks existentes: Lo más seguro es que ya exista algo que hace lo que se quiere lograr. Puede que se trate de un problema resuelto. Quizás lo mejor sea contribuir a un proyecto open source existente, agregando las características que se necesitan. Si la idea es hacer lo mismo que ya hace otro Framework, debe haber una razón más fuerte que el solo no tomarse la molestia de aprender a trabajar con los existentes.
No tienen un proyecto real donde usarlo: Sin una aplicación real donde probar los conceptos es difícil que se le atine a lo que realmente se necesita en un proyecto real. Puede tomarse en cuenta la experiencia de proyectos anteriores. Aun así creo que uno de los riesgos que se corre al no tener un proyecto donde probarlo es agregar características que no se necesitan u omitir las necesarias.
No son de código abierto (Open Source): Varios de estos pequeños frameworks son para uso exclusivo de quien lo desarrollo y a veces no quieren mostrarle el código a nadie fuera de la empresa, como si alguien les fuera a robar la idea y teniendo el secreto ya nadie necesitaría (contrataría) del autor del framework. Cuando en realidad es todo lo contrario, Al liberar el código de la librería/framework ayuda a que el código tenga mas ojos; y mas ojos pueden ayudar a que el proyecto sea mejor. Además de que es una buena oportunidad de que el autor se de a conocer en la comunidad (publicidad) y que la comunidad se beneficie de esto, ambas partes ganan, pero sobre todo código.
No conocen la teoría: Conocer la teoría para que la practica tenga mas sentido. Cuando el proyecto tiene buenas bases teóricas logra ser mas consistente en la manera como esta desarrollado y tanto la mantenebilidad, como su extensibilidad generalmente logran ser mayor.
Quieren abarcar mucho: El no tener un objetivo claro o un problema concreto el cual se quiere resolver termina generando una gran cantidad de código que nadie quiere usar.
El desarrollo de un framework es una buena actividad para ser un mejor desarrollador, es algo que se debe intentar (más si es en un proyecto open source). La innovación puede ocurrir. Si conociendo las soluciones existentes se cree necesitar una opción mas, pues adelante.

Comunicación con messenger en la oficina

2011-02-11T20:09:00.006-08:00

Ahora que volví a trabajar desde la oficina, con compañeros de trabajo (antes trabajaba desde mi casa) he notado que mucha de la comunicación entre los desarrolladores, incluso con la administración, se da a través del messenger e incluso por redes sociales como twitter y facebook (aunque por estas la comunicación es mas informal). Es algo que ya venia haciendo, pero pensé que era porque no estaba físicamente ahí con ellos.

Al principio no me gustaba tanto y prefería levantarme e ir al lugar de los demás. Empece a notar que era de los pocos que hacia eso y sentía que estaba distrayendo a la persona que con la estaba hablando y a los de su alrededor.

Ahora uso mas el messenger (mensajero en español) para hablar con mis compañeros (aunque estén a lado mio) y he notado que tiene algunos beneficios que explico a continuación.

Debido a que somos muchos personas trabajando en la oficina, es casi imposible que a todos nos guste la misma música; por eso el uso de audífonos es algo común. Esto hace que al escuchar música (con los audífonos) logres cierta concentración hacia la computadora. El problema con una interrupción en persona es que obliga a "desconectarse" para poder atenderla. En cambio si la interrupción es a través del mensajero; entonces se puede atrasar un poco, no "desconectarte" en ese momento y después atender el mensaje cuando se tenga oportunidad. Incluso aunque se atienda el mensaje de inmediato, el no tener que poner en pausa la música y quitarte los audífonos para responder, logra que se pierda menos la concentración de lo que se esta haciendo.

Esto me hace pensar que si toda la comunicación se da a través de medios electrónicos, entonces ¿por que no trabajamos todos desde nuestras casas? Con las herramientas actuales de comunicación fácil podríamos todos trabajar desde casa; pero el problema es que no todos pueden. Hay para quienes trabajar desde casa implica muchas distracciones en persona, o simplemente se distraen por otras cosas, etc.

Extraño los días en que todo el equipo trabajaba escuchando la misma música (o sin música), cuando no había necesidad de audífonos. Y hablábamos sin necesidad del mensajero, pero ahora veo las ventajas y me parece una buena idea, porque hay quienes en la oficina no lo usan para hablar entre ellos y distraen a los demás con sus discusiones técnicas.

Desarrollo Web Arrastrando y Soltando

2011-02-03T20:32:00.006-08:00

Hace unos días necesitaba realizar una aplicación web en muy poco tiempo. Debía mostrar un demo en un día; así que decidí olvidarme de las buenas practicas por un día y (usando ASP.NET WebForms) empezar a arrastrar y soltar componentes a mi página. Diseñando las paginas de captura y lectura (Grids) sin ver el markup que VisualStudio me iba generando.

Tenia mucho tiempo sin trabajar en Design View, pero no tenia tiempo de ponerme a editar el markup a mano. Una vez creadas las páginas (a la drag and drop) usando el ratón empece a conectar mis GridViews y DropDownsLists usando LinqDataSources. Todo esto con la ayuda de wizards, en algunas consultas utilice views definidas en la base de datos (MS SQL Server) también con la ayuda de diseñadores, no use SQL para definir mis views. (Creo que tenia años sin usar Views y menos de usar el query designer).

No pudieron faltar los lugares donde necesite algo de código y para ello LinqToSql me ayudo a realizar las consultas y/o actualizaciones a la base de datos. Como no tenia mucho tiempo y el código era poco opté por escribirlo directamente en los event handlers (button_click, etc). Donde el código crecía un poco entonces sí agregaba una clase para no tener métodos muy largos.

Al final el demo se pudo terminar en un día y la aplicación estaba lista para usarse en un semana. El haber podido entregar una aplicación en una semana me ha hecho reconsiderar mi opinión sobre el desarrollo web hecho arrastrando y soltando.

Se que el problema vendrá con el mantenimiento. Precisamente esta es una de las razones por las que deje de hacer desarrollo arrastrando y soltando; Pero el poco código que escribí es facil de mantener (al menos así lo veo ahora) y si despues necesito algo mas complejo podria refactorizarlo y apoyarme en pruebas unitarias para eso.

No se... me puso a pensar que tal vez si hubiera seguido las buenas practicas (TDD) quizas no hubiera terminado a tiempo y por lo tanto el proyecto se hubiera perdido.

Con esto no quiero decir que de ahora en adelante puro drag en drop (veremos como nos va con las nuevas features). Solo quise compartir mi experiencia en un proyecto pequeño y rápido del cual me sentí bien del código entregado y del poco tiempo que nos tomo hacerlo (Aunque fuera a la Drag and Drop) .

Editores para RubyOnRails en Windows

2011-01-07T15:13:00.008-08:00

Al trabajar con RubyOnRails desde Windows he usado algunos editores y IDE's con sus ventajas y desventajas cada uno de ellos.

El primero que utilicé fue Notepad++, porque ya lo tenia instalado en el sistema. Me gustó por lo ligero y rápido que responde el editor, pero lo que me hizo buscar opciones es que no coloreaba muy bien todos los archivos con los que trabajaba. Ademas de que no cuenta con un explorador del proyecto. Hay complementos para para tener una lista de carpetas, pero ninguna me gustó del todo.

La segunda herramienta que usé fue NetBeans. Ya había trabajado con NetBeans antes (desarrollando en java) así que no me fue difícil conocer el IDE. Me gustó trabajar con el IDE ya que estoy acostumbrado a usar uno en mi trabajo (trabajo con .Net en C# desde Visual Studio). Pero seguí buscando alternativas, ya que NetBeans es algo pesado y al buscar información, sobre como realizar ciertas tareas en rails, siempre encontraba ejemplos con la consola y simples editores. Al hacerlos en netbeans sentía como que hacia "trampa".

Intenté aptana pero estaba lentísimo en mi maquina, así que lo des-instale luego luego.

Buscando algo parecido a TextMate encontré E-Editor que según dicen es algo así como el textmate para windows; pero es de pago y actualmente no cobro por desarrollar en ruby. Por lo que seguí buscando una opción gratis.

Así fue como encontré intype un editor muy sencillo y bonito que cuenta con un project view (que es simplemente una carpeta raíz en una vista de árbol, no tiene un archivo con la definición del proyecto). Lo estuve usando por algún tiempo junto con la consola de comandos; pero a ratos sentía que tenia que escribir mucho, no te auto-completa nada...entonces seguí buscando.

Encontré Komodo, un editor sencillo que si te auto-completa algunas cosas y ademas puedes definir tus propias plantillas, funciona bien. Sin embargo nunca me terminó de gustar. Tiene algunos detalles como no poder abrir un archivo rápidamente con solo teclear parte del nombre y otras cosillas que hacían que no me gustara del todo. Lo usaba junto con la consola de comandos.

Y así después de intentar con algunos editor regresé a NetBeans, donde todo esta integrado, No necesito la consola para usar los generadores básicos, ni para la mayoría de los comandos de rake, ni para iniciar el servidor Web. Es por eso que por ahora mi editor (IDE) para trabajar en ruby on rails en windows es netbeans.

Siento que me sirvió el estar usando editores sencillos y usar la consola. Para conocer (practicar) a bien los comandos. Pero una vez que los conozco me gusta lo rápido que los uso desde NetBeans...obviamente esta opinión puede cambiar de un momento a otro sin previo aviso.

Aun me falta por intentar Vim...

Hablando sobre Certificaciones

2010-12-23T16:16:00.004-08:00

Hace tiempo participé en el podcast dev3cast donde hablamos sobre Certificaciones ¿para qué?

Instalar Ruby on Rails 3 en Windows

2010-12-10T11:57:00.007-08:00

He estado explicando en el trabajo los pasos para iniciar una aplicación con rails 3 en windows, así que pensé que seria buena idea escribir los pasos en un post:

A continuación muestro los pasos que sigo para instalar Ruby on Rails por primera vez en Windows.

Lo primero que necesitamos es instalar Ruby, lo podemos descargar desde rubyinstaller.org
Bajar el DLL de sqlite3 y copiarlo a la carpeta bin de la carpeta donde se instaló ruby
Instalar rails, para eso desde la consola de comandos podemos ejecutar "gem install rails". Esto bajará e instalará la última versión estable de Rails.
Ahora si podemos crear una nueva aplicación ejecutando en la consola: "rails new app_name" (donde app_name es el nombre de tu aplicación). Después nos cambiamos al directorio de la aplicación (cd app_name).
Para que la aplicación corra necesitamos instalar las gemas necesarias por nuestro proyecto, si vemos el archivo gemfile que esta en la raíz del proyecto nos damos cuenta de las gemas necesarias (sqlite3-ruby por ejemplo). Para eso podemos correr desde la consola "bundle install"; Lo que pasará es que se instalarán todas las gemas que necesita nuestra aplicación (según el gemfile).
Ahora podemos arrancar nuestro servidor web usando "rails server" (o simplemente "rails s")
Una vez que esta corriendo el servidor web podemos abrir una ventana de nuestro navegador e ir a la dirección "http://localhost:3000" y podremos ver nuestra aplicación corriendo.

Antes estaba usando NetBeans para realizar la mayoría de estas tareas, ahora prefiero hacerlo en la consola, de hecho como editor estoy usando intype (aun sigo pensando que netbeans es una buena opcion, sobre todo si vas empezando).

Permiso para hacer TDD

2010-10-07T21:15:00.003-07:00

Al estar en platicas/presentaciones sobre TDD (Test Driven Development) donde los participantes son gente que ya esta trabajando. La mayoría de los participantes coincide en que es una buena practica realizar el desarrollo guiado por pruebas. Sin embargo una pregunta que surge frecuentemente es ¿Como convenzo a mi jefe de hacer TDD?

Bueno para empezar no creo que un equipo de desarrollo deba pedir permiso para escribir mejor código, debería ser su obligación. Todos deberíamos de tratar de realizar cada vez un mejor trabajo. Mientras se entreguen resultados con calidad no debería de haber problema con los jefes.

Es claro que el realizar pruebas unitarias aumenta la cantidad de código escrito. Pero solo es eso, mas código y de mejor calidad. Si bien es cierto que eso implica mas tiempo (al principio), también es cierto que el tiempo invertido en el código de una prueba es menor al tiempo que se invierte en mantener el código después o en encontrar un bug que una prueba (y un mejor diseño) nos hubiera evitado. Al final estamos escribiendo mejor código que prácticamente ya esta probado. Y al realizar TDD frecuentemente el tiempo para realizar prueba e implementación mejora.

Entonces al realizar TDD pasa lo siguiente:

Mejora el diseño
Mejora el código, es mas fácil modificarlo después
Aumenta el numero de clases (código)

Ahora yo te pregunto ¿Necesitas convencer a tu jefe de que te deje escribir una clase?

Creo que la respuesta es no; así que solo hazlo. Escribe tus pruebas unitarias sin hacer una junta con tu jefe. Hazlo como parte del desarrollo normal del proyecto. Pero, si la respuesta es sí, es decir que necesitas convencer a tu jefe que te deje escribir una clase o un archivo con código entonces quizás tengas un problema mas grande.

Si tu estas convencido que es lo mejor, no esperes a convencer a otros para sentir que tienes la razón. Solo haz lo mejor.

Model View Presenter en ASP.NET WebForms

2010-09-30T15:40:00.001-07:00

En la reunión 37 de la comunidad Tijuana Net, realizada el pasado 29 de Septiembre en la Universidad Autónoma de Baja California. Hablé sobre el patrón MVP (Model View Presenter) en aplicaciones escritas usando ASP.NET WebForms.

Actualmente considero una mejor alternativa utilizar el framework ASP.NET MVC sobre WebForms sin embargo, por diversos motivos, muchos de nosotros aun tenemos que trabajar en aplicaciones escritas con WebForms. Es por ello que me pareció buena idea presentar como aplicar este patrón y así quienes aun trabajamos en WebForms podamos obtener algunas de las ventajas de separación de intereses y capacidad de pruebas que brinda MVC.

En la presentación inicie una aplicación WebForms de manera “tradicional” después la modifiqué para poder aplicar el patrón MVP y así tener la posibilidad de realizar pruebas unitarias al código que antes estaba en el code behind. En la segunda parte de la presentación modifiqué una vez mas el código de la aplicación para poder tener una estructura de clases reutilizable, además de utilizar un contenedor de dependencias.

Abajo pueden ver la presentación y el material que se utilizó. Agradezco sus comentarios que puedan ayudar a mejorar siguientes presentaciones. De igual forma si tienen alguna duda sobre la presentación no duden en hacérmela llegar a través de los comentarios del blog.

Agradezco también a todos los asistentes su presencia y participación durante la reunión. Y claro a la comunidad Tijuana Net y a su líder Gabriel Flores por hacer posible estas reuniones.

Screencast

Your browser cannot play this video. Learn how to fix this.

Fotos

Proyecto de ejemplo

Reuniones previas mencionadas (para ver los screencasts):
Test Driven Development
IoC containers

Eduardo Ramón Cornejo Portillo

2010-07-26T11:31:00.001-07:00

Mi hijo Eduardo Ramón nació el 24 de Julio del 2010 a las 5:41 am. Le gusta dormir de día y estar despierto en la noche.
Peso 3.3 Kg y midió 0.52 m al nacer.

Su hermana, mamá y papá estamos muy contentos.

Iniciando con RubyOnRails Parte 5 – Instalando Cucumber

2010-07-19T16:27:00.001-07:00

En este screencast muestro como instalé cucumber usando NetBeans. Además instalé un plugin para NetBeans y así ejecutar las features desde el IDE

Iniciando con RubyOnRails Parte 4

2010-07-06T17:12:00.001-07:00

Sigo con la aplicación en RubyOnRails sobre NetBeans, en esta ocasión en el screencast escribí la implementación de algunos de los métodos del guestscontroller

Iniciando con RubyOnRails Parte 3

2010-06-29T10:57:00.002-07:00

Aprovechando un poco de tiempo libre que tenia agregué algo de validación a la aplicación “Traje”, agregue el modelo y empecé el controlador para registrar invitados a las reuniones. El screencast dura 7 minutos aproximadamente

Iniciando con RubyOnRails Parte 2

2010-06-28T14:12:00.001-07:00

Sigo aprendiendo RubyOnRails, en este screencast veo como agregar un campo a mi modelo, generando una migración. También veo como usar vistas parciales para reutilizar partes en las vistas.

Iniciando Con RubyOnRails

2010-06-24T23:02:00.001-07:00

Hace tiempo que querido aprender RubyOnRails y por una cosa o la otra siempre lo posponía. Hace poco inicio la comunidad de Ruby en Tijuana lo cual me ha inspirado a aprender RubyOnRails aprovechando que puedo tener el apoyo y ayuda de la comunidad mientras aprendo.

Acá entre nos, una de las razones por las que no iniciaba con ruby era que pensaba comprarme una Mac. He visto que la mayoría de los desarrolladores de ruby es lo que usan. Pero realmente no la necesito y además tomando en cuenta que próximamente seré papá nuevamente :-), ese es un gasto que tendrá que esperar. Sin embargo puedo aprender sobre RubyOnRails desde Windows.

He decidido grabar lo que voy aprendiendo, en videos cortos de no mas de 10 minutos, para que así alguien que también se quiera animar quizás pueda ayudarse de mi experiencia. De igual forma alguien que tenga experiencia y vea lo que estoy haciendo pueda orientarme a través de los comentarios del blog, lo cual agradeceré.

Para iniciar instalé ruby, rails y sqlite3 sobre Windows usando la información de esta página. Intente con varios editores pero al final no encontré ninguno que me convenciera, además estoy muy acostumbrado a usar un IDE; así que por lo pronto iniciaré la aplicación usando NetBeans (Ruby Bundle).

La aplicación que intentaré realizar es un sitio donde pueda organizar “Reuniones de Traje”. Son reuniones donde cada uno de los asistentes trae algo para la reunión, el traje se refiere al verbo traer y no a la vestimenta (ej. “yo traje botana”) .

Iniciando con la aplicación (screencast de 7 minutos y fracción)

MEF Parte 4 - Imports

2010-05-24T20:43:00.001-07:00

Usando el mismo ejemplo de la aplicación “Saludador” (Iniciada en el Lanzamiento de VisualStudio 2010 en Tijuana) en el siguiente video muestro otras opciones al momento de importar partes de nuestro objeto usando MEF. En concreto ImportingConstructor y AllowDefault.

Entradas Relacionadas:
Introducción a MEF Parte 1
Introducción a MEF Parte 2
Introducción a MEF Parte 3 - Recomposición

Introducción a MEF Parte 3 - Recomposición

2010-05-22T16:50:00.001-07:00

Continuando con la aplicación de ejemplo sobre MEF, en esta ocasión muestro el concepto de recomposición de MEF. El cual permite cargar componentes de forma dinámica mientras nuestra aplicación corre.

Algo a notar con este ejemplo fue que lo realice utilizando la librería de MEF que se encuentra en codeplex, usando VisualStudio 2008 con el .Net Framework 3.5. En lugar de utilizar VS2010 con el .Net 4.0 como lo había venido haciendo. Por ahora el código es el mismo para ambas versiones del framework.

Como siempre mi meta es que estos videos (screencasts) no pasen de 5 min, por lo tanto si fui muy rápido, me falto algo o me equivoque, les agradeceré sus comentarios.

También se puede ver el video desde screencast.com

Post Relacionados:
Introducción a MEF Parte 1
Introducción a MEF Parte 2

Como usar Unity IoC Container en ASP.NET MVC

2010-05-21T21:54:00.002-07:00

Una de las ventajas sobre la plataforma ASP.NET MVC sobre WebForms es que podemos utilizar el principio de inversión de control usando la inyección de dependencias (generalmente a través de los constructores). De tal forma que nuestros controladores reciben parámetros en los constructores. Esto hace que la plataforma MVC no pueda, por si sola (usando el DefaultControllerFactory), construir nuestros controladores usando el constructor que recibe parámetros. Es por ello que vemos ejemplos (como el proyecto plantilla de VisualStudio) donde se sobre carga el constructor con uno que no recibe parámetros y es el propio controlador el encargado de crear sus dependencias. Lo cual va en contra del principio de inversión de control.

Resolver este problema es muy sencillo, basta con crear nuestro propio IControllerFactory que es el contrato que utiliza la plataforma MVC para construir los controladores. En este ejemplo nuestro controller factory hará uso de Unity un Contenedor de dependencias (IoC container) para administrar las dependencias.

La forma mas sencilla de crear un IControllerFactory es heredar del DefaultControllerFactory y redefinir el método GetControllerInstance. Aquí muestro el código:

public class UnityControllerFactory: DefaultControllerFactory
{
    readonly IUnityContainer container;

    public UnityControllerFactory(IUnityContainer container)
    {
        this.container = container;
    }

    protected override IController GetControllerInstance(
        RequestContext requestContext, Type controllerType)
    {
        if (controllerType == null )
            return null;

        return (IController)container.Resolve(controllerType);            
    }
}

Como puede verse el UnityControllerFactory recibe un contenedor con las dependencias registradas, el cual utiliza para crear los controladores en el método GetControllerInstance. No hace falta registrar los controladores en el contenedor ya que Unity puede construir instancias de tipos no registrados.

Una vez creado nuestro controller factory es necesario indicarle a MVC (en concreto al ControllerBuilder) que utilice nuestro UnityControllerFactory para crear los controladores; el código queda algo así:

var container = new UnityContainer();
//aqui se registran las dependencias
ControllerBuilder.Current.SetControllerFactory(
new UnityControllerFactory(container));

Esto se debe ejecutar al iniciar la aplicación (el Application_Start() en el Global.asax.cs).

Como puede verse con muy poco código podemos estar usando un IoC container en nuestra aplicación ASP.NET MVC, no es complicado y el UnityControllerFactory puede reutilizarse en otras aplicaciones MVC. Así que, ya lo saben, no hay pretexto para no utilizar un contenedor de dependencias.

Singleton por cada HTTP Request usando Unity IoC

2010-05-20T16:07:00.002-07:00

Hay ocasiones en las que necesitamos tener un objeto compartido por varios objetos en nuestra aplicacion web, similar al patrón singleton, pero solo para esa petición HTTP. Es decir sin compartirlo en toda la aplicación.

Hace tiempo escribí sobre como compartir un LinqToSql DataContext por cada request en una aplicación web. Ahora utilizando Unity podemos lograr ese comportamiento y dejar que el contenedor de dependencias se encargue de darnos la instancia adecuada.

Para manejar el tiempo de vida de las instancias unity utiliza lo que llama LifetimeManager, entonces lo primero que debemos hacer es crear nuestro LifetimeManager, en este caso lo llamaré HttpRequestLifetimeManager y heredamos de la clase abstracta Microsoft.Practices.Unity.LifetimeManager y debemos de definir 3 metodos GetValue, RemoveValue y SetValue.

public class HttpRequestLifetimeManager: LifetimeManager
{                                                       
   object key;                                          
                                                        
   public HttpRequestLifetimeManager(): this(null)      
   {                                                    
   }                                                    
                                                        
   public HttpRequestLifetimeManager(object key)        
   {                                                    
       this.key = key;                                  
   }                                                    
                                                        
   public override object GetValue()                    
   {                                                    
       if (key == null) return null;                    
       return HttpContext.Current.Items[key];           
   }                                                    
                                                        
   public override void RemoveValue()                   
   {                                                    
                                                        
   }                                                    
                                                        
   public override void SetValue(object newValue)       
   {                                                    
       if (key == null)                                 
           key = newValue.GetType();                    
                                                        
       HttpContext.Current.Items[key] = newValue;       
   }                                                    
}

Lo que hace el HttpRequestLifetimeManager es guardar la instancia de la clase en el Items dictionary con el key que se le especifique en el constructor, si no se ha especificado un key, entonces utilizará el tipo del objeto para identificarlo en el diccionario.

Una vez teniendo nuestro LifetimeManager solo es cuestión de especificarle a unitity, al momento de registrar nuestro tipo, que utilice nuestro HttpRequestLifetimeManager para manejar el tiempo de vida de nuestra instancia.

Por ejemplo supongamos que tenemos declarados algunas clases (posiblemente repositorios) que recibe el constructor un DataContext algo como esto:

public class UserRepository : IUserRepository       
{                                                   
   readonly MyDataContext db;                       
                                                    
   public UserRepository(MyDataContext db)          
   {                                                
       this.db = db;                                
   }                                                
...

Si queremos que todos nuestros repositorios compartan el mismo MyDataContext por cada request, entonces configuramos nuestro contenedor (generalmente en el Global.asx.cs) de la siguiente manera:

var container = new UnityContainer();                             
                                                                  
container.RegisterType<IAccountRepository, AccountRepository>();  
container.RegisterType<IUserRepository, UserRepository>();        
                                                                  
container.RegisterType<MyDataContext>(                            
   new HttpRequestLifetimeManager(), new InjectionConstructor());

Ahí podemos ver como al registrar MyDataContext paso una instancia de la clase HttpRequestLifetimeManager para usar la misma instancia durante todo el request y además le paso un instancia de InjectionConstructor para indicarle que utilice el constructor sin argumentos de nuestra clase MyDataContext.

Una vez hecho esto nuestro contenedor se encargará de entregarnos repositorios que comparten el mismo datacontext por cada request.

Introducción a MEF Parte 2

2010-04-15T12:58:00.001-07:00

Siguiendo con el ejemplo del post anterior sobre MEF (La aplicación para consola “Saludador” que presente en el Launch de Visual Studio 2010 en Tijuana). En este screencast muestro como usar MEF para que alguien que no tiene acceso al código fuente de la aplicación, pueda extenderla (plugins) y agregar sus propios saludos.

Debido a que los videos solo los quiero realizar de 5 min, tuve que irme (quizás) un poco rápido. Como siempre cualquier comentario es bienvenido.

Post relacionado: Introducción a MEF Parte 1

Código Fuente:

Introducción a MEF Parte 1

2010-04-13T20:06:00.001-07:00

En el pasado Launch de Visual Studio 2010 en Tijuana presenté el tema: Extendiendo Aplicaciones con MEF. Debido a que olvide grabar la presentación, quise rehacer el ejemplo dividiéndolo en screencasts de no mas 5 min. Usando el mismo ejemplo que en la sesión. Espero sirva como introducción para quienes quieran conocer sobre MEF (Managed Extensibility Framework).

El ejemplo trata de una aplicación para consola que tiene una lista de saludos, el usuario puede seleccionar el saludo que guste y ejecutarlo. La idea es que el saludador pueda ser extendido, de tal forma que yo (como desarrollador de la aplicación) o cualquier tercero pueda agregar saludos a la aplicación.

En este primer video, muestro el funcionamiento básico de MEF (Importar, Exportar y Componer).

Post Relacionado: Introducción a MEF Parte 2

Singleton con Unity

2010-03-30T18:42:00.004-07:00

En la pasada reunión de la comunidad TJ.Net presenté el tema IoC, donde mostré un ejemplo usando el contenedor de dependencias Unity. Una de las preguntas de los asistentes fue sobre si unity siempre crea nuevas instancias para los tipos registrados y como podría indicarle que utilice siempre la misma (lo que se conoce como el patrón singleton). Al momento de la reunión conteste que por omisión Unity crea una nueva instancia cada que resuelve un tipo, pero que sí era posible indicar un comportamiento distinto, sin embargo no recordé la manera exacta para ello. Bueno pues aquí la respuesta.

Al registrar un tipo con el método registerType<TFrom, TTo> podemos pasarle un LifetimeManager el cual será encargado de manejar el tiempo de vida de las instancias resueltas por el contenedor. Podríamos crear nuestro propio LifetimeManager, pero (para el caso del patrón singleton) unity ya cuenta con uno del tipo ContainerControlledLifetimeManager.

Así que lo único que necesitamos para que nuestro contenedor implemente el patrón singleton al momento de resolver nuestro tipo es pasarle una instancia de la clase ContainerControlledLifetimeManager. Utilizando el mismo ejemplo de la reunión, podríamos suponer que necesitamos que nuestro INotificationService sea siempre la misma instancia para todos los componentes que requieran usarlo. Entonces el código donde registramos nuestro tipo quedaría así:

container.RegisterType<INotificationService, NotificationServiceWithTemplates>(
 new ContainerControlledLifetimeManager());

Con esto logramos el patrón singleton con unity.

Inversión de Control - IoC

2010-03-25T22:00:00.000-07:00

El día de ayer (Miércoles 24 de Marzo 2010) fue la Reunión 33 de la comunidad TJ.NET donde presenté el tema “Inversión de control (IoC)”. La reunión se llevo a cabo en las instalaciones del Instituto Tecnológico de Tijuana.

En la reunión presenté una introducción a lo que se refiere el principio IoC; con ejemplos como: el usar eventos en nuestros componentes para la interfaz de usuario y el utilizar un Contenedor de dependencias (IoC Container) para realizar una Inversión de control aplicando el patrón de diseño “Inyección de dependencias”. Como ejemplo se refactorizó una aplicación Web ASP.NET para usar un IoC Container (Unity en este caso). La presentación que fue grabada y el material (diapositivas y archivos) pueden ser descargados desde la página del evento en la comunidad.

Fotos

Presentación y archivos

Iniciando con MongoDB desde .Net

2010-02-11T20:45:00.003-08:00

En el post anterior mostré como iniciar con mongoDB utilizando las herramientas que obtenemos al descargar la base de datos. Ahora quiero mostrar las mismas operaciones pero desde .Net (específicamente C#). Para esto es necesario descargar el driver para hablar con mongo desde .net

Para abrir la conexión a la base de datos debo crear una instancia de la clase MongoDB.Driver.Mongo, llamar el método Connect y después hacer un getDB con el nombre de la base de datos a la que quiero conectarme. Tomando el ejemplo anterior de la libreta de direcciones, el código queda así:

var mongo = new Mongo();
mongo.Connect();
var db = mongo.getDB("AddressBook");

una vez conectado a la base de datos obtengo una referencia a mi colección de documentos llamada “Contacts” (similar al concepto de tabla en una base de datos relacional).

var contacts = db.GetCollection("Contacts");

Ahora para insertar documentos creamos instancias de la clase MongoDB.Driver.Document (el cual es básicamente un diccionario de datos), le damos valores y lo insertamos a nuestra colección de contactos; como en el post anterior inserto 2 documentos a nuestra colección:

var mario = new Document();
mario["Name"] = "Mario";
mario["Phone"] = "1234567";
contacts.Insert(mario);

contacts.Insert(new Document()
  .Append("Name", "Humberto")
  .Append("Phone", "5555555")
);

Puede observarse dos formas de crear documentos. Una vez teniendo dos contactos (Mario y Humberto). Voy a actualizar al contacto con el nombre “Mario”. Aprovechando que estoy usando una base de datos no relacional, cambiaré las campos del documento, para ello utilizo el método Update de la colección contacts pasando como primer parámetro el nuevo documento y como segundo parámetro un documento que me sirve como selector

contacts.Update(
  new Document()
      .Append("FirstName", "Mario")
      .Append("LastName", "Cornejo")
      .Append("Phone", "1234567")
  , new Document()
      .Append("Name", "Mario")       
);

Para hacer solo la actualización del campo teléfono del contacto con el nombre “Humberto” puedo hacer lo siguiente:

var humberto = contacts.FindOne(new Document().Append("Name", "Humberto"));
humberto["Phone"] = "4444444";
contacts.Update(humberto);

Aquí utilice el mismo método Update, pero solo le pase como parámetro el documento actualizado. Como se puede ver, la forma de realizar las operaciones desde C# es muy similar a como lo haríamos desde la consola usando la aplicación Mongo.exe

Iniciando con MongoDB

2010-02-03T23:31:00.001-08:00

Recientemente he empezado a jugar con la base de datos no relacional MongoDB, grabe un mini-screencast donde muestro la características básicas de esta base de datos orientada a documentos.

También puedes ver el video directamente desde www.screencast.com

Compartir DataContext por cada HTTP Request

2009-12-21T17:30:00.001-08:00

Trabajando en proyectos donde, por petición especifica del cliente, debo usar LinqToSql para mi acceso a datos. Donde además se me ha pedido usar las entidades generadas por LinqToSql como mis entidades de negocio. Al abstraer mi acceso a datos con repositorios, Esto con la finalidad de poder hacer pruebas unitarias en mi capa de servicios, me encontré con la necesidad de compartir el DataContext a través de mis repositorios, en si lo que necesitaba era tener un solo DataContext por cada petición HTTP.
Para ello mis repositorios reciben en el constructor un IDataContextFactory la cual será la encargada de pasarle el datacontext a los repositorios

public interface IDataContextFactory<T> where T: DataContext, new()
{                                                                  
    T GetCurrentDataContext();                                     
    void DisposeCurrentDataContext();                              
}

Así mis repositorios no necesitan saber de donde viene el datacontext. Aquí esta la implementación de esta interfaz para tener un datacontext por request

public class WebDataContextFactory<T>: IDataContextFactory<T> where T : DataContext, new()
{                                                                                         
    public T GetCurrentDataContext()                                                      
    {                                                                                     
        var dataContext = HttpContext.Current.Items[typeof(T)] as T;                      
        if (dataContext == null)                                                          
        {                                                                                 
            dataContext = new T();                                                        
            HttpContext.Current.Items[typeof(T)] = dataContext;                           
        }                                                                                 
                                                                                          
        return dataContext;                                                               
    }                                                                                     
                                                                                          
    public void DisposeCurrentDataContext()                                               
    {                                                                                     
        var dataContext = HttpContext.Current.Items[typeof(T)] as T;                      
        if (dataContext != null)                                                          
            dataContext.Dispose();                                                        
    }                                                                                     
}

lo que hago es guardar el datacontext dentro del diccionario Items del actual HttpContext, el cual esta vivo solo para ese request y se puede utilizar el evento request end del HttpAplication para hacer dispose del datacontext a través del IDataContextFactory

TDD con Fluent Validation Parte 2

2009-12-01T18:53:00.001-08:00

En el post anterior (screencast) mostré como escribir las pruebas para un validador que usa la librería FluentValidation, debido a que se me acababan los 5 minutos, solo mostré las pruebas. en esta ocasión muestro como escribir el código para satisfacer dichas pruebas, el cual es muy simple. el screencast dura solo 2 minutos

aquí el link para verlo desde jing

TDD con Fluent Validation

2009-11-21T17:31:00.001-08:00

En este mini-screencast (5 min) muestro como escribir las pruebas unitarias para un validador que será escrito utilizando la librearía FluentValidation

Para ver el video desde el sitio de jing haz clic aquí

Munq - Inversión de Control para ASP.NET MVC

2009-10-27T11:03:00.001-08:00

Buscando un contenedor de inversión de control (IoC Container en ingles) ligero para utilizar en una aplicación ASP.NET MVC me encontré con Munq el cual esta escrito a partir del código de Funq. Me pareció muy fácil de configurar así que grabe un pequeño screencast (4 min), usando jing, en el cual muestro como configurarlo para usarlo con la aplicación que crea la platilla de nuevo proyecto ASP.NET MVC 1 en Visual Studio.

Para ver directamente desde el sitio de jing haz clic aquí.

TDD ¿Por qué escribir primero las pruebas?

2009-10-21T23:23:00.001-07:00

Hace poco leí el blog post de Eber Irigoyen donde escribe sobre duct tape programming. Lo que me llamo la atención en ese post es que Eber mencionó que al escribir pruebas, estas no las hace antes de escribir el código necesario para que las pruebas pasen e incluso menciona que la idea de escribir la prueba primero la considera algo tonta (no son sus palabras exactas pero es la idea). En lo personal la idea de escribir la prueba antes del código lo considero como una buena practica y no pensaría que es algo tonto.

Muchas de las veces cuando se me solicita realizar un nuevo programa o agregar funcionalidad a uno ya existente primero se realiza una entrevista con el usuario final, analista de negocio o cliente (de ahora en adelante lo llamaré cliente) que solicita la funcionalidad. Para que ahí explique a detalle que es lo que necesita. En ocasiones al cliente se le dificulta expresar que es lo que realmente necesita y eso se debe en gran parte porque el tampoco esta seguro que es lo que realmente necesita.

He notado que esto sucede principalmente cuando el cliente, al empezar a explicar el problema y lo que desea lograr con la nueva funcionalidad, esta pensando en la solución que le ayudará a resolver su problema. Inicia explicando como es que ve su solución en lugar de explicar el problema o lo que quiere lograr con ello. En ocasiones se empieza a discutir la implementación de esa solución y que problemas pudiéramos encontrar, después se discute como es que se podría ayudar a resolver esos problemas. Así la discusión puede continuar centrándose en como resolver los problemas de una posible solución que pudiera o no ser la ideal.

Si el desarrollo se centra en hacer que la posible solución funcione, se corre el riesgo que al terminar el desarrollo, esta no cumpla con las expectativas del cliente, ya que lo que se tomo en cuenta para desarrollarla fue la posible solución en lugar de lograr que el problema inicial del cliente se resolviera. Esto hace que el cliente se de cuenta que la solución no le sirve del todo pero el desarrollador siente que cumplió porque hizo que funcionara lo que le pidieron.

Cuando el cliente se centra primero en explicar el problema y en especificar lo que espera lograr, en lugar de pensar en la posible solución. Es entonces cuando yo como profesional puedo trabajar en un programa que resuelva su problema y logre lo que él espera.

Del mismo modo cuando el desarrollador inicia escribiendo el código que resuelva un problema sin especificar antes que es lo que quiere lograr con ello. Es posible que termine escribiendo código que no va a necesitar. Esto es porque se centra en escribir una solución robusta en lugar de solo resolver el problema.

Por eso que pienso que el escribir lo que esperamos del código, como una prueba unitaria, antes de escribir la implementación nos da la ventaja de centrarnos en lo que realmente es importante: cumplir con al expectativa. Y no tanto en hacer que nuestra posible solución funcione. De igual forma ayuda a no escribir código que posiblemente no se necesite, ya que la prioridad es hacer que la prueba unitaria (especificación) pase.

Considero que es benéfico que al iniciar el desarrollo de nueva funcionalidad primero se especifiquen las expectativas que se tienen sobre ella y después se evalúe en base a esas especificaciones. Las expectativas se escriben usando pruebas unitarias y es por eso que me gusta que las pruebas se escriban primero.

El desarrollo guidado por pruebas o TDD (Test Driven Development) no solo se trata de las pruebas. TDD es una tarea de diseño.

VB XML Literals – Parte 3 LinqToXml

2009-10-09T19:27:00.001-07:00

Siguiendo con la serie de post sobre VB XML Literals en esta ocasión en lugar de copiar y pegar el código utilicé Jing para grabar un screencast de 5 minutos donde explico como buscar dentro de un archivo xml usando LinqToXml en VB XML Literals

Ver screencast desde el sitio Jing

Post Relacionados
VB XML Literals Parte 2
VB XML Literals Parte 1

VB XML Literals - Parte 2

2009-10-05T21:31:00.002-07:00

En la parte 1 de esta serie de posts sobre XML Literals expliqué en el ejemplo como cargar un objeto a partir de un archivo xml. Ahora veré el caso contrario: A partir de un objeto Order creare un archivo xml con la información de la orden. Este es el test con que comprobaré que mi método esta funcionando:

[TestMethod]
public void should_save_order_to_file()
{
   var fileName = @"..\..\Order_Temp.xml";

   if (File.Exists(fileName)) File.Delete(fileName);

   var order = CreateSampleOrder();

   var orderXmlTasks = new OrderXmlTasks();
   orderXmlTasks.SaveToFile(fileName, order);

   File.Exists(fileName).Should().Be.True();
  
   var fileLines = File.ReadAllLines(fileName);
   var expectedLines = CreateExpectedXml();
   for (int i = 0; i < fileLines.Length; i++)
   {
       var line = fileLines[i].Trim();
       line.Should().Be.EqualTo(expectedLines[i]);
   }
}

public Order CreateSampleOrder()
{
   return new Order
   {
       Id = 321,
       Customer = "Peter Griffin",
       Items = new List<OrderItem>
       {
           new OrderItem { ProductId = 3, Quantity = 1, Price = 2.05m, Description = "product x" },
           new OrderItem { ProductId = 7, Quantity = 4, Price = 3.45m, Description = "product y" },
           new OrderItem { ProductId = 8, Quantity = 9, Price = 5.50m, Description = "product z" },
       }
   };
}

public string[] CreateExpectedXml()
{
   var xml = new List<string>();
  
   xml.Add("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
   xml.Add("<order id=\"321\" xmlns=\"urn:schemas-developeando-com:xmlLiterals\">");
   xml.Add("<customer>Peter Griffin</customer>");
   xml.Add("<items>");
   xml.Add("<item productId=\"3\" quantity=\"1\" price=\"2.05\">product x</item>");
   xml.Add("<item productId=\"7\" quantity=\"4\" price=\"3.45\">product y</item>");
   xml.Add("<item productId=\"8\" quantity=\"9\" price=\"5.50\">product z</item>");
   xml.Add("</items>");
   xml.Add("</order>");

   return xml.ToArray();
}

Lo que hace el test es crear una orden de ejemplo (CreateSampleOrder), escribir los datos de la orden en un archivo xml y después leo el archivo generado y lo comparo con el xml esperado (CreateExpectedXml)

Generar xml usando XML Literals es tan simple como solo escribir el XML y agregar expresiones donde queremos insertar código. Entonces el código para que la prueba pase queda así:

Public Sub SaveToFile(ByVal FileName As String, ByVal Order As Order)
   Dim xml = <order id=<%= Order.Id %>>
                 <customer><%= Order.Customer %></customer>
                 <items>
                     <%= From item In Order.Items _
                         Select <item
                                    productId=<%= item.ProductId %>
                                     quantity=<%= item.Quantity %>
                                     price=<%= item.Price %>>
                                    <%= item.Description %>
                                 </item> %>
                  </items>
             </order>
   xml.Save(FileName)
End Sub

Como se puede apreciar solo declaro una variable y le asigno el xml, usando expresiones para indicar donde quiero escribir los valores de las propiedades del objeto Order. Para los items utilizo una expresión LINQ para indicar que por cada item agregue un elemento <item> y asigno el valor a los atributos y el valor de la descripción en el texto interno.

VB XML Literals

2009-09-29T18:42:00.011-07:00

Desde la versión 9.0 de VB .Net existe una característica llamada XML Literals la cual consiste en poder escribir XML directamente en el código VB y manejar el xml como parte del lenguaje.

Actualmente cuando en una solución necesito trabajar con XML, donde generalmente hay puros proyectos de C#, también agrego un proyecto en VB.Net solo para el manejo de XML por que se me facilita con XML Literals.

Para mostrar como se utiliza XML Literals mostraré un ejemplo (el clásico ejemplo de una orden) el cual consiste en una clase que exporta e importa ordenes a/desde XML.

Para esto creo una solución con 3 proyectos uno de tipo C# Windows library con el nombre XmlLiteralsExample.Domain el cual contiene las clases Order y OrderItem con esta definición

namespace XmlLiteralsExample.Domain
{
 public class Order
 {
     public int Id { get; set; }
     public string Customer { get; set; }
     public List<OrderItem> Items { get; set; }

     public Order()
     {
         Items = new List<OrderItem>();
     }
 }

 public class OrderItem
 {
     public int ProductId { get; set; }
     public int Quantity { get; set; }
     public string Description { get; set; }
     public decimal Price { get; set; }
 }
}

Ahora agrego el proyecto de tipo VB Class library llamado XmlLiteralsExample.Tasks en el cual agregaré la clase en VB que me ayudará con el XML

Imports XmlLiteralsExample.Domain

Public Class OrderXmlTasks
 Public Function ReadFromFile(ByVal FileName As String) As Order
     Throw New NotImplementedException()
 End Function

 Public Sub SaveToFile(ByVal FileName As String)
     Throw New NotImplementedException()
 End Sub

 Public Function FindOrderItem(ByVal FileName As String, _
                               ByVal ProductId As Integer) As OrderItem

     Throw New NotImplementedException()
 End Function

End Class

Y por último agrego un proyecto para las pruebas unitarias en C# llamado XmlLiteralsExample.Tasks.Test en el cual agregaré las pruebas unitarias para nuestra clase OrderXmlTasks y un archivo xml para las pruebas.

El proyecto XmlLiteralsExample.Test tiene referencias al proyecto Domain así como el proyecto XmlLiteralsExample.Tasks.Test tiene referencias a los otros 2 proyectos de la solución

Además el proyecto de prueba incluye una referencia a las extensiones SharpTestsEx

El Archivo Order.xml contiene una orden de prueba

<?xml version="1.0" encoding="utf-8" ?>
<order id="123" xmlns="urn:schemas-developeando-com:xmlLiterals">
<customer>Homer Simpson</customer>
<items>
 <item productID="1" quantity="2" price="1.50">product desc 1</item>
 <item productID="2" quantity="4" price="2.60">product desc 2</item>
 <item productID="3" quantity="6" price="3.80">product desc 3</item>
</items>
</order>

A partir del archivo de prueba (Order.xml) genero el xml schema utilizando la opción del menú XML de VisualStudio y la guardo en el folder del proyecto Tasks y después agrego el archivo al proyecto. Con esto puedo importar el xml namespace en el archivo OrderXmlTasks.vb como si fuera un namespace de .net

Imports <xmlns="urn:schemas-developeando-com:xmlLiterals">

Esto me ayudará a que visual studio conozca la estructura de mi xml y así pueda darme opciones a través de intellisense

Ahora que tengo los datos de prueba iniciamos con con la funcionalidad, para ello escribo mi primer test en la clase OrderXmlTasksTest (dentro del proyecto de prueba)

[TestMethod]
public void should_load_order_from_file()
{
 var orderXmlTasks = new OrderXmlTasks();
 var order = orderXmlTasks.ReadFromFile(@"C:\..\..\Order.xml");

 order.Id.Should().Be.EqualTo(123);
 order.Customer.Should().Be.EqualTo("Homer Simpson");
 order.Items.Count.Should().Be.EqualTo(3);         
}

Ahora el código para pasar esta prueba:

Public Function ReadFromFile(ByVal FileName As String) As Order
 Dim orderXml = XElement.Load(FileName)

 Dim order = New Order()
 With order
     .Id = orderXml.@id
        .Customer = orderXml.<customer>.Value         
 End With

 For Each itemXml In orderXml.<items>.<item>         
     Dim item = New OrderItem()
     With item
         .ProductId = itemXml.@productID
            .Quantity = itemXml.@quantity
            .Price = itemXml.@price
            .Description = itemXml.Value
     End With
     order.Items.Add(item)
 Next

 Return order
End Function

Ahora explico un poco lo que hace el código; la primer línea carga el xml a un objeto. En este ejemplo uso la clase XElement la cual carga el xml a partir del elemento raíz (en este caso la etiqueta Order). Por lo tanto el objeto orderXml me representa la etiqueta Order del archivo xml. Después creo un objeto order que después lleno con los datos del archivo xml cargados en el objeto orderXml.

En XML Literals para accesar a los atributos de un elemento xml utilizamos la @ es por eso que podemos ver que de carga en la propiedad Id, del objeto order, el valor del atributo id del elemento order del xml. Después se puede notar que para tener acceso a los elementos hijos solo hace falta escribir las etiquetas tal y como lo haríamos en un archivo xml y gracias a que importe el namespace xml también tengo intellisense

de igual forma en una ciclo for each acceso a la colección de items. En este caso acceso al elemento item a través de toda la ruta de elementos hijos.

Pero además XML literals me permite accesar a elementos hijos sin tener que seguir la ruta usando tres puntos entre el objeto y la etiqueta.

Para obtener al texto dentro de una etiqueta se utiliza la propiedad Value del objeto XElement. Así es como obtengo el nombre del cliente y la descripción de los ítems.

Bueno este post ya se extendió y tengo que dividirlo, seguiré con el ejemplo en otro post.

Sharp Tests Ex

2009-09-17T20:21:00.007-07:00

Descargue las extensiones para MsTests desarrolladas por Fabio Maulo: "Sharp Tests Extensions". La idea de estas extensiones es que tus aserciones en las pruebas sean escritas con mayor fluidez. ademas de que es mas clara la distinción entre el valor esperado y el valor obtenido. Evitando el uso de la clase Assert directamente.

Un ejemplo de como cambia un test usando estas extensiones

Test usando MsTest sin extensiones

[TestMethod]
public void should_change_password()
{
var username = "username";
var originalPassword = "original";
var newPassword = "newPassword";

var user = new User { Password = originalPassword };

mockRepository.Setup(r => r.GetUser(username))
    .Returns(user);

bool result = accountService.ChangePassword(
     username, originalPassword, newPassword);

Assert.IsTrue(result);
Assert.AreEqual(newPassword, user.Password);     
mockRepository.Verify(r => r.Save());
}

ahora esta es la misma prueba utilizando Sharp TextsEx

[TestMethod]
public void should_change_password()
{
var username = "username";
var originalPassword = "original";
var newPassword = "newPassword";

var user = new User { Password = originalPassword };

mockRepository.Setup(r => r.GetUser(username))
    .Returns(user);

bool result = accountService.ChangePassword(
     username, originalPassword, newPassword);

result.Should().Be.True();
user.Password.Should().Be.EqualTo(newPassword);
mockRepository.Verify(r => r.Save());
}

estas son las lineas que cambian de:

Assert.IsTrue(result);
Assert.AreEqual(newPassword, user.Password);

result.Should().Be.True();
user.Password.Should().Be.EqualTo(newPassword);

Se escribe mas sin embargo queda mas descriptivo cual es la intensión de la prueba ademas de que tenemos la ventaja que intellisense nos ayuda a completar la aserción.

En lo personal me cuesta un poco acostumbrarme a no ver la clase Assert al final de los metodos, pero debo reconocer que el test es mas claro así.

TDD - Desarrollo Guiado Por Pruebas

2009-07-28T19:06:00.002-07:00

En la reunión 30 de la comunidad TjNet estaré presentando el tema TDD (Test Driven Development), el cual es una práctica de programación que consiste en escribir primero las pruebas unitarias, después el código que cumple con las pruebas y refactorizar el código escrito.

La idea principal es que el comportamiento esperado del objeto que estamos probando lo definamos en pruebas y después nos preocupemos por que el objeto cumpla con lo que se definió en las pruebas.

Cabe aclarar que el TDD es una actividad del equipo de desarrollo y no del equipo de QA que realiza las pruebas al software. La intención de las pruebas unitarias no es que el equipo de calidad las use para realizar su trabajo. Las pruebas unitarias son para definir el comportamiento del código que vamos escribir, es decir es parte del diseño. Aunque sí aumentan en cierta forma la calidad del código escrito.

Efectos del desarrollo guiado por pruebas

Algunos de los efectos notables sobre el desarrollo guiado por pruebas es que se evita escribir código que no se utilizará. Ya que se trata de realizar solamente el código necesario para poder satisfacer las pruebas definidas.

Otro efecto que se obtiene al trabajar de esta manera es que como nuestras clases ya no solo van a ser utilizadas por la aplicación, sino también por el código de prueba, esto nos obliga a tener clases débilmente acopladas y que hacen uso de dependencias solo a través de interfaces, independientemente de la implementación. De tal forma que sea fácil utilizar ciertas clases concretas para la aplicación y otras para las pruebas. Para esto es común aplicar el principio de inyección de dependencias.

El mantenimiento del código es más manejable, la confianza en el código mejora, por que las pruebas nos sirven como alerta cuando introducimos código que hace que nuestras pruebas fallen. En lugar de introducir cambios al código sin saber cómo afectan a otras clases del sistema.

El uso del depurador disminuye ya que cuando existe un error en el código es más fácil encontrarlo en las pruebas que corriendo la aplicación en modo debug.

Ciclo de desarrollo

1. Escribir el comportamiento deseado (requerimiento) a manera de prueba unitaria, Este paso fuerza al programador a tomar la perspectiva de un cliente considerando el código a través de sus interfaces. Obviamente la prueba fallará ya que aun no está escrito el código para satisfacerla.

2. Escribir solo el código necesario para que la prueba pase.

3. Correr las pruebas para confirmar que efectivamente el código escrito cumple con los establecido por las pruebas.

4. Refactorizar el código, para eliminar código duplicado y dejarlo de tal forma que sea fácil hacerle modificaciones en el futuro.

5. Verifica que las pruebas no fallen después de la refactorización.

Conclusión

El desarrollo guiado por pruebas no es parte del proceso de calidad de un sistema en desarrollo (aunque si aumenta la calidad del código escrito) sino que forma parte del diseño de cada clase; define el comportamiento esperado de la clase desde el punto de vista del cliente que la usará.

Los espero en la reunión 30 de la comunidad TjNet.

Agile Programming Coffee Camp

2009-06-17T09:33:00.008-07:00

Tijuana Agile Programming Coffee Camp en el devolada de otay (el lugar de costumbre) el sábado 4 de Julio, a partir de las 9:00am.

La idea surgió de una conversación en twitter entre @mario_chavez y @fcastellanos a la que nos sumamos @gabo y yo. Y como 140 caracteres no es suficiente y varios queremos participar; pues mejor platiquemos sobre el tema tomando café.

Cualquiera puede participar, es una platica entre colegas, el costo es según el tamaño del café que pidas.

Si conoces del tema asiste a compartir tus experiencias, y si no, es una buena oportunidad para aprender.

Mas información (mapas, fotos y Dilbert) en:
TjNet
blog de Mario Chavez
blog de Fernando Castellanos

ASP.NET MVC Routing Validations

2009-05-30T12:18:00.011-07:00

Ayer asistí a la reunión de la comunidad TjNet fue la presentación sobre ASP.Net MVC que dieron Mario Chavez y Fernando Castellanos. Hubo pocos asistentes sin embargo hubo varias preguntas interesantes, incluso falto tiempo para seguir con las preguntas.

Algo que se preguntó ahí en la reunión fue: ¿Como restringir el routing en ASP.NET MVC con expresiones regulares? Mencioné que si se podía pero en ese momento no me acorde como hacerlo ;), bueno pues aquí muestro un ejemplo.

Una vez creado un nuevo proyecto de asp.net mvc desde visual studio, voy a agregar dos métodos al HomeController

public ActionResult WelcomeByName(string name)
{
ViewData["Message"] = "Bienvenido, tu nombre es: " + name;
return View("Index");
}

public ActionResult WelcomeById(int id)
{
ViewData["Message"] = "Welcome, your user ID is " + id;
return View("Index");
}

mi idea es que si el usuario pone la dirección /Welcome/{cadena}
se ejecutará el metodo WelcomeByName (mensaje en español) y si el usuario escribe /Welcome/{entero} se ejecutará el metodo WelcomeById (mensaje en ingles).

Para ello debo de agregar entradas a mi tabla de rutas que se crea en el archivo Global.asax

routes.MapRoute(
"Welcome int",
"Welcome/{id}",
new { controller = "Home", action = "WelcomeById" },
new { id = @"^\d+$" }
);

routes.MapRoute(
"Welcome s",
"Welcome/{name}",
new { controller = "Home", action = "WelcomeByName", name = "anonimo" }
);

Estas dos entradas las puse antes de la entrada "Default". La primera ruta indica que espera una dirección con la forma "Welcome/{id}" para ejecutar la acción WelcomeById del HomeController, pero ademas agrega una restricción (usando expresiones regulares) que indica que solo se usara esta ruta si el parámetro "id" es entero positivo (o cero). Entonces si el valor de id no cumple con la condición no se usará esa ruta y se buscará otra para ser utilizada.

La segunda ruta es similar a la primera solo que no tiene restricción alguna, por lo tanto si es entero el valor se ejecuta la primera, para las demás (que inicien con "Welcome") se ejecuta la segunda.

Corro la aplicación y escribo la dirección en el navegador y compruebo que las rutas funcionen

Pueden encontrar mas información sobre esto en la grabación de la VAN de Alt.Net Hispano. Sobre ASP.NET MVC Avanzado explicada por Hadi Hariri.

ASP.NET MVC MyTwitter (Parte 2)

2009-04-29T20:34:00.008-07:00

Como parte de la serie sobre el desarrollo de una aplicación similar a Twitter para aprender ASP.NET MVC. Voy a seguir con la parte de registro (Signup). Esta semana he estado ocupado con trabajo, por eso agregaré poca funcionalidad en este post, la cual consiste en que una vez que el usuario se registre debemos de iniciar sesión con ese usuario, es decir identificarlo como un usuario Autentificado.

Para ello es necesario escribir una clase (y una Interfaz) que me ayude en esta funcionalidad, para después hacer un mock de ella en el test del AccountController.

namespace MyTwitter.Models
{
public interface IFormsAuthenticationTasks
{
  void SetAuthCookie(string username, bool createPersistentCookie);
  void SignOut();
}
}

using System.Web.Security;
namespace MyTwitter.Models
{
public class FormsAuthenticationTasks 
   : MyTwitter.Models.IFormsAuthenticationTasks
{
  public void SetAuthCookie(string username, 
      bool createPersistentCookie)
  {
      FormsAuthentication.SetAuthCookie(
                   username, createPersistentCookie);
  }

  public void SignOut()
  {
      FormsAuthentication.SignOut();
  }
}
}

agrego una variable de tipo IFormsAuthenticationTasks al AccountController y al constructor usado para las pruebas

public class AccountController : Controller
{
  private IUserRepository userRepository;
  private IFormsAuthenticationTasks formsAuthenticationTasks;

  public AccountController(IUserRepository userRepository,
        IFormsAuthenticationTasks formsAuthenticationTasks)
  {
      this.userRepository = userRepository ?? new UserRepository();
      this.formsAuthenticationTasks =
            formsAuthenticationTasks ?? new FormsAuthenticationTasks();
  }

  public AccountController()
      : this(null, null)
  {
  }
...

escribo el test para la nueva funcionalidad

[TestMethod]
public void Login_User_After_Signup()
{
formsAuthenticationMock.Setup(
 fa => fa.SetAuthCookie(It.IsAny<string>(), It.IsAny<bool>()));
controller.Signup(null);
formsAuthenticationMock.VerifyAll();
}

implemento la funcionalidad en el método Signup del Account Controller para que la prueba pase, es solo agregar una línea antes del redirect

[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Signup(FormCollection formValues)
{
var user = new User();
UpdateModel(user);
userRepository.Add(user);
userRepository.Save();

formsAuthenticationTasks.SetAuthCookie(user.Username, true);

return Redirect("/invitations");
}

Hasta aquí con esta parte. Estuve tentado a llamarla “Parte 1.5” en lugar de “Parte 2”, por el poco contenido, pero se iba a empezar a complicar la numeración, continuaré con la serie en siguientes posts.

ASP.NET MVC MyTwitter (Parte 1)

2009-04-24T11:31:00.001-07:00

En la parte 0 de esta serie sobre ASP MVC MyTwitter hice la base de datos (la cual cambie un poco desde el pasado post) para iniciar el desarrollo de la aplicación. Ahora voy a generar el modelo de datos (LINQ to SQL classes) para eso en el folder de Models agrego el modelo de datos.

Le doy clic con el botón derecho en el folder de Models y le hago clic en “Add/New Item” y selecciono “LINQ to SQL Classes” y le pongo el nombre MyTwitter.dbml

Arrastro desde el server explorer las tabla de la base de datos al modelo de datos, para que mi modelo quede así.

Cambie el nombre de la tabla UserFriends por Friends y la columna Friend por FriendName. Esto fue con el propósito de que quedaran con mejor nombre las clases generadas por LinqToSql.

Ahora empiezo con la pagina de inicio, esta seria solo un formulario para iniciar sesión y un link para registrarse si es que no se tiene una cuenta. Para ello abro la página Views/Home/Index.aspx y escribo el la forma en el HTML

<form action="/account/login" method="post">
       <fieldset>
           <p>
               <label for="username">Usuario</label>
               <%= Html.TextBox("username") %>
                <%= Html.ValidationMessage("username", "*") %>               
           </p>
           <p>
               <label for="password">Contrase&ntilde;a</label>
               <%= Html.Password("password") %>
                <%= Html.ValidationMessage("password", "*") %>
            </p>
           <p>
               <input type="submit" value="Ingresar" />
           </p>
           <p>Si no tienes una cuenta registrate <a href="/signup">aqui</a>.</p>
       </fieldset>
   </form>

De igual manera también modifico la prueba unitaria que viene por omisión en nuestro proyecto de test (MyTwitter.Tests) dentro del archivo HomeControllerTest.cs.

[TestMethod]
public void Index()
{           
  HomeController controller = new HomeController();        
  var result = controller.Index();
  Assert.IsNotNull(result);
}

Solo pruebo que el método Index() del HomeController regrese un View que no sea null.

Para realizar el registro de usuario voy a agregar un controller llamado AccountController, similar al que venia por default al crear al proyecto.

Hago clic en el folder Controllers y selecciono la opción “add controller”. y le pongo el nombre de “AccountController”.

Esto me agrega una nueva clase AccountController que hereda de la clase Controller con un método llamado Index. por el momento elimino el método Index, ya que todavía no lo voy a usar (casi no me gusta tener código que no hace nada) y agrego un método llamado Signup().

namespace MyTwitter.Controllers
{
   public class AccountController : Controller
   {
       public ActionResult Signup()
       {
           throw new NotImplementedException();
       }
   }
}

Ahora el unit test

En el folder Controllers del proyecto MyTwitter.Tests selecciono “Add > New Test..” y selecciono “Unit Test” y le doy el nombre de AccountControllerTest. Esto me agrega una clase con código de ejemplo.

Quito el código que genera para quedar con una prueba sencilla que verifica que se regrese un view para realizar el registro.

[TestMethod]
public void Return_A_View_For_Signup()
{           
   var result = controller.Signup();
   Assert.IsNotNull(result);
}

Implemento el método de Signup en el AccountController, este simplemente (como el test lo indica) regresará el view necesario para que el usuario ingrese sus datos de registro

public ActionResult Signup()
{
    return View();
}

Para agregar el View abro el menú contextual sobre el método Signup y selecciono “Add View”

Aparece un dialogo para agregar un view. aquí habilito la opción “Create a strongly-typed view” y selecciono (en “View data class:”) la clase MyTwitter.Models.User, En “View content” selecciono la opción Create. Esto para que VisualStudio escriba la mayoría del HTML por mi. Esto agrega un archivo (Views\Account\Signup.aspx) , lo abre en el editor y lo modifico para que quede en español.

El view queda así:

<% using (Html.BeginForm()) {%>

        <fieldset>
           <legend>Fields</legend>
           <p>
               <label for="Username">Usuario:</label>
               <%= Html.TextBox("Username") %>
                <%= Html.ValidationMessage("Username", "*") %>
            </p>
           <p>
               <label for="FullName">Nombre Completo:</label>
               <%= Html.TextBox("FullName") %>
                <%= Html.ValidationMessage("FullName", "*") %>
            </p>
           <p>
               <label for="Password">Contraseña:</label>
               <%= Html.Password("Password") %>
                <%= Html.ValidationMessage("Password", "*") %>
            </p>
           <p>
               <label for="ConfirmPassword">Confirmar Contraseña:</label>
               <%= Html.Password("ConfirmPassword") %>
                <%= Html.ValidationMessage("ConfirmPassword", "*") %>
            </p>
           <p>
               <label for="Email">Correo Electronico:</label>
               <%= Html.TextBox("Email") %>
                <%= Html.ValidationMessage("Email", "*") %>
            </p>
           <p>
               <label for="Url">Sitio Web:</label>
               <%= Html.TextBox("Url") %>
                <%= Html.ValidationMessage("Url", "*") %>
            </p>
           <p>
               <label for="Bio">Biografia:</label>
               <%= Html.TextBox("Bio") %>
                <%= Html.ValidationMessage("Bio", "*") %>
            </p>
           <p>
               <label for="Location">Ubicacion:</label>
               <%= Html.TextBox("Location") %>
                <%= Html.ValidationMessage("Location", "*") %>
            </p>
           <p>
               <input type="submit" value="Create" />
           </p>
       </fieldset>

   <% } %>

Las funciones de la clase Html me ayuda a no tener que escribir todo el HTML a pie (o mejor dicho a mano), no explicare como funcionan (creo que el nombre de cada método describe bien lo que hace) basta decir que escriben HTML. Uso Html.BeginForm sin parámetros en lugar de escribir el HTML para un <form> y así el action es al mismo url actual pero con el method=”post”. en este caso seria equivalente a escribir <form action=”/signup” method=”post”> y al cerrar el using (<% } %>) se escribe el </form>.

Ahora voy a implementar el código que se ejecutará cuando el usuario haga submit a esta forma, para esto creo un nuevo método en el AccountController llamando también Signup la diferencia con el otro son los parámetros que recibe (en este caso los valores de la forma) y un atributo para que solo reciba peticiones de tipo POST.

[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Signup(FormCollection formValues)
{
   throw new NotImplementedException();
}

Antes de implementar la función quiero escribir un test para probar que el método Signup trate de guardar la información en la base de datos, pero sin hacer una llamada real a la base de datos, para esto voy a crear una clase UserReposotory que será la que se encargue de cargar los datos. También voy a crear una Interfaz para poder hacer un mock del repository. Esta clase e interfaz las pongo dentro del folder Models cada una en su propio archivo.

namespace MyTwitter.Models
{
   public interface IUserRepository
   {
       void Add(User user);
       User GetUser(string username);
       void Save();
   }
}

namespace MyTwitter.Models
{
   public class UserRepository : IUserRepository
   {
       private MyTwitterDataContext db;

       public UserRepository()
       {
           db = new MyTwitterDataContext();
       }

       public User GetUser(string username)
       {
           return db.Users.FirstOrDefault(u => u.Username == username);
       }

       public void Add(User user)
       {
           db.Users.InsertOnSubmit(user);
       }

       public void Save()
       {
           db.SubmitChanges();
       }
   }
}

Ahora sí, ya puedo empezar a escribir mi prueba en AccountControllerTest. Para no tener que hacer uso de la base de datos en las pruebas unitarias utilizo Moq, el cual es un mock framework que se puede descargar aquí.

Una vez descargado moq, agrego una reference al moq.dll en el proyecto MyTwitter.Tests y agrego el using Moq; en el AccountControllerTest.cs. Con la ayuda de este framework vamos probar que el AccountController llame el metodo Add y Save del UserRepository.

Para no repetir la inicialización del repositoryMock y del controller, voy a agregarlos como variables de clase e inicializarlos en un método SetUp

[TestClass]
public class AccountControllerTest
{
   private AccountController controller;
   private Mock<IUserRepository> repositoryMock;
  
   [TestInitialize]
   public void Setup()
   {
       repositoryMock = new Mock<IUserRepository>();
       controller = new AccountController(repositoryMock.Object);
   }
   ...

Ahora agrego los métodos de prueba

[TestMethod]
public void Add_And_Save_User_To_Repository()
{           
   repositoryMock.Setup(r => r.Add(It.IsAny<User>()));
   repositoryMock.Setup(r => r.Save());        

   controller.Signup(new FormCollection());

   repositoryMock.VerifyAll();
}

Además voy a agregar un test para probar que, una vez que se realice el registro del usuario, se envíe al usario a la pagina “/invitations” para que ahí el usuario pueda agregar amigos (friends) a quien seguir.

[TestMethod]
public void Redirect_To_Invitations_After_Signup()
{                       
   var result = controller.Signup(new FormCollection()) as RedirectResult;

   Assert.AreEqual("/invitations", result.Url);
}

Si corro el test ahora fallará porque no lo he implementado, entonces ahora lo que debo de hacer es que el test pase. Para ello declaro un IUserRepository en la clase AccountController y 2 constructores, uno que usare en el código en producción y el otro para las pruebas.

public class AccountController : Controller
{
   private IUserRepository userRepository;

   public AccountController(IUserRepository userRepository)
   {
       this.userRepository = userRepository ?? new UserRepository();
   }

   public AccountController()
       : this(null)
   {
   }
   ...

ahora si, por fin implemento el método Signup en el AccountController

[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Signup(FormCollection formValues)
{
   var user = new User();
   UpdateModel(user);
   userRepository.Add(user);
   userRepository.Save();

   return Redirect("/invitations");
}

[tanto blog post para este método tan sencillo :) ]

Ejecuto las pruebas unitarias y verifico que el código hace lo que se supone debe hacer.

Si ejecuto la aplicación y en la pagina de inicio hago clic en el enlace para registrase me manda a “/signup” y me marca error por que no encuentra el recurso. Para que al buscar el recurso /signup se ejecute el action Signup del AccountController, debo de agregar un Route en el archivo Global.asax ( lo agrego antes del Route “Default”).

public class MvcApplication : System.Web.HttpApplication
{
   public static void RegisterRoutes(RouteCollection routes)
   {
       routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

       routes.MapRoute(
           "Signup",
           "signup",
           new { controller = "Account", action = "Signup" });

       routes.MapRoute(
           "Default",                                              
           "{controller}/{action}/{id}",                           
           new { controller = "Home", action = "Index", id = "" }  
       );           

   }

   protected void Application_Start()
   {
       RegisterRoutes(RouteTable.Routes);
   }

con esto ya puedo hacer una pequeña prueba de integración.En la siguiente parte continuare con el desarrollo de esta aplicación.

ASP.NET MVC MyTwitter (Parte 0)

2009-04-22T15:27:00.001-07:00

Para aprender acerca de ASP.NET MVC voy a realizar una aplicación de prueba que sería la versión en español de twitter (con esta aplicación solo pretendo aprender, no pretendo competir con twitter) que llamaré MyTwitter. Este post lo he titulado parte 0 de la serie por que solo escribiré el setup de la aplicación y a partir de la parte 1 empezare (ahora si) con el desarrollo.

Antes de iniciar debo instalar el ASP MVC Framework, el cual se puede descargar aquí.

Una vez que instalé el MVC Framework puedo crear un nuevo proyecto en visual studio (no es un Web Site, sino un project).

Después selecciono la plantilla de ASP.NET MVC Web Application y le doy el nombre de MyTwitter

Una vez hecho esto aparece una ventana que me pregunta si quiero un proyecto para las pruebas unitarias. Seleccione la opción de “Yes”. Esto creará una aplicación con 2 controllers (Home y Account). Adema incluye algunas pruebas unitarias para el proyecto de ejemplo. Para este ejemplo voy a quitar el AccountController (y su respectivo test) para crear uno propio.

Ahora voy a crear la base de datos. Haciendo clic con el botón derecho en el folder App_Data. Esa opción aparece si se le da con el botón derecho en cualquier parte del proyecto pero me gusta hacerlo sobre el App_Data folder por que así me aparecen los ítems filtrados.

Selecciono SQL Server Database y le doy el nombre de MyTwitter.mdf. Una vez hecho esto me aparece la nueva base de datos bajo el folder de App_Data Dandole doble clic, me agrega una nueva conexión en el Server Explorer y la abre.

Ahora agrego algunas tablas para iniciar el desarrollo del sitio. Por lo pronto agregaremos Users, Posts y UserFriends.

Con esto queda listo nuestro proyecto para empezar a agregarle funcionalidad. En el siguiente post (Parte 1) seguiré con el desarrollo de este proyecto de prueba “MyTwitter”.

Web 2.0 Coffee Camp TJ

2009-03-17T11:27:00.001-08:00

El Sábado 7 de marzo de 2009 nos reunimos en el Café D’Volada de Otay Constituyentes para discutir que es el Web 2.0. Fue una reunión que duro aproximadamente 2 horas. Lo que aprendí de la reunión es que para que una aplicación se pueda considerar como WEB 2.0 debe de cumplir con algunas (no todas) características:

Característica Social

Los usuarios participan activamente en el contenido de la misma. El contenido son opiniones o expresiones personales y no simplemente datos, es decir el contenido es mas subjetivo que objetivo por lo tanto esta abierto a discusión y comentarios. En estos casos podemos encontrar sitios como YouTube, Wikipedia (contenido objetivo, pero abierto a discusión), flickr, twitter.

Característica Tecnológica

El sitio utiliza Ajax, tiene un API para ser consumido por clientes desarrollados por terceros. Y pueden o no utilizar RIAS. Esta es una característica no obligatoria. En lo personal al inicio del termino Web 2.0 consideraba esta característica mas importante que la social (tal vez por que soy desarrollador).

Característica Visual

Comentaron en la reunión (en lo personal no me ha tocado por que no soy diseñador) que algunas personas relacionan el termino web 2.0 con el aspecto visual de la aplicación. En lo general estuvimos de acuerdo en que esto no basta para que la aplicación sea considerada como WEB 2.0 (tómese en cuenta que a la reunión asistimos desarrolladores y diseñadores). Sin embargo eso me hizo pensar que si preguntamos en la calle a la mayoría de la gente tal vez para ellos web 2.0 requiere esta otra característica que para nosotros (desarrolladores y diseñadores) no es necesaria. Si para los que pagan los desarrollos y los diseños, el web 2.0 se refiere a lo visual y los efectos (muchas veces como resultado de la característica tecnológica) quizás esto deba ser considerado como una característica valida (aunque no me guste la idea).

Solo discutieron aplicaciones publicas en el Internet, parece que una aplicación privada que corre dentro de una intranet no es considerada como Web 2.0 aunque la mayoría del contenido de estas aplicaciones es generados por los mismos usuarios de la empresa y pudiera utilizar Ajax. Tal vez si el contenido es social, es decir de opinión de los empleados y no datos generados por el negocio, si se considere Web 2.0 (Creo que es algo que debí preguntar)

Algunas de las conclusiones personales de la reunión fueron que: siendo Web 2.0 un termino subjetivo, lo que para unos es web 2.0 para otros no lo es (generalmente depende de la perspectiva). Aunque creo que en lo que todos estuvimos de acuerdo es que: twitter si es Web 2.0. por su característica social.

Me quedó pendiente una pregunta...Si los comentarios de mi blog no son filtrados y cualquiera puede opinar ¿Los comentarios de mi blog son Web 2.0?

Puedes escuchar la reunión en:

http://www.dev3cast.com/

Podcasts

2009-03-04T15:24:00.000-08:00

Esta una lista de los podcasts que actualmente escucho

.Net Rocks
Ya un clasico de los podcasts, tiene la mejor calidad de audio y muy buenos invitados y temas sobre .Net

Deep Fried Bytes
Hablan principalmente sobre desarrollo en .net

Hanselminutes
Scott Hanselman web developer y ahora empleado de Microsoft trata varios temas

Polymorphic Podcast
Arquitectura y programación orientada a objetos en .Net (Ya tiene tiempo que no salen nuevos episodios)

The Poscast @ Delphi.org
podcast sobre Delphi

RunAs Radio
Para profesionales de IT, no es desarrollo pero es bueno conocer sobre IT

The Startup Success Podcast
Podcast para Startups o MicroISVs varios consejos para iniciar tu propio negocio de software

stackoverflow
Tratan temas sobre desarrollo y administración de equipos de desarrollo, principalmente hablan del sitio stackoverflow.com

The Thirsty Developer
Este de los mas recientes en mi lista, hablan principalmente de como se esta usando la tecnología.

dev3cast
Podcast de la comunidad .Net en Tijuana

Software Engineering radio
Ingeniería de software tratan temas que aplican a todas las plataforma y lenguages

Reunión 27 de la comunidad TJ.NET

2009-02-25T09:58:00.000-08:00

Hoy será la reunión 27 de la comunidad TJ.NET donde estaré presentando el tema de XML Literals en Visual Basic.

Mostrare como carga un archivo XML y con los datos crear un objeto del dominio y a partir de un objeto del dominio del problema crear un archivo XML. Ademas de mostrar como realizar una búsqueda en el documento XML utilizando LinqToXml.

Debido al poco tiempo sera una presentacion sencilla sin entrar mucho a detalle. Espero que los asistentes tengan preguntas, para hacerlo mas interesante.

Iniciando con Test Driven Development (TDD)

2009-02-01T13:35:00.001-08:00

Al iniciar con TDD , en algunos proyectos, note que esto ha hecho que cambie mi manera de programar. Ya que al tratar de escribir código de manera que sea testeable, termino escribiendo código mas desacoplado y con mas clases que hacen un trabajo mas especifico y con un poco de dependency injection. también he notado que ahora escribo mucho mas código y el resultado a veces es el mismo que antes (con la desventaja que me tarde mas). Aunque muchas veces los tests me han ayudado a encontrar errores mas rápido y me siento mas seguro de que el código que escribo funciona correctamente.

Por el momento estoy utilizando NUnit y NMock para mis unit test en .Net. Para mi gusto estos frameworks están bien para el tipo de tests que realizo.

Por ejemplo, supongamos que estamos construyendo un registro para usuarios. Y queremos que (cuando un usuario nuevo se registre) se validen los datos del usuario, se inserte a la base de datos y se envié correo de bienvenida.

Al escribir el test para el método de registro, debemos de evitar que este tengan dependencias en otras partes del sistema ya que solo queremos validar que se realicen las reglas de negocio y no tanto como se implementa cada tarea (para cada tarea se realizarán sus propias pruebas unitarias) esto me hace escribir mas clases de tal forma que pueda hacer mock objects para las dependencias.

Entonces en lugar de una sola clase para el registro (RegistrationService) que se encargue de validar, insertar y enviar correo, tendremos varias clases que colaboran para realizar el registro. Como pueden ser: RegistrationService, RegistrationValidator, EmailService y RegistrationDAL. Así podemos probar que el RegistrationService realice la regla de negocio y por separado probar cada una de las tareas. Ademas, si por alguna razón cambia la manera de validar el registro, solo tendríamos que modificar la clase RegistrationValidator y no tenemos que cambiar el resto del proceso de registro. Como ven esto implica realizar mas código, pero se supone que a la larga es mejor, Ahora tenemos código que valida nuestro código.

En mi caso realizar unit tests si me ha ayudado a encontrar errores y a estar seguro de que el código hace lo que tiene que hacer. Aunque debo admitir que hay veces que quisiera no tener que escribir tantas clases y pruebas para cada una de estas clases. En fin todo es cosa de saber que no todo requiere unit test y encontrar el balance entre lo que lo requiere y lo que no.

Firebird 2.1 List Function

2009-02-01T10:25:00.001-08:00

The List function in Firebird 2.1.

This is an aggregate function that returns a string with the field values concatenated using a delimiter. the default delimiter is the comma. So it's similar to the SUM function, but instead of adding numbers, this function concatenate strings. if some of the values is null then the function returns null.

So suppose I have 2 tables, projects and resources, and I know that a project will have a few resources assigned. Now I need to write a report of projects showing their resources assigned.


CREATE TABLE projects(
   project_id INTEGER,
   name string   
);

CREATE TABLE resources(
   project_id integer,
   user_name string
);

Without the LIST function I have to write this query


SELECT
  p.project_id as id,
  p.name,
  r.user_name
FROM
  projects p INNER JOIN
  resources r ON p.project_id = r.project_id

my result will be like this


id  name       user_name
-------------------------
1   Project_1  Steve
1   Project_1  John
2   Project_2  Jim
2   Project_2  Ed

Then in the report I will need to group the records with the same project_id so I don't show duplicate projects for each resource assigned.

Now with Firebird 2.1 I can write the query using the LIST function


SELECT
  p.project_id AS id,
  p.name,
  LIST(r.user_name, ', ') AS resources
FROM
  projects p INNER JOIN
  resources r ON p.project_id = r.project_id
GROUP BY
  p.project_id,
  p.name

my result will be like this


id  name       resources
-----------------------------
1   Project_1  Steve, John
2   Project_2  Jim, Ed

then in my report I only need to show the results of my query, I don't need to create groups.

The list function returns a BLOB data type, so if I need to display the result in a grid I often CAST the result to varchar. The delimiter parameter is not required (I added because I like to add a space after the comma). You can see more details of how to use the LIST function in the Firebird 2.1 Release Notes

This function is also useful in reports when you need details values in the same row as the master data like in reports headers or footers.

Firebird 2.1 UPDATE OR INSERT

2008-12-07T13:59:00.000-08:00

Another great feature that I like in Firebird 2.1 is the UPDATE OR INSERT statement. It's a really time saver and it makes the SQL cleaner.

For example suppose I have a products table like the one I use in my last post and an inventory table to store the product stock. Before Firebird 2.1 if I want to set the stock for a product I needed to check if a record for that product_id already exists; if the product_id already exists then I write an update. If not then I write an insert statement. So I ended up with something like this:


IF EXISTS(SELECT * FROM inventory WHERE product_id = :product_id ) THEN
  UPDATE
    inventory
  SET
    stock = :stock
  WHERE
    product_id = :product_id;
ELSE
  INSERT INTO inventory
    (product_id, stock)
  VALUES
    (:product_id, :stock);

In this example I only update one field but when I have to update a big table I ended up with a big chunk of code and thinking: "there should be another (better) way to do this".

Fortunately now with Firebird 2.1 there is a better way to do it, I only need to use the UPDATE OR INSERT statement and the engine will take care of checking if the record already exists, based on the primary key value. If the table does not have a primary key defined then I should use the MATCHING keyword with the columns I want to match. So in this example the sql can look like this:

--product_id is the primary key

UPDATE OR INSERT INTO inventory
  (product_id, stock)
VALUES
  (:product_id, :stock);

or like this

--product_id is not defined as the primary key

UPDATE OR INSERT INTO inventory
  (product_id, stock)
VALUES
  (:product_id, :stock)
MATCHING 
  (product_id);

This code looks much cleaner and does not need any comments to explain what is going on.

I really like this new feature.

Firebird 2.1 Domains in PSQL

2008-09-02T21:34:00.000-07:00

I Often use this domains in my Firebird databases


CREATE DOMAIN STRING AS VARCHAR(50) CHARACTER SET ISO8859_1 COLLATE ES_ES_CI_AI; /* for Spanish text */
CREATE DOMAIN MONEY AS DECIMAL(15, 2);
CREATE DOMAIN BOOL AS SMALLINT CHECK VALUE = 0 OR VALUE = 1;

So I can use them in my tables definitions like this:


CREATE TABLE PRODUCTS(
    ID INTEGER,
    DESCRIPTION STRING,
    PRICE MONEY,
    ACTIVE BOOL
)
ALTER TABLE PRODUCTS ADD CONSTRAINT PK_PRODUCTOS PRIMARY KEY (ID);

Before Firebird 2.1 when I wanted to create a stored procedure I had to write the data type of the domain instead of the domain name, like in the table definition, so I had to check the domain definition and write the data type on the procedure definition, although IBExpert help with that, my Stored Proc definition end it up not using the domains like this:


CREATE PROCEDURE INSERT_PRODUCT(
    DESCRIPTION VARCHAR(50),
    PRICE DECIMAL(15, 2),
    ACTIVE SMALLINT
)
BEGIN
  ...
END

Now with version 2.1 I can use domain in PSQL. I just need to type the domain name if i want to inheriting the check clause and the default value, or I can use the TYPE OF keyword if I just want the data type so I can define something like this:


CREATE PROCEDURE INSERT_PRODUCT(
    DESCRIPTION STRING,
    PRICE TYPE OF MONEY,
    ACTIVE BOOL
)
BEGIN
  ...
END

This way it seems that there is more consistency on my data types.

Firebird 2.1 Autentificar con Windows

2008-08-28T18:34:00.000-07:00

La mayoría de las aplicaciones que desarrollo que utilizan Firebird son de tipo Cliente/Servidor lo cual hace que el deba de guardar al usuario y contraseña en la cadena de conexión almacenada en la maquina cliente.

Ahora con Firebird 2.1 puedo usar los usuarios de windows como usuarios de la base de datos, de este modo no necesito almacenar el usuario y contraseña en la maquina cliente.

Utilizando Delphi o C++ Builder con DbExpress para conectarme a la base de datos puedo agregar el archivo dbConnections.ini y dejar en blanco los valores de user_name y password. El archivo quedaría similar a esto:

[MyFirebirdDatabase]
DriverName=INTERBASE
GETDRIVERFUNC=getSQLDriverINTERBASE
DATABASE=Server:Database
PASSWORD=
USER_NAME=
SQLDIALECT=3

Si uso .Net y el Firebird .Net Data Provider la cadena de conexión puede quedar algo asi:
Database=MyDatabase.fdb;DataSource=MyServer;Dialect=3;

Si el usuario es administrador entonces ingresará al servidor de firebird como el usuario SYSADMIN si no usara el usuario d windows actual.

Ahora solo debo de agregar los usuarios de windows a los usuarios de la base de datos y windows se encargará de autentificar.

Firebird Windows Authentication

2008-08-28T17:55:00.000-07:00

Most of the applications I write that use Firebird are Client/Server applications storing the user name and password to access the database in the connection string in the client machine.

Now with Firebird 2.1 you can use windows authentication so the client will use the windows user to log on to the server. This way I don't need to store the user name and password on the connection string in the client.

MS SQL Server has this feature for long time now. but it's great to have it on Firebird too.

Using Delphi or C++ Builder with DbExpress to accesss firebird in the dbconnections.ini file I just leave blank the user_name and password values, so I could have something like this:

[MyFirebirdDatabase]
DriverName=INTERBASE
GETDRIVERFUNC=getSQLDriverINTERBASE
DATABASE=Server:Database
PASSWORD=
USER_NAME=
SQLDIALECT=3

Using the Firebird .Net Data Provider the connection string will end up like this:
Database=MyDatabase.fdb;DataSource=MyServer;Dialect=3;

If the windows user is an administrator it will log in to the server as the SYSADMIN user. if the user is not an admin then the user will log in as the windows user.

Now I only have to add the windows users as database users and Windows will take care of authenticate them.

Firebird 2.1

2008-07-02T17:42:00.000-07:00

Estoy empezando a usar Firebird 2.1 y estoy contento con las nuevas características. Aun no he tenido de oportunidad de usar todo lo nuevo, aquí esta una lista de lo nuevo que he estado usando, espero escribir de cada una de ella con mas detalle en los próximos posts

Seguridad usando usuarios de Windows
Parámetros Opcionales en procedimientos almacenados
Dominios en los parámetros de los procedimientos
Natural Join
La función List
Sentencia Update or Insert

Hay mas características en la nueva versión, que aun no he tenido oportunidad de utilizar.

Abrir Documentos de MS Office 2007 con OpenOffice.org 2.4

2008-05-19T21:20:00.000-07:00

Para abrir documentos con el formato de open Xml (.docx, xlsx, pptx) con openOffice.org estoy utilizando un convertidor http://katana.oooninja.com/w/odf-converter-integrator, este programa crea una copia del archivo a un formato que OpenOffice.org puede abrir. Hasta ahora todos los archivos que he probado han sido convertidos con calidad.

Firebird and DBX4

2008-03-02T22:48:00.000-08:00

Although Firebird is not officially supported by the Interbase dbexpress driver it can be used without problems until the BSD 2006 (and the Turbo versions).

Now with Delphi 2007, RAD Studio and DBX4, firebird can still be use with Interbase driver, except if is used on Blobs fields; they allow reading but does not allow updating. This presents a problem when migrate applications to the latest version of Delphi and RAD Studio. This was reported in Quality Central but CodeGear closed the post arguing that Firebird is not Interbase, and the driver was written for Interbase, therefore it’s not a bug.

I suppose Firebird and Interbase will be separating each other more on future versions. I hope CodeGear will develop a driver for firebird because there are many applications made with Delphi and C++ Builder that are using Firebird.

Firebird DBX4 Blob Fields

2008-03-02T21:53:00.000-08:00

Aunque Firebird no es oficialmente soportado por el driver de interbase para dbexpress, se puede utilizar sin problemas hasta la versión de BSD 2006 (incluyendo los Turbo).
Ahora con la versión 2007 y DBX4 se puede seguir utilizando el driver de interbase, excepto si se usa campos Blobs. Ya que estos solo pueden ser leídos, pero no pueden ser actualizados. Lo cual representa un problema al querer migrar aplicaciones a la nueva versión de delphi y/o RAD Studio.

"El Problema" fue reportado en Quality Central pero CodeGear cerró el post argumentando que Firebird no es Interbase y el driver fue escritó para Interbase, por lo tanto no es un bug.

Supongo que poco a poco se irán separando cada vez más la base de datos Firebird e Interbase. Ojala y CodeGear desarrolle un driver para firebird ya que muchas de las aplicaciones hechas en delphi y BCB utilizan este servidor SQL.

Reiniciar Identity en MS SQL Server

2008-02-18T21:32:00.000-08:00

Esto es algo que casi no uso, pero de vez en cuando lo necesito y se me olvida apuntarlo, asi que ahora lo anoto aqui para que no se me olvide:

DBCC CHECKIDENT («Tabla», RESEED, «Semilla»);

por ejemplo reiniciar la semilla en la columna CustomerID en la tabla dbo.Customers seria:

DBCC CHECKIDENT ('dbo.Customers', RESEED, 1);

IBExpert

2008-02-15T18:55:00.001-08:00

Actualmente estoy usando el servidor SQL Firebird, este motor al ser open source no trae una herramienta de interfaz grafica para administración. Hay varias que se pueden usar, pero la que he encontrado mas facil y que se adapta mas a lo que necesito es IBExpert . Ademas de que tienen una versión personal gratis.

Firebird Stored Procedures

2007-07-29T20:47:00.000-07:00

Trabajando con los procedimientos almacenados de firebird. Algo interesante es la posibilidad de tener columnas con acumulados en los procedimientos, algo que no es facil de lograr con MS SQL Server (a menos que se usen tablas temporables o variables de tipo tabla). Y la posibilidad de ejecutar procedimientos por cada registro.

Este es un ejemplo de un procedimiento que regresa un dataset con los movimientos de una cuenta, mostrando el saldo en cada registro.


CREATE PROCEDURE EDO_CTA(DESDE DATE)
RETURNS(
   FECHA DATE,
   CONCEPTO VARCHAR(50),
   ENTRADA DECIMAL(15, 2),
   SALIDA DECIMAL(15, 2)
   SALDO DECIMAL(15, 2)
)
AS
BEGIN
--Obtenemos el saldo inicial
EXECUTE PROCEDURE GET_SALDO_INICIAL(:DESDE)
RETURNING_VALUES :SALDO;

FOR SELECT
   FECHA, CONCEPTO, ENTRADA, SALIDA
FROM
   MOVIMIENTOS_CUENTA
WHERE
   FECHA > :DESDE
INTO
   :FECHA, :CONCEPTO, :ENTRADA, :SALIDA
DO BEGIN
   SALDO = SALDO + ENTRADA - SALIDA;
   SUSPEND;
END
END;

Esto ira calculando el saldo por cada registro.

¿Por que Firebird?

2007-06-21T22:09:00.000-07:00

En el proyecto que estoy trabajando estamos migrando de base a datos desde MySQL hacia Firebird. El problema con MySQL fue que aunque es gratis, no puede ser redistribuido a menos que se pague por cada redistribucion, ademas de que las versiones con las que trabajamos no soportaban llaves foraneas ni procedimientos almecenados.

Otro motor de base de datos que consideramos fue MS SQL Server 2005. Este tiene la ventaja de que lo conocemos bien por haberlo utilizado en la mayoria de los proyectos, pero el problema es el costo de las licencias -En realidad el problema no es el costo de la licencia sino el presupuesto para el proyecto :( - Pensamos entonces en la version Express, pero no cuenta con todas las ventajas de la version completa.

Entonces fue que pensamos en Firebird, que es un motor de base de datos en mi opinion mas completo que MySQL y comparable con MS SQL Server (para aplicaciones medianas), puede ser redistribuido sin restrincciones y el deployment de firebird es mas sencillo que el de MS SQL Server.

He aqui una tabla con comparaciones entre MS SQL Server Express y la version embeded de Firebird.

Estas son algunas de las razones por las que eleigimos Firebird.

De C++Builder a Delphi

2007-05-19T20:22:00.000-07:00

Estoy trabajando en un proyecto en Delphi y he tenido la oportunidad de aprender mas del IDE y del lenguaje (Object Pascal). Ya conocia la VCL, por que he trabajado en C++ Builder.

Este proyecto me decidí por delphi, ya que al trabajar en C++ Builder siempre me senti como usuario de segunda comparado con el usuarios de Delphi a los que Borland y ahora CodeGear se enfocan mas, ademas de que solo estaba utilizando la VCL y no estaba aprovechando el potencial de c++ ni la facilidad de Delphi.

El lenguaje lo he encontrado muy parecido a C# (no en la sintaxis sino en los conceptos que maneja) se nota que tienen a Anders Hejlsberg en comun. Asi que casi solo tengo que enfocarme en el cambio de sintaxis lo cual no es gran problema.

Lo ventaja es que ahora disfruto de todas los avances que tiene el IDE el cual siempre tiene las mejoras primero para delphi que para C++ Builder.

Database Mail en MS SQL Server 2005

2007-02-01T10:59:00.000-08:00

Configuración de Database Mail en MS SQL Server 2005

Primero se debe de habilitar, ya que por omisión el componente esta deshabilitado, Utilizando el SSMS (SQL Server Management Studio)

Si no esta habilitado aparecerá un mensaje preguntado si lo habilita, después aparece esta ventana donde se pregunta al usuario que es lo desea hacer.

Seleccionamos la primera opción para crear un perfil.

Configuramos el perfil y le agregamos por lo menos una cuenta.

Seleccionamos el perfil como public y default.

Para mandar correo se utiliza el procedimiento msdb.sp_send_dbmail por lo tanto el usuario que intente mandar correo debe de tener permiso para la base de datos msdb.

Referencias:
http://www.sqlservercentral.com/columnists/cBunch/introtodatabasemailinsql2005.asp

Cosas que aprendi en Coca-Cola

2007-01-31T08:54:00.000-08:00

El viernes 2 de febrero es mi último dia como empleado de "Servicios ejecutivos del Noroeste". Gracias a todos por el apoyo que me dieron. Esta es una lista de algunas de las cosa que aprendi trabajando para Sistemas en Cdf (Coca-Cola).

El que te llames igual que tu superior no significa que lo puedas llamar tocayo
el signo "¿" se pronuncia "Pregunta".
La palabra "interface" o "interfase" no existe (la que existe es interfaz), pero si se usa.
El que haya muchos jefes no significa que exista gente a su cargo (algunos son jefes de ellos mismos solamente)
Solo los chilangos tienen oficina
El vino tinto es bueno para romper el hielo
Pagar derecho de piso es un mito

Estas son solo algunas, espero despues completar la lista.

Vuelven los Turbo

2006-08-31T20:46:00.000-07:00

CodeGear - Borland relanza sus productos turbo (c++, Delphi win32, Delphi.net y c#). Saldran 2 versiones. La version Explorer y la version profesional. tendran las mismas caracteristicas que la version profesional del BDS.

la version explorer es gratis y se puede usar para realizar aplicaciones comerciales, lo malo es que no se le pueden agregar componentes de terceros ni trae reporteador.

Sara Mercedes Cornejo Portillo

2006-08-28T16:16:00.001-07:00

Ya nació mi hija Sara Mercedes. Una preciosa bebita que nació el 23 de Agosto del 2006 a las 3:45 am y que no me ha dejado dormir desde entonces.

Peso 3 Kg y midio .51 m

Cambiar data source de un crystal report en tiempo de ejecucion

2006-04-25T17:11:00.000-07:00

Para cambiar el servidor, base de datos, user id y password de reportes crystal en tiempo de ejecucion (runtime) se debe indicar la informacion de la conexion a cada tabla del reporte y tablas de los subreportes.

private bool ApplyLogon(ReportDocument cr, ConnectionInfo ci)
{
TableLogOnInfo li;
// for each table apply connection info
foreach (CrystalDecisions.CrystalReports.Engine.Table tbl in cr.Database.Tables)
{
li = tbl.LogOnInfo;
li.ConnectionInfo = ci;
tbl.ApplyLogOnInfo(li);
// check if logon was successful
// if TestConnectivity returns false, check
// logon credentials
if (tbl.TestConnectivity())
{
// drop fully qualified table location
if (tbl.Location.IndexOf(".") > 0)
tbl.Location = tbl.Location.Substring(tbl.Location.LastIndexOf(".") + 1);
else
tbl.Location = tbl.Location;
}
else
return false;
}
return true;
}
// El metodo recorre todas las tablas
private bool Logon(ReportDocument cr, string server, string db, string id, string pass)
{
ConnectionInfo ci = new ConnectionInfo();
SubreportObject subObj;
ci.ServerName = server;
ci.DatabaseName = db;
ci.UserID = id;
ci.Password = pass;
if (!ApplyLogon(cr, ci))
return false;
foreach (ReportObject obj in cr.ReportDefinition.ReportObjects)
{
if (obj.Kind == ReportObjectKind.SubreportObject)
{
subObj = (SubreportObject)obj;
if (!ApplyLogon(cr.OpenSubreport(subObj.SubreportName), ci))
return false;
}
}
return true;
}

Comunidad de Egresados

2006-03-05T12:14:00.000-08:00

Ya inicio la organización del grupo de egresados de la carrera Ing. En computación de la UABC. La idea es que al principio seamos amigos con reuniones para poder compartir conocimientos, experiencias, técnicas y consejos.

Espero que no solo se traten temas técnicos, si no también temas relacionados con el trabajo. Para estar todos enterados de como se encuentra la industria en nuestra región, que es lo que se requiere saber y cuanto se debe cobrar o pagar para así ser competitivos.

Por el momento se ha planteado que las reuniones sean el primer viernes de cada mes en la noche, pero todavía esta por confirmarse, se requiere que los posibles asistentes revisen sus agendas.

Con este post inicio mi blog; espero mantenerlo actualizado.