Angel "Java" Lopez : .NET

ALT.NET Hispano VAN (reunión virtual): Aplicaciones modulares con Prism

lopez — Thu, 10 Dec 2009 10:49:14 GMT

Este sábado 12 de diciembre, 19 GMT (4 de la tarde aquí en Buenos Aires) de nuevo tenemos VAN (Reunión virtual, des-conferencia) organizada por la comunidad de ALT.NET Hispano.

(Más información sobre cómo asistir a la reunión virtual, software necesario, enlaces:

http://altnet-hispano.pbworks.com/Descripcion-de-Reuniones

)

Esta vez el tema será Prism (Composite Application Guidance para Windows Presentation Foundation y Silverlight). La introducción estará a cargo del bueno de @juliandominguez, que nos comenta en la lista de ALT.NET Hispano:

La idea de este próximo sábado es presentar sobre Prism (o Composite Application Guidance for WPF and Silverlight para los que prefieren el nombre real pero aburrido).

¿Qué es Prism de patterns & practices y qué desafíos resuelve?

¿Qué beneficios les brinda a arquitectos, desarrolladores y a la interacción con diseñadores?

En esta sesión mostraré cómo Prism nos ayuda a trabajar en equipos distribuidos, no distribuidos, grandes o pequeños, con requerimientos cambiantes, aplicando conceptos como TDD y patrones de UI como Model View ViewModel (MVVM). También voy a mostrar cómo nos ayuda a reusar código que funcione en WPF y en Silverlight.

Vamos a estar viendo los beneficios que nos trae Prism a la hora de construir una aplicación compuesta, como así también en qué (lio?) nos metemos cuando queremos usar Prism en una aplicación que no lo amerita.

Espero que les resulte muy interesante a quienes no conocen Prism y tienen pensado empezar un proyecto en WPF o Silverlight.

Sé que normalmente las VAN suelen ser a las 18:00 GMT, pero debido a mi horario (actualmente estoy en Redmond), preferiría que sea las 19:00 GMT. Esto sería el sábado 12/12.

Así que la reunión será este sábado a las 19GMT (no a las 18GMT como otras veces).

Mi colección de enlaces sobre Prism:

http://delicious.com/ajlopez/prism

Otros interesantes:

http://delicious.com/ajlopez/mef
http://delicious.com/ajlopez/mvvm
http://delicious.com/ajlopez/silverlight
http://delicious.com/ajlopez/wpf

(especialmente si agregan examples o tutorial, como http://delicious.com/ajlopez/mef+example)

Si es la primera vez que topan con el término VAN, les recuerdo:

Si no conocen qué es una reunión VAN, pueden consultar VAN meetings. Para ver cómo se desarrolla una VAN de ALT.NET Hispano, y qué software necesitan para asistir, ver Descripcion-de-Reuniones-VAN. Pueden ver el historial de anteriores reuniones VAN (visiten las que dieron, por ejemplo, sobre NHibernate, WPF y demás) (yo participé en VAN sobre Scrum y en otra sobre generación de código). También pueden suscribirse para proponer nuevos temas, y colaborar con la comunidad. Si no pueden asistir a ésta VAN, seguramente quedará publicada más adelante, con video incluido.

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

ALT.NET Hispano VAN: Mocking, Rhino Mocks, Moq con Hadi Hariri

lopez — Fri, 27 Nov 2009 11:29:34 GMT

Este sábado 28 de noviembre, la comunidad ALT.NET Hispano organiza una nueva VAN (Reunión virtual). Esta vez el horario (tomen nota) será 19:00 GMT/UTC (4 de la tarde por aquí en Buenos Aires, Argentina). El tema será el uso de Mocks, en nuestras pruebas automatizadas. La presentación del tema estará a cargo del bueno de Hadi Hariri (que pueden seguir en Twitter en @hhariri). Hadi vive en España, se presenta en su sitio:

http://hadihariri.com

de esta manera:

I'm a software developer and work as Tech Lead for iMeta Technologies. I also give talks and presentations. I love to travel and luckily get to do so when speaking at conferences. My main passions are Software Architecture, Web and TCP/IP development. I live in Málaga, with my wife Katya and my two wonderful sons, Maxim and Sasha. I run the local .NET User group for Málaga and the province. If you live in Málaga or are visiting, drop me a line.

Pueden leer sobre sus conferencias e intereses en:
http://hadihariri.com/blogengine/page/Conferences.aspx
http://hadihariri.com/blogengine/archive.aspx

El enlace a usar es http://snipr.com/virtualaltnet. La información sobre las VAN que vienen, están en la página del Calendario de ALT.NET Hispano. Ahí leo más detalles sobre esta reunión de mañana sábado:

La comunidad ALT.NET Hispano (http://altnethispano.org) realizará un evento virtual con el tema "Mocking" (e "Inyección de Dependencias"), a cargo de Hadi Hariri. Fecha: Sábado 28 de Noviembre a las 19:00 hrs. Hora Internacional (GMT/UTC), con una duración aproximada de 2 horas.

Lugar: Para atender la reunión deben usar el enlace: http://snipr.com/virtualaltnet el cual les demandará el uso del programa Microsoft Office Live Meeting 2007 Client. En esta ocasión la desconferencia estará a cargo de Hadi Hariri, Visual C# MVP, quien es consultor y desarrollador ante todo, así como apasionado de la arquitectura de software y el desarrollo de aplicaciones web. Es ponente habitual en conferencias sobre .NET y Win32, y ha escrito numerosas publicaciones.

Descripción: En esta charla primero repasaremos la inyección de dependencias e Inversión de Control y profundizaremos en los frameworks de Mocks. Veremos cómo funcionan, éstos últimos, así como también cómo sacarle el máximo de partida a ellos para hacer tests sostenibles. Examinaremos las diferencias entre Mocks y Stubs así como diferencias entre pruebas de estado e interacción.

Algunas páginas a revisar:

Inversion of Control Containers and the Dependency Injection pattern

Mocks can be your friend, or your worst nightmare

Pueden plantear sus comentarios e inquietudes sobre el tema de la reunión en: http://groups.google.com/group/altnet-hispano/t/57766b68494fe859 Para mayor información sobre cómo atender la reunión consulten: http://tinyurl.com/van-hispano Pueden vincular el Google Calendar al suyo (http://screenr.com/nr7), o bien descargar el iCal de este evento en particular: http://altnet-hispano.pbworks.com/f/VAN20091128.ics

Si no conocen qué es una reunión VAN, pueden consultar VAN meetings. Para ver cómo se desarrolla una VAN de ALT.NET Hispano, y qué software necesitan para asistir, ver Descripcion-de-Reuniones-VAN. Pueden ver el historial de anteriores reuniones VAN (visiten las que dieron, por ejemplo, sobre NHibernate, WPF y demás) (yo participé en VAN sobre Scrum y en otra sobre generación de código). También pueden suscribirse para proponer nuevos temas, y colaborar con la comunidad. Si no pueden asistir a ésta VAN, seguramente quedará publicada más adelante, con video incluido.

Con respecto a Mocks, y librerías de mocking, he dejado enlaces en:

http://delicious.com/ajlopez/mocks
http://delicious.com/ajlopez/rhino
http://delicious.com/ajlopez/moq

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Generando código con AjGenesis usando archivos de mapeo de NHibernate

lopez — Mon, 23 Nov 2009 09:18:30 GMT

En estos días, estuve trabajando en generar código de clases C#, usando como punto de partida los archivos .hbm, que se usan en NHibernate para especificar el mapeo de clases y tablas de bases relacionales. Como es usual, cuando encaro algo de generación de código uso AjGenesis, mi proyecto open source de generación de código (practico el “dog fooding” :-).

(English version of this post Generating code with AjGenesis using NHibernate hbm files)

Pueden bajar un ejemplo de lo que estoy haciendo de mi Skydrive:

Examples > AjGenesis > NHibernateMappingExample01.zip

(el código en desarrollo está en el trunk, en este change actual, en el directorio examples\NHibernateMappinp:

pero si quieren ir directamente al ejemplo, pueden bajárselo completo desde el Skydrive que mencioné, que incluye el ejecutable de AjGenesis de la versión en desarrollo, no necesitan compilar nada).

Luego de expandir el archivo del ejemplo, tendrán este contenido:

Para crear clases C#, pueden probar de ejecutar los comandos:

GenerateClasses AjFirstExample
GenerateClasses AjTest

Para crear un proyecto .NET con los archivos .cs y .hbm, y una solución, ejecutar:

GenerateProject AjFirstExample
GenerateProject AjTest

Los archivos generados, en ambos casos, quedan en el directorio Build.

Hay dos proyectos ejemplo que son AjFirstExample, con dos mapeos simples, y AjTest, que tiene mapeos más interesantes, con “bags” y relaciones “many to one”.

En el ejemplo, cada proyecto se describe con un simple archivo Project.xml:

<Project Name="AjTest">
</Project>

En cuanto necesite más información, lo agregaré ahí, o en tags meta de los propios archivos de mapeo y configuración.

Este es uno de los archivos de mapeo que sirven de modelo inicial para este ejemplo de generación, en Projects\AjTest\Mappings, Department.hbm:

<?xml version="1.0" encoding="utf-8" ?> 
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2"
  assembly="AjTest.Entities"
  namespace="AjTest.Entities"
  >
  <class name="Department" table="departments">
    <id name="Id" column="Id" type="Int32">
      <generator class="native"/>
    </id>
    <property name="Description" type="String"/>
    <bag name="Employees" lazy="true" inverse="true" cascade="all">


      <key column="IdDepartment"/>
      <one-to-many class="AjTest.Entities.Employee, AjTest.Entities"/>
    </bag>  
  </class>
</hibernate-mapping>

Este es el código generado para este mapeo, Department.generated.cs:

using System;
using System.Collections.Generic;
using Iesi.Collections.Generic;
namespace AjTest.Entities 
{
  public class Department {
    public int Id { get; set; }
    public string Description { get; set; }
    public IList<Employee> Employees { get; set; }
    public Department() 
    {
      this.Employees = new List<Employee>();
    }
  }
}

Veamos el proceso de generación. Este es el contenido de GenerateProject.cmd:

@echo off
set ProjectName=%1%
if "%1%"=="" set ProjectName=AjFirstExample
Bin\AjGenesis.Console.exe Projects\%ProjectName%\Project.xml Tasks\AddMappings.ajg Tasks\BuildCSharp.ajg
xcopy Libraries\*.* Build\%ProjectName%\CSharp\Src\Libraries /Y /Q

La línea más importante es la que invoca a AjGenesis.Console.exe. El contenido de Project.xml se carga en memoria. La tarea AddMapping.ajg se carga y ejecuta (está escrita en un lenguaje dinámico, afectuosamente llamado AjBasic), y luego, se procesa la tarea BuildCSharp.ajg. Veamos el código de AddMapping.ajg:

' Add mappings from directory if not specified in Project model
Include("Utilities/Utilities.tpl")
if not Project.Mappings then
  Project.Mappings = CreateList()
  
  di = new System.IO.DirectoryInfo("Projects/${Project.Name}/Mappings")
  
  for each fi in di.GetFiles("*.hbm.xml")
    filename = fi.Name
    Project.Mappings.Add(filename.Substring(0, filename.Length - 8))
  end for
end if

Encuentra y agrega los nombres de los archivos de mapeo contenidos en el directorio de Mapping, dentro del proyecto (noten que se pueden usar clases y objetos del framework .NET). Una tarea más interesante es la GenerateCSharp.ajg. Primero, carga la dll de NHibernate, para usar más adelante su parser de archivos hbm:

include "Utilities/Utilities.tpl"
include "Utilities/FileUtilities.tpl"
include "Utilities/TypeUtilities.tpl"
Include("Utilities/NHibernateUtilities.tpl")
include "Templates/CSharp/UtilitiesCs.tpl"
include "Templates/CSharp/CSharpFunctions.tpl"
AssemblyManager.LoadFrom("Libraries/NHibernate.dll")
parser = new NHibernate.Cfg.MappingSchema.MappingDocumentParser()

Crea objetos dinámicos, donde coloca información de la solución y el proyecto a crear:

if not Project.BuildDir then
  Project.BuildDir = "Build/${Project.Name}/CSharp"
end if
message "Creating Directories..."
FileManager.CreateDirectory(Project.BuildDir)
FileManager.CreateDirectory("${Project.BuildDir}/Sql")
FileManager.CreateDirectory("${Project.BuildDir}/Src")
FileManager.CreateDirectory("${Project.BuildDir}/Src/Libraries")
message "Defining Solution and Projects..."
Project.Solution = CreateObject()
Project.Solution.Guid = "FAE04EC0-301F-11D3-BF4B-00C04F79EFBC"
Project.Solution.Projects = CreateList()
message "Defining Entities Project..."
PrjEntities = CreateObject()
PrjEntities.Includes = CreateList()
PrjEntities.Guid = CreateGuid()
PrjEntities.COMGuid = CreateGuid()
Project.Solution.Projects.Add(PrjEntities)
Project.Entities = CreateList()

Ahora, itera sobre cada archivo hbm, lo lee usando el parser del propio NHibernate, toma información sobre las clases a generar:

for each MappingName in Project.Mappings
  filename = "Projects/${Project.Name}/Mappings/${MappingName}.hbm.xml"
  mapping = parser.Parse(OpenAsStream(filename))
    
  for each hbmclass in mapping.Items where IsType(hbmclass, "HbmClass")
    Entity = CreateObject()
    
    Project.Entities.Add(Entity)
  
    Entity.ClassName = hbmclass.name
    Entity.Namespace = mapping.namespace
    
    ' Namespace as default project name for Entities Project
    if not PrjEntities.Name then
      PrjEntities.Name = mapping.namespace
      PrjEntities.Directory = "${Project.BuildDir}/Src/${PrjEntities.Name}"
      FileManager.CreateDirectory(PrjEntities.Directory)
    end if
    
    Entity.Properties = CreateList()
    
    if hbmclass.Id then
      Property = CreateObject()
      Property.Name = hbmclass.Id.name
      Property.Type = HbmTypeToCSharp(hbmclass.Id.type1, Entity.Namespace)
      Entity.Properties.Add(Property)
    end if
    
    for each item in hbmclass.Items
      if IsType(item, "HbmProperty") then
        Property = CreateObject()
        Property.Name = item.name
        Property.Type = HbmTypeToCSharp(item.type1, Entity.Namespace)
        Entity.Properties.Add(Property)
      end if
      
      if IsType(item, "HbmManyToOne") then
        Property = CreateObject()
        Property.Name = item.name
        Property.Type = HbmTypeToCSharp(item.class, Entity.Namespace)
        Entity.Properties.Add(Property)
      end if
      if IsType(item, "HbmSet") then
        Property = CreateObject()
        Property.Name = item.name
        Property.IsSet = true
        Property.Type = HbmTypeToCSharp(item.Item.class, Entity.Namespace)
        Entity.Properties.Add(Property)
      end if
      if IsType(item, "HbmBag") then
        Property = CreateObject()
        Property.Name = item.name
        Property.IsList = true
        Property.Type = HbmTypeToCSharp(item.Item.class, Entity.Namespace)
        Entity.Properties.Add(Property)
      end if
    end for    
  end for
end for

Pueden extender esta capacidades, procesando más tags (debería escribir un ejemplo usando los tags meta que puede contener el hbm; ya utilitarios de Java, como el venerable XDocLet, usaban esos tags para ayudarse en la generación de código, en Hibernate), y detectar más formas de mapeo de NHibernate. Ahora, pasa a la generación de código:

for each Entity in Project.Entities
  TransformerManager.Transform("Templates/CSharp/Entity.tpl", "${PrjEntities.Directory}/${Entity.ClassName}.generated.cs", Environment)
  PrjEntities.Includes.Add(CreateFileCs("${Entity.ClassName}.generated"))
end for

La tarea genera los archivos .cs, y también crea un archivo de solución y otro de proyecto C#, copiando y embebiendo los archivos de mapeo originales:

for each MappingName in Project.Mappings
  filename = "Projects/${Project.Name}/Mappings/${MappingName}.hbm.xml"
  targetfilename = "${PrjEntities.Directory}/${MappingName}.hbm.xml"
  System.IO.File.Copy(filename, targetfilename, true)
  PrjEntities.Includes.Add(CreateFileType(MappingName,"hbm.xml"))
end for
for each CsProject in Project.Solution.Projects where CsProject.ProjectType<>"Web"
  FileManager.CreateDirectory(CsProject.Directory)
  FileManager.CreateDirectory(CsProject.Directory & "/Properties")
  TransformerManager.Transform("Templates/CSharp/CsProject.tpl", "${CsProject.Directory}/${CsProject.Name}.csproj", Environment)
  TransformerManager.Transform("Templates/CSharp/AssemblyInfoCs.tpl", "${CsProject.Directory}/Properties/AssemblyInfo.cs", Environment)
end for
TransformerManager.Transform("Templates/Solution.tpl", "${Project.BuildDir}/Src/${Project.Name}.sln", Environment)

Esta es la solución generada:

Próximos pasos

Debería trabajar en algunos puntos:

- Generar una solución más completa, como en otros ejemplos de AjGenesis (con un proyecto de infraestructura, un proyecto de Service Layer o similar, una presentación web, etc…).

- Soportar más opciones de mapeo de NHibernate.

- Usar los tags meta.

Por ahora, pueden jugar con este ejemplo. Pueden cambiar los templates para generar más artefactos, por ejemplo, código VB.NET.

Gracias a @fabiomaulo por avisarmr de las capacidades públicas de parser de hbm dentro de NHibernate!

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Lo bello de Twitter: Ejemplo 1

lopez — Sun, 22 Nov 2009 09:31:11 GMT

Soy un gran usuario de Twitter. Generalmente, uso TweetDeck como cliente, aunque a veces voy por la interfaz web. Twitter es la implementación de un idea simple (mensajes cortos, podemos seguir a quien querramos que tenga perfil público, nos pueden seguir y dejar de seguir en cualquier momento (noten los cambios de Facebook a tener perfiles públicos, veo que motivados por la facilidad que se da en Twitter)) Todo eso ha cambiado la forma en que interactuamos. En especial, en el ambiente del desarrollo del software, Twitter es un gran complemente (podría ser un reemplazo) a los lectores de feeds. Veamos un ejemplo de lo efectivo que puede ser.

Todo comenzó ayer sábado, con un mensaje de @jfroma, desarrollador de software argentino, como yo, que escribía:

Yo no había leído todos sus mensajes del viernes, así, que curioso sobre ese comentario, fuí y los leí. El mensaje original aludía al patró Model View View Model. Sé que José (@jfroma) ha estado trabajando en ejemplos de data binding en WPF usando modelos recuperados con NHibernate, así que seguí el link que apuntaba al usuario @michaellperry, para leer sus mensajes. Era mi primer contacto con Michael:

Encontré, entre sus mensajes del viernes, esta presentació:

Session Detail: Data binding without INotifyPropertyChanged

preguntando para confirmar a @jfroma:

Ahora, tenía más contexto (una frase que repito muchas veces: con contexto, uno se puede manejar más entre la información que recibe). Con todo esto, descubro los intereses de Michael en su blog (noten cómo Michael usa su estado Twitter a la izquierda):

http://adventuresinsoftware.com/blog

Descubrí la librería de código abierto de la presentación de Michael:

http://updatecontrols.net

Como siempre que encuentro algo interesante, ya sea para mí, o que pienso que puede ser interesante para alguien, comencé a tweetear sobre el tema. Al rato, veo que @jyinglee desde China, también tomó nota, haciendo RT de mi mensaje:

Todo comenzó con un simple mensaje. Este es el poder de Twitter, es“serendipity with help” (descubrimiento accidental con ayuda), con la ayuda de gente interesante que nos sigue y a la que seguimos.

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Alt.Net Hispano VAN, ASP.NET MVC 2 con estilo, de Oxite a CodeCamp

lopez — Thu, 19 Nov 2009 12:08:52 GMT

Este sábado 21 de Noviembre, tendremos VAN (reunión virtual) organizada por la comunidad ALT.NET Hispano. El tema será ASP.NET MVC, en particular, la versión 2. Como siempre, la reunión no será sólo una exposición, sino también discusión, preguntas, ejemplos, recursos, opiniones. Hasta donde sé, el horario es el de siempre 5:00pm GMT (2 de la tarde acá en Buenos Aires). Y en enlace a usar es http://snipr.com/virtualaltnet (más detalle sobre software y qué es una VAN al final de este post).

La presentación inicial estará a cargo de Cristian Prieto, Microsoft ASP.NET MVP, MCPD ASP.NET Web Development Applications 3.5, MCTS Workflow Foundation 3.5:

http://www.cprieto.com/ (me gusta el título “IDisposable Thoughts” :-)

Hi, My name is Cristian Prieto, I'm a Senior Software Developer living in Guatemala, Central America. I mainly "speak" in .Net languages (like C#, F# and _even_ VB.NET) but I really love programming in Python/Ruby/Erlang. When I'm not programming (or speaking at a .net user group) I enjoy reading and spend my life with my beautiful wife (Emy) and my three cats: Cocco, Motto and Chester

Pueden seguirlo en Twitter como @cprieto:

y en LinkedIn como http://www.linkedin.com/in/cprieto. Ahí leemos su experiencia:

- Experienced Web Developer with more than 9 years in technologies like ASP.NET, PHP, Python, JavaScript and distributed programming.
- Agile software developer proficient with patterns and best practices like Test Driven Development, Behavior Driven Development and Continuous Integration.
- Lover of agile process based development like Lean Development, Kanban and Scrum.
- Technical Community Leader, mentor of new development trends and best practices. Awarded Microsoft ASP.NET MVP 2009
- Accustomed to work with many languages and tools.
- Self-thought and early adopter

Cristian Prieto’s Specialties:

ASP.NET, SQL Server, Web Development in general
Python, Best practices, Multi tier application development, Agile development (lean, kanban, scrum)

Escribe el bueno de Cristian en la lista de ALT.NET Hispano, cuál va a ser el tema de la charla:

Como ustedes recordaran, este sábado 21 de noviembre tendremos la VAN acerca de ASP.NET MVC 2, quería comentar un poco de que esperar para esta VAN (bueno, quizás también por parte del nerviosismo de ser mi primera VAN :P)
ASP.NET MVC fue "cocinado" durante 1 año y mientras tanto nos mantubieron pegados a la silla con 5 CTP's y un par de betas... después de varios meses hemos visto aplicaciones en producción con la plataforma, 5 libros acerca del tema, muchos y muchos webcasts (hay 2 en alt.net hispano :D) y conferencias de "cómo explotarla", multiples proyectos de ejemplo.... y, obviamente, muchas preguntas luego de hacer el "hola mundo".
¿Qué pasa cuando necesitamos algo más que el típico proyecto de NerdDinner? ¿Qué pasa cuando mi aplicación realmente no es un típico ejemplo? ¿Dónde pongo la lógica? ¿Cómo divido y saco provecho de la framework? ¿Qué otras cosas podemos tener bajo la manga para hacernos la vida más sencilla?
Para aclarar estas dudas, examinaremos desde el punto de vista histórico y práctico con qué solemos comenzar y hasta dónde lo podemos llevar, mencionando cosas como MvcContrib y MvcTurbine y dónde encajan cosas como SharpArchitecture en todo esto...
¿Porqué menciono todo esto si la charla es de ASP.NET MVC 2?, simple, porque gran parte de los "problemas" que solemos encontrarnos con ASP.NET MVC vienen o prometen venir solucionados en la "cajita" de la versión 2...
Espero verlos en la VAN, y espero que les guste lo que he preparado :)

Todo indica que va a ser una VAN muy interesante: el título del mensaje (y de este post) alude a un proyecto “fracaso” Oxite, con código disponibl, que fue critica por la comunidad por los “bad smell” que presentaba en la implementación, y a CodeCamp, un nuevo proyecto de código abierto, que sirve de muestra de mejores prácticas con ASP.NET MVC (Model View Controller). Cristian menciona también a proyectos como SharpArchitecture, MvcContrib y MvcTurbine.

Si no conocen qué es una reunión VAN, pueden consultar VAN meetings. Para ver cómo se desarrolla una VAN de ALT.NET Hispano, y qué software necesitan para asistir, ver Descripcion-de-Reuniones-VAN. Pueden ver el historial de anteriores reuniones VAN (visiten las que dieron, por ejemplo, sobre NHibernate, WPF y demás) (yo participé en VAN sobre Scrum y en otra sobre generación de código). Supongo (pero confirmen) que la URL de entrada de esta VAN será http://snipr.com/virtualaltnet. Cualquier cosa, pueden consultar la lista de correo de ALT.NET Hispano. También pueden suscribirse para proponer nuevos temas, y colaborar con la comunidad. Si no pueden asistir a ésta VAN, seguramente quedará publicada más adelante, con video incluido.

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

NHibernate en SQL Azure

lopez — Tue, 03 Nov 2009 16:12:26 GMT

El viernes pasado, estuve hablando con Fabio Maulo (@fabiomaulo) de varios temas: de desarrollo de software, enseñanza de la programación, y por supuesto, sobre NHibernate. Ambos vivimos en Buenos Aires, Argentina, y fue un placer hablar con él, como siempre. Yo sigo a Fabio en Twitter, y soy un subscripto a su blog. Fabio ha estado colaborando con el proyecto NHibernate desde hace años, y es un reconocido desarrollador en la comunidad .NET.

Me contó detalles de un sitio que construyó con un equipo, usando NHibernate. Lo interesate es que corre sobre SQL Azure. Pueden verlo en línea (es un sitio mexicano):

http://salondetokio.autocosmos.com.mx/

Fabio y su equipo trabajaron duro para armar este sitio, en menos de mes (estoy esperando que el equipo de Fabio comente más detalles en posts, por ahora, puedo hablar sobre lo que se conoce públicamente).

Curiosamente, el sitio está ejecutando sobre WebForms, pero sin usar ViewState, y sin tener un tag de Form en varios de los tags Body de las páginas que he examinado. Espero que Maulo y su equipo escriban explicando los detalles de implementación. El código está basado en el patrón Model View Presenter, ha sido escrito con tests automáticos, mocks, stubs, comenzando desde cerca de la presentación, hasta llegar a la persistencia. ¡Vamos Fabio! ¡Estamos esperando detalles sobre el proceso seguido y las decisiones de arquitectura! :-)

Más información sobre NHiberante y SQL Azure:

NHibernate on the cloud: SQL Azure Tests de NHibernate sobre SQL Azure, según Ayende

Quick news NHibernate with SQL Azure Los primeros pasos de Fabio en el tema: “All work… even the SchemaExport.” !!

NHibernate dialect for SQL Azure Ajustes para el SchemaExport

Estoy coleccionando enlaces sobre NHibernate y Azure en:

http://delicious.com/ajlopez/nhibernate+azure

Hay una excelente serie de posts de Brad Adams, explicando Azure en general, SQL Azure, NHibernate, Silverlight, RIA .NET Services, y más:

Index for Business Apps example for Silverligth 3 RTM and .NET RIA Services July Update

Relacionado a NHibernate y Azure, en esa serie:

Part 20: NHibernate
Part 23: Azure

¿Conocen otro proyecto que use NHibernate en “el cloud”?

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Aventuras de Programación Extrema en C#

lopez — Mon, 02 Nov 2009 09:06:08 GMT

El viernes pasado estuve visitando las oficinas del Microsoft User Group de Argentina, acá en Buenos Aires. Tenía que dictar un curso de .NET, pero hubo un corte de luz (al parecer frecuente en estos días de alta temperatura; Buenos Aires está sufriendo cortes de luz, mucha carga en los aires acondicionados creo). Ni lerdo ni perezoso, me entretuve unas horas aprovechándome de la biblioteca del MUG, sobre la que tendría que postear más. Los socios del MUG tienen acceso a los volúmenes de la biblioteca, y hay libros de temas como Windows Server, programación .NET, Test Driven Development, programación en general, desarrollo web y más.

Así que, no teniendo más deberes de los que ocuparme ni más preocupaciones en el alma (como Descartes ante la estufa… :-), me dediqué a la lectura. Estuve leyendo un libro de ASP.NET 3.5 (no tengo el autor acá), estuve hojeando el clásico “Práctica de la Programación” de Kernighan y y estaba por encarar el Sistemas Operativos de Tanenbaum (al que sigo desde las primeros avisos en la Dr.Dobbs, al principio de los ochenta, sobre compiladores multilenguajes). Pero un libro me llamó la atención, había sido devuelto a la biblioteca el jueves, por el bueno de @lmpetek: el Extreme Programming Adventures in C#

Excelente libro, escrito por Ron Jeffries, acreditado XPer, uno de los tres “fundadores” de XP (Extreme Programming), junto con Ken Beck y Ward Cunningham. Pueden seguirlo en Twitter por @RonJeffries. Leo en la página del libro en Microsoft Press:

See how eXtreme Programming (XP) works—and learn Microsoft .NET and C# programming in the process!
See eXtreme Programming (XP) in action at the hands of an XP master—and learn Microsoft .NET and C# programming in the process! In this fast-paced, hands-on exposition, Ron Jeffries—one of the leading voices and practitioners in the XP community—demonstrates that you can write well-designed, resilient code incrementally and safely, while minimizing your investment in speculative up-front design. As Jeffries builds his sample application, you get firsthand insights into what successful XP development looks like, complete with real-world challenges such as the eleventh-hour change order. For further practice and study, you can download all the author’s code—including the missteps—so you can see XP and agile concepts in action and assess how they fit into your own work.Pair program with an XP master, discovering how to:

Streamline and simplify the software development process

Work more effectively as part of an XP development team

Reduce missteps by designing, testing, and refining code in increments

Receive clearer specifications and feedback from customers

Write cleaner, more expressive code—and weed out more bugs

Conserve resources by planning and reassessing progress as you go

Maintain a sustainable work pace—and avoid burnout

Step up delivery dates, shipping the most crucial features first

Improve customer satisfaction!

Jeffries va explicando, cómo un equipo de dos personas (uno es él mismo) van aprendiendo sobre C#, .NET, mientras desarrollan el software XMLNotepad. Es muy interesante de leer, porque explica paso a paso lo que van haciendo: cómo hacen spikes, pequeñas exploraciones, luego vuelven a tests, avanzan poco a poco, escriben y se ponen de acuerdo con los tests de aceptación, las historias de usuario, cómo generan un modelo testeable, mockean parte de la interfaz de usuario, etc. Si Uds. tienen dudas sobre cómo es el desarrollo con Programación Extrema, si quiere conocer los detalles de un caso concreto, éste es el libro. Pueden aprovecharlo, sepan o no C#: la parte técnica no es la más importante, es la explicación detallada la que hace de este libro, un excelente recurso.

Hmm… ya va siendo hora de tener un sistema de biblioteca para el MUG, no? Podríamos armarlo usando XP… :-)

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Code Kata: Capturando páginas web

lopez — Mon, 26 Oct 2009 09:31:03 GMT

Para practicar, como Code Kata (y también, como prueba de concepto para un proyecto relacionado con Hacia una Historia Clínica Digital de Código Abierto), estuve codificando un programa de Web Scraping. Pueden bajarse el código completo desde: Web Scrapping Example (pensé que en inglés era “scrapping” con doble p, así que quedó por ahora con ese nombre :-)

La solución, escrita en C#, contiene un proyecto de librería de clases, uno de tests de Visual Studio, y un programa de demostración, del tipo consola. Fue interesante codificar un mini HTML parser (simple, que no contempla todos los casos, sólo los necesarios para el trabajo), que soporta el análisis de páginas mal formadas. El usar TDD (Test-Driven Development) me permitió ir codificándolo de forma de estar seguro de lo que necesitaba como resultado, y además, que ese resultado fuera el correcto. Ejemplo de test simple:

[TestMethod]

public void ParseSimpleTag()

    HtmlParser parser = new HtmlParser("<html>");

    HtmlToken token = parser.NextToken();

    Assert.IsNotNull(token);

    Assert.AreEqual(HtmlTokenType.Tag, token.TokenType);

    Assert.AreEqual("html", token.Name);

    Assert.IsNull(parser.NextToken());

Para capturar las páginas, usé System.Net.WebClient, con código tan simple como:

private string GetContent()

    WebClient webclient = new WebClient();

    return webclient.DownloadString(this.address);

Como demostración, en el programa de consola, parto de explorar la página:

Medline Plus Drugs

Lanzando el programa de consola, aparece la salida, capturando algunos cientos de páginas, sobre información de drogas medicinales (efectos, posología, contraindicaciones, etc):

Exploro las páginas que apuntan a la información de drogas por letra, obtengo los enlaces a cada droga, traigo el contenido de la página, extraigo la información que me interesa (descartando el principio y el fin de la página) por cada droga. Un ejemplo de página:

Al final, genero una página de índice:

Podría implementar un mejor parser de HTML, y algunas operaciones más de extracción de datos. Pero para lo que quería obtener, me bastó. Y fue una buena experiencia de TDD.

Si usan la información generada, recuerden de leer los términos del sitio original (entiendo que necesitan una autorización para usarlo de forma comercial, no parece que haya problema en capturar los datos en un utilitario no comercial).

¿Por qué no explorar directamente la web para obtener estos datos? Porque el contexto de la prueba de concepto que me impuse, es que los médicos y enfermeros no tienen acceso a Internet desde todas las máquinas donde van a estar trabajando.

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Tales from the Scrum: No esperemos a Superman

lopez — Sat, 24 Oct 2009 14:18:29 GMT

En estos días, buscando ejemplos de antipatrones de Scrum, me encuentro con el “Hero-Driven Development” (visiten todo el blog Scrum is Scrum). Hace poco comentaba sobre las “prima donnas” en desarrollo en Tales from the Scrum- No somos Q. El caso que quiero comentar ahora, es distinto. El desarrollador super héroe de nuestra historia, puede ser un tipo apreciado, querido por el equipo, reconocido en su campo. Es uno de esos desarrolladores que puede programar mucho más que los demás. Steve Mc Connell los llama 10X Developers. Pero puede causar problemas. Veamos (basado en el blog que mencioné):

Problema: En el medio del desarrollo, surge un problema. Puede ser una configuración de Windows Communication Foundation, un tema de mapeo de Hibernate, una instalación en JBoss. No importa. El problema es complejo, y bastante técnico. De pronto, se abre la ventana, y entra nuestro “programador héroe”, reluciente en su traje. Se sienta, mira el código, entiende el problema, y lo va solucionando. El equipo, arrobado, se queda atrás, mirando, cómo nuestro Superman del código, va resolviendo el más intricado nudo de desarrollo. El héroe, concentrado, no habla ni explica. Parece relajado, lo que hace es “pan comido” para él. Entonces, en un momento, para, el problema está solucionado, levanta la vista, mira al equipo, y sale volando por la ventana, directo hacia el atardecer. Gran música de fondo.

Contexto: El equipo no sabe cómo solucionar el problema técnico que surgió. Es algo en lo que tienen poca experiencia. Trataron de solucionarlo, pero no pudieron, y están entrando en pánico. Pasan las horas, y no avanzan. Todo está empantanado. Entonces, encienden la señal, para llamar al super héroe.

Fuerzas: Vivimos en tiempos de cumplir los compromisos que asumimos para la iteración. Queda poco tiempo para la entrega. Todo indica que necesitamos una solución rápida.

Solución: No hay que buscar solución rápida. Primero, habría que haber previsto el riesgo tecnológico, desde el propio equipo. Los miembros deberían haber anotado que en algún momento se toparían con una tecnología que no conocen, y tendrían que haber tomado la tarea asignándole más tiempo. Pero bueno, supongamos que no se pudo hacer eso. El problema de arriba, es que el equipo delega la solución FUERA del equipo. El equipo, de alguna forma, “se lava las manos”. La actitud del superhéroe también conspira para eso. No es ése el camino. El equipo no debería perder “ownership”, propiedad y responsabilidad del producto, y de cada pequeño o gran problema. El desarrollador super héroe, que los hay, debería haberse integrado al equipo, compartiendo su conocimiento. Debería actuar como consultor del resto del equipo, pero trabajando con él. Y cada cosa que haga, con el equipo, será considerada como cualquier otra tarea de otro miembro: deberá cumplir con los estilos pactados, las métricas adoptadas, la definición de “hecho”. No debe ser un miembro “distinguido”. Lo que haga, debe estar público y lo más entendible posible para el resto del equipo. Tal vez no consigamos una solución tan rápida como la de arriba. Pero seguramente, a largo plazo, estaremos construyendo un equipo más responsable.

Recuerden: uno de los grandes entregables, en Scrum, es el equipo.

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

VAN sobre Boo con Rodolfo Finochietti

lopez — Fri, 23 Oct 2009 09:22:26 GMT

Vuelven las VAN (Reuniones Virtuales) de ALT.NET Hispano. La próxima, es este sábado 24 de Octubre, a las 18:00 GMT/UTC (Greenwich) (En Buenos Aires, con GMT-3, serían las 3 de la tarde). El tema será, principalmente, el lenguaje Boo, a cargo del bueno de Rodolfo Finochietti (@rodofof).

Pueden ver detalles en

VAN sobre Boo con Rodolfo Finochietti, Sábado 24 de Octubre

Será en parte, continuación de la anterior

Alt.NET Hispano- VAN con Martín Salías y lenguajes en .NET

Pueden ver el video resultado de esa anterior reunión en:

Virtual ALT.NET sobre Lenguajes

Son todos temas como los que tratamos en algún TechNight de Buenos Aires, el año pasado: lenguajes de programación e implementaciones en .NET (ahí dejé bastantes enlaces sobre los temas que ahora están siendo actualizados en esta serie de VANs).

Según adelanta Rodolfo, el tema será:

Básicamente mi exposición se va a centrar en porque me gusta Boo. Todos los lenguajes estáticos en .NET son bastante similares (con el DLR esto cambio un poco), y esto creo yo tiene una razón que voy a explicar en el charla. En cambio Boo no se parece un lenguaje .NET. Su diseñador (Rodrigo De Oliveira) lo creo como un herramientas que le facilita la construcción de aplicaciones.

Resumiendo: Voy a hacer una intro al diseño de lenguajes estáticos en .NET y después me voy a centrar en Boo y sus características.

Recuerden:

Si no conocen qué es una reunión VAN, pueden consultar VAN meetings. Para ver cómo se desarrolla una VAN de ALT.NET Hispano, y qué software necesitan para asistir, ver Descripcion-de-Reuniones-VAN. Pueden ver el historial de anteriores reuniones VAN (visiten las que dieron, por ejemplo, sobre NHibernate, WPF y demás) (yo ya participé en VAN sobre Scrum y en otra sobre generación de código, que quedará publicada en estos días). Supongo (pero confirmen) que la URL de entrada de la VAN de Martín será http://snipr.com/virtualaltnet. Cualquier cosa, pueden consultar la lista de correo de ALT.NET Hispano. También pueden suscribirse para proponer nuevos temas, y colaborar con la comunidad.

Visiten el sitio de Boo si quieren averiguar más sobre el lenguaje, y lean el Boo Manifesto. Tomé la imagen del blog http://blogs.codehaus.org/people/bamboo/archives/boo.html.

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Enseñando a programar (Parte 1)

lopez — Mon, 19 Oct 2009 09:47:00 GMT

El tema que señala el título de este post es un tema amplísimo, del que habría tanto para decir y discutir. Veamos de tratar algunos puntos, que surgen de experiencia personal, e ideas sin probar que van rondando mi cabeza desde hace unos años.

Primero, una aclaración: si bien gran parte de mi actividad semanal (en estos tiempos, más del 60% del tiempo que empleo), está dedicado al dictado de cursos (en empresas e institutos acá en Argentina, o en charlas en distintas ciudades) me considero no un instructor de programación, sino un desarrollador de software que por esos accidentes de la vida terminó dedicando tanta cantidad de sus horas al dictado de clases. Pero no soy una persona pedagógica, o que haya estudiado para enseñar sino, como muchos otros instructores, soy alguien que programa y que muestra algunos temas de programación, desde mi propio óptica personal (hace años que no doy un curso oficial o de Sun o de Microsoft, prefiero dar mis temas a mi forma y con mis temarios).

Segundo: prefiero programar que enseñar. Contrariamente a lo que algunos de Uds. podrían pensar, para mí enseñar no es la mejor forma que imagina de pasar mi tiempo profesional, por lo menos en cursos presenciales de la forma en que me toca ahora dictar. Prefiero escribir, leer, programar ejemplos, pruebas de conceptos, aplicaciones completas, describir temas en posts, antes que estar dictando una clase presencial (una charla es otra cosa: es más interesante, es para presentar un tema, y llamar a la acción a los asistentes, sin tener que seguir por semanas hablando de lo mismo). Cuando tengo, digamos, un curso para las 18:30, ya sé que ese día no puedo trabajar hasta las 18hs en un proyecto, o no puedo irme a almorzar tarde, o no puedo salir de viaje a otra ciudad, o no puedo… o voy a salir demasiado tarde para ir a cenar tranquilo, o pasar por tal lado, o … y mil cosas más. Un curso es un clavo en el medio de cualquier agenda a armar. También pasa que un curso que no es nocturno, parte al medio cualquier día de trabajo, especialmente cuando trabajo en un equipo Scrum. Como los cursos tienen días ocupados durante varias semanas, también se me complica organizar cualquier visita al interior de mi país, para dar una charla sobre un tema. En definitiva, curso presencial con muchas clases, es un incordio para cualquier agenda.

Y una de las cosas que más me cansan, a esta altura de mi vida, es hablar, hablar y hablar durante horas en un curso. Vuelvo a mi cubil, a veces, bastante cansado y congestionado, nada más de hablar. Imagino que en cualquier momento comienzo a dar una clase mostrando cosas en el proyecto y explicando lo que hago escribiendo en el Notepad… :-)

Hechas esas confesiones personales, respiro hondo, y paso a comentar algunos problemas que detecto en los cursos que conozco, los míos.

Muchos de mis cursos se pueden circunscribir a estos tipos:

- Grupo de gente que conoce algo de programación, que pueden estar en distintos niveles, y quieren aprender un tema de tecnología, ejemplo: ASP.NET o JSP.

- Curso con máquina o sin máquina y proyector

Bien, comienzo por los temas que veo que no están del todo bien y se pueden mejorar, o cambiar completamente por otro “approach”.

Notemos que los cursos presenciales tienen un gran problema: son, justamente presenciales. Hay que combinar los horarios de todos los que quieren participar, reservar tal tiempo a tal hora y lugar; también tienen que estar todos presentes. Esto es un resabio de como se enseñaba en las universidades que comenzaron a aparecer en la Edad Media: como no había libros, el papel no existía o era caro y los profesores escasos, la única forma de enseñar era presencial: juntar un grupo que tenía que escuchar a un profesor mientras daba un tema. En aquellos años incluso se estudiaba para ejercitar la memoria ante la escasez de elementos para tomar apuntes.

Pasaron los siglos y veo seguimos con el mismo esquema. Algunos problemas derivados de esto:

- Cada asistente tiene que venir, a cada clase. Si llueve, si está complicado en el trabajo, si se enferma, por lo que fuera se pierde una clase que en generle al es irrecuperable presencialmente. Tiene que estar disponible cada día al horario en que se dicta el curso, por varias semanas a veces. Y si un día se le complica asistir lo más probable es que falte o que llegue tarde y no pueda aprovechar bien la clase.

- Cada asistente mismo tiene que estar con el ánimo más despierto, durante varias horas, para captar todo lo que se dicta en el curso.

- Como un curso presencial implica asignar recursos escasos, como lugar, proyector o máquinas, sala, etc., entonces cada clase dura por lo menos 3 horas durante las cuales o se dan demasiados temas, de tal forma que no hay tiempo de asimilar, o se dan pocos y el curso se encarece por durar más tiempo.

- El instructor tiene que explicar algo que ya explicó, probablemente, cuarenta veces.

- Como los asistentes, el instructor también tiene que estar con todas las luces, explicar de forma clara y tener todas las neuronas prendidas en cada clase, que se repite y repite a lo largo del año.

- No siempre el lugar de dictado es el adecuado: o no está cerca o no tiene todos los elementos en condiciones.

- No todos los asistentes tienen el mismo nivel de conocimientos inicial con lo que no todos van aprovechando el contenido de la misma forma.

- Si trabajan con máquina, el curso se alarga. Se necesita más tiempo para corregir ejemplos en cada máquina. También pasa que algunos asistentes terminan antes y otros quedan trabados. Coordinar las distintas velocidades es difícil de manejar. Muchas veces sugiero trabajar de a grupos, con poco éxito. Pasa cuando los asistentes son particulares que no se conocen entre sí y hay una máquina por persona: la gente prefiere encarar por su cuenta, en solitario, cada ejercicio. Esto trae como consecuencia que la clase se alarga. O hay que alargar el curso completo, con el consiguiente aumento del costo final.

- Aun teniendo práctica para captar un tema, un asistente puede necesitar su tiempo para entenderlo. Necesita practicar y jugar con un ejercicio un tiempo. No siempre es posible disponer de ese tiempo: muchas veces porque hay que seguir con otro tema.

- Si no trabajan con máquina, muchas veces los asistentes no se toman el tiempo para practicar. Hay varias razones: están tomando el curso en el trabajo pero no tienen máquina adecuada para practicar. O están tapados de trabajo y no tienen tiempo. O sus jefes no les asignan tiempo para practicar. O podrían practicar en una máquina personal, al volver a casa, pero ahí también: hay otros temas de que ocuparse. Me ha pasado dejar ejercicio a un curso y que de los veinte integrantes sólo uno o dos practicó algo entre dos clases. Cuando esto se repite, a lo largo de las clases, llega un momento que el contenido que se trata no se asimila porque no se practicó lo anterior. Llegados a ese punto, sin práctica de lo ya tratado es difícil captar todas las facetas del contenido nuevo. También a algunos asistentes se les complica instalar todo lo que necesitan para practicar. Una vez, recuerdo, puse un ejercicio entre clases en un curso de cuarenta personas. Lo escribí mal planteado a propósito. A la siguiente clase, solo uno de los asistentes se dio cuenta del problema: era el único que lo había encarado.

- El lugar de dictado puede estar a varios kilómetros de donde un asistente vive y trabaja.

- Si el curso es en el propio trabajo, un asistente puede sufrir interrupciones, o por tener un tema "urgente" para solucionar, debe abandonar la clase.

- Si el curso es en el trabajo, pero después o antes de hora de oficina, a muchos no les es fácil participar por tener otras actividades o no poder llegar más temprano.

- De vez en cuando me pasa que algunos asistentes no tienen mucha motivación para hacer el curso: los “mandaron” al curso y no tienen un soporte, un apoyo, de parte de sus empleadores, para sacar provecho del mismo (especulo, pero eso puede ser también un “test de proactividad” de su empleador o contratante).

- Otras veces, el asistente está motivado porque necesita trabajar pero hace tiempo que no toma un curso. Las tecnologías nuevas lo sobrepasan y termina necesitando de más tiempo para aprovechar el contenido.

- Si el curso es por cuenta de cada integrante, no lo paga una empresa, entonces probablemente tenga que asistir después de hora un día de semana o un sábado. En esos horarios también tendrá que pelear su tiempo con otras actividades, familiares, o de estudio formal.

- El temario es introductorio para un lenguaje de programación, pero no se enseña a programa. Se pide explícitamente que se conozca de programar y de base de datos. Y algunos asistentes no tienen esos conocimientos en firme.

- Otro caso es cuando el temario es intermedio o avanzado. Puede pasar que de los que asisten, algunos ya saben varios puntos del temario y se aburren. Mientras, otros necesitan repasar o incluso aprender un tema, porque no llegan al nivel que se necesita para el curso. Esto pasa cuando los cursos son para asistentes de distintas empresas o que se inscriben por su cuenta.

- Cuando el temario lo arma una empresa, el que arma el temario pide todos los temas habidos y por haber, pero luego no se asigna tiempo para que los asistentes practiquen en el medio del trabajo de cada día.

- Prácticamente todo el material que doy queda disponible en mi sitio personal. A la quinta o sexta clase del curso, alguien se acerca y me pregunta: ¿dónde puedo bajar los ejemplos? Yo me pregunto entonces: ¿cómo hizo para seguir las anteriores clases, si nunca repasó los ejemplos que YA se dieron? Detecto acá que no han tenido tiempo para practicar entre clases.

Y en mi caso en particular, muchas veces los cursos no se abren por falta de inscriptos: se necesita un número mínimo para costear los activos inmovilizados (proyector, máquinas si es con práctica, lugar, instructor) que no siempre se cubre. También me pasa armar una lista de correo para los asistentes del curso (por ejemplo, en los míos de Java) . Luego de dos años, les cuento que solo cuatro personas, entre decenas que asistieron, se inscribieron para hacer más preguntas.

No quisiera afirmar que siempre es así como describo arriba. Pero me asombra la cantidad de veces que algunos de esos “anti-patrones” aparecen, por lo menos, en muchos de los cursos que me ha tocado dictar. Así que pienso, desde hace algún tiempo, que debo mejorar en algunos temas. O motivar más, o hacer algo para que estos anti-patrones no aparezcan tan frecuentemente. Una sorpresa agradable: los cursos de Scrum son los más participativos de todos: son casos donde prácticamente no prácticamente no aparecen estos “issues”.

Y un tema, disculpen, más personal: otra “constante” que detecto. Ante un curso de cuarenta personas, pregunto cuántos conocen mi blog. Sólo uno levanta la mano. Pasan las semanas, y al final del curso, después de dos meses, pregunto de nuevo. Y ahora, son 1 o 2 las manos levantadas. Así que algo tengo que hacer: o mejorar los contenidos o escribir más claro o de temas que les interesen más. Muchas veces escribo para que lo explicado quede más claro. Si algo no se entiende en una clase presencial, quisiera que se pueda leer y releer por acá. Pero veo que he tenido poca llegada en ese tema, por lo menos en los asistentes a mis cursos presenciales.

Pero también detecto y especulo un patrón: los que programan y no leen blogs (mío o de cualquiera), en general, no se mantienen actualizados y necesitan cursos presenciales. Los que programan y leen blogs son otro grupo: se mantienen actualizados y no necesitan cursos presenciales, apenas algunas charlas introductorias como primeros pasos en un tema. Luego, ellos mismos aprenden de una nueva tecnología, patrón, estilo arquitectónico o herramienta.

Habiendo repasado estos puntos, ¿cómo se podría mejorar? Tengo algunas ideas al respecto, tomadas de otros ámbitos, y de lo que veo que puede funcionar, pero son temas para seguir en la segunda parte de este post. Mientras tanto: ¿tienen alguna sugerencia?

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Desarrollando aplicaciones en .NET

lopez — Mon, 12 Oct 2009 17:08:40 GMT

En esta semana, comienzo a dictar el curso presencial que había anunciado en un anterior post:

Preparando un curso de .NET: aplicaciones, patrones y arquitectura

organizado por la gente del Microsoft Users Group de Argentina. Gracias a todos los que dejaron sugerencias sobre el temario, ahí, y en listas de correo que consulté. Es un curso pago, pueden obtener más información en la página de inscripción al curso.

El temario a desarrollar es ambicioso:

Arquitectura de aplicaciones .NET
Capas lógicas, capas físicas
El gran Service Layer
Persistencia
Object Relational Mapping
NHibernate, otros ORMs
Reglas de Negocio
Test-Driven Development
Rhino Mocks, Moq, otros
Inyección de dependencias
Spring Framework y otros
Separando responsabilidades
Conceptos de Autorización, Autenticación, y Seguridad Federada
Patrones en presentación: MVC, MVP, otros
Tecnologías de presentación: WinForms, ASP.NET, ASP.NET MVC, conceptos de WPF, Silverlight
Propuestas de Microsoft de Arquitectura
Modelo de Dominio
Domain-Driven Development
Desarrollo en equipo
Conceptos de Metodologías Agiles, XP, Scrum
Repositorio de Código
Integración Continua

además de algunas alternativas “exóticas” a explorar, como para amenizar estos temas. Presentaré ejemplos propios y otros de código abierto que están publicados en Internet.

La idea es ir transmitiendo algunas de las técnicas e ideas que se están usando, para llevar a cabo un desarrollo en .NET. Bien podría dar un curso similar en Java: ambas plataformas son lo bastante maduras como para que podamos usarla en todos estos temas, y más. Y mucho de lo que se usa hoy en .NET, nació primero en Java y otras tecnologías.

Mi idea es ir volcando por aquí, en este blog, algunos apuntes, resúmenes, notas de lo que dicte en el curso presencial. También compartir por acá enlaces sobre los temas que visitemos (más ejemplos, posts, herramientas, librerías). Es una forma de pasar en limpio, todo lo que entre todos tratemos en el curso, para que no quede solamente para los que asisten. Siempre dejo los ejemplos de los cursos que dicto en mi sitio, en Cursos y Seminarios: Ejemplos, Enlaces y Recursos, pero esta vez quisiera ir más lejos, y poner por escrito gran parte de lo que desarrollemos en el curso.

Son varios temas: intentaré mostrar cómo se derivan de unos pocos principios y necesidades, en principio, de la complejidad y el cambio que acompañan a cualquier sistema de software no trivial y exitoso de estos días.

(Tomé la imagen de este post de http://www.leansoftwareinstitute.com/blog/, creo que refleja la belleza y complejidad de construir software).

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Microsoft MVP (Most Valuable Professional) otro año más, y el futuro del software

lopez — Sat, 10 Oct 2009 14:36:00 GMT

El pasado 1ro. de Octubre, me confirmaron que nuevamente, en este año que sigue, soy Microsoft MVP. Pueden ver detalles del programa en:

http://mvp.support.microsoft.com/

Quiero agradecer a Néstor Portillo (@nportillo) y Fernando García Loera (@ferglo) por su apoyo en todos estos años. También, a Carlos “Billy” Reynoso, quien me propuso como MVP en 2002 (vio la luz!! :-), luego de haberme convocado también en los 90 para participar de charlas y reuniones. Y a la gente del Microsoft User Group, del que participo desde hace casi 15 años, por el constante trabajo para armar una comunidad en la que podemos participar todos.

Me gustaría que otras empresas tuvieran un programa similar a los Microsoft MVPs. No sé si hay programas como éste en Oracle/Sun, IBM. En Argentina, la empresa que más se ha preocupado (con altibajos, hay que reconocer) ha sido Microsoft. Recuerdo los tiempos de Sun lanzando Java por estos lares, en los noventa. Estaba más preocupada por captar periodistas que a programadores. Si alguna vez me invitaron a una charla en los noventa, fue porque escribía para una revista, sino, ni enterados la gente de Sun de que hay programadores de este lado del ecuador.

Recuerdo mis primeros contactos con la tecnología Microsoft, al leer la Dr.Dobb’s Journal, donde se comentaban algunos productos. ¿Recuerdan Lattice C? Microsoft lo compró para ser su primer Microsoft C. ¿Alguien recuerda el Lisp de Microsoft? Creo que se lo habían comprado a una cía de Haway. Conocí más de la historia de esos tiempos en varios libros; en especial, recuerdo “Fire in the Valley”. También ahí aprendí de Apple, MITS y demás pioneros en la microcomputación. En esos tiempos, había multitud de “computadoras personales”, con distintos sistemas operativos y lenguajes. En muchas de ellas, Microsoft tenía software para ofrecer. Pero todos conocemos que el mercado despegó con la llegada de la IBM PC. Recuerdo que para editar con el edlin, booteaba con un diskette, lo retiraba, y ponía el segundo, porque ahí estaba el editor de línea. Como diría Olmedo: “Eramos tan pobres…. " :-). Si bien llegó Apple a mi país, Argentina, en aquellos años había que ser descendiente directo de los que desembarcaron en el Mayflower para poder acceder al programa de desarrollo de aplicaciones de la empresa de la manzanita. Algunos detalles más de esos tiempos, en

Treinta años en desarrollo de software

Creo que, como entonces, vivimos tiempos fascinantes en el tema de desarrollo de software. Me gustaría escribir acá algunos puntos a estudiar, a seguir de cerca, en estos años que se vienen (espero que para mí, sean otros treinta años… :-)

Primero, quiero destacar la existencia de dos plataformas de desarrollo: Java y .NET. Entiendo por plataforma de desarrollo a lenguaje(s), librería de clases extensa, soporte de desarrollo de distinto tipos de aplicaciones (desde consola a web a distribuidas). En el 95, comencé a conocer Java, y desde entonces, me ha parecido una de las mejores cosas que ha pasado en la historia del desarrollo de software. Con todas las críticas que se le pueden hacer (EJB una terrible cosa que aún me dá escalofríos (antes de acostarme, veo abajo de mi cama a ver si hay algún Entity Bean escondido), Sun como karma, empresa que no supo mover a la comunidad de desarrollo, que en muchos casos se tuvo que arreglar sola (Hibernate como ejemplo?)), Java ha sido lo que hizo que las máquinas virtuales, clases y objetos, frameworks, threads, serialización, modelos de dominio, salieran de lo académico o del nicho, y pasaran a la corriente principal de desarrollo. Desde fines de los noventa, no he pasado casi una semana, sin dar algún curso o charla sobre Java, y tecnologías asociadas. Es un “must be know” para cualquier desarrollador de software de este milenio.

Y Microsoft, vió la luz, y se reinventó a sí misma: abandonó VB, VBScript, ASP, C++ con la infame MFC (Microsoft Foundation Classes), ATL, COM (que nunca despegó para multiplataforma, como hubiera querido Don Box, y aún Miguel de Icaza con el proyecto Bonobo), y cambió como empresa, por lo menos en las herramientas de desarrollo. Parecía como si hubiera hecho todo por otra empresa: no más COM como tecnología necesaria; teníamos al fin una máquina virtual (un empleado de Microsoft morirá en la tortura antes de llamar “máquina virtual” al CLR, pero, es lo que es.. :-); plétora de lenguajes nuevos, totalmente montados sobre esa máquina virtual. Realmente, es como si hubiera habido otra empresa que creó todo eso. Un gran movimiento por parte de Microsoft, que ha sabido adaptarse a los tiempos que le tocan: como ejemplo, recuerden el giro a Internet que dió la empresa, a finales del 95.

Así que tenemos dos temas para seguir con atención: Java y .NET.

Otros temas: el desarrollo de aplicaciones, ¿dónde va? Veo que sigue habiendo aplicaciones de escritorio. Pero preveo que la lucha y la innovación vendrán en otras áreas (enlaces al final):

- Aplicaciones Web: dentro de la empresa, los sistemas de gestión serán migrados a todo web. Si bien la interfaz web no es la mejor, la aparición de Ajax, librerías maduras de Javascript, tecnologías en el servidor (ASP.NET, ASP.NET MVC, veremos hacia donde va Java, luego de no haberse adoptado JSF por todo el mundo, Ruby y Python con desarrollo web), hoy no es descabellado ver cada vez más aplicaciones internas, expuestas en el browser.

- Rich Internet Applications: usar JavaFX, Silverlight, Air, o lo que aparezca. Pero crear aplicaciones, que mediante algún plugin liviano en el cliente, permitan tener la experiencia de usuario del tipo de aplicaciones locales que tenemos ahora.

- Software as a Service, tanto aplicaciones web (Google Apps) como RIA, el software de gestión y otros tipos, que hoy consumimos localmente, veo que estará cada vez más ofertado directamente en la web. Habrá que ver quienes serán el target: ¿las pequeñas empresas que no tienen un equipo de IT? ¿las medianas y grandes, que están cansadas de soportar un equipo de IT y desarrollo semi a a medida?

- Desarrollos Web2.0: la interconexión de aplicaciones mediante protocolos livianos (desde REST hasta cualquier otra cosa, olvidando los pesados Web Services, especificación que veo que se encamina a la over-complexity), modelos pubsub montados sobre Twitter o similares, la aparición de Service Bus online.

- Cloud computing: lo veo de dos formas: como una forma de virtualización as a service, y como una forma de aplicación escalable hacia afuera. La primera será más fácil de programar (es como venimos hasta ahora, pero “hosteando” en otro lado). Nos ahorramos el setup de la máquina, licencias, mantenimiento del equipo. Lo de escalable hacia afuera, más cercano a la idea de “cloud”, ejecutando en varias máquinas, habrá que estudiar cuán de difícil o fácil es el cambio de modelo de programación. Ejemplo: sharding de base de datos, ¿será lo suficientemente transparente para como venimos programando?

- Mobile: o debería llamarlo, la aparición del software en múltiples dispositivos. Esto es una rama que tenemos que estar atentos. La industria de desarrollo está por dar un salto, o ya lo está dando: tal vez, el mayor desde la aparición de la computadora personal. La cabeza de playa son los teléfonos móviles. Pero lo que veo es: sistemas operativos para pequeños dispositivos (Android, Windows Mobile) con soporte de desarrollo (Android SDK, .NET Compact Framework), que harán que podamos escribir software para casi cualquier cosa, cualquier “widget” que tengamos (teléfonos personales, otros dispositivos, aparatos inteligentes), comunicados por Internet. La convergencia de: dispositivos inteligentes, Internet, herramientas de desarrollo maduras, es “the next big frontier”.

- Lenguajes dinámicos: podrá haber lenguajes aislados (como los originales Ruby y Python) pero veo que cada vez más se montarán sobre las dos plataformas, .NET y/o Java. Veremos que pasa con esto: lo que veo, es que tienen comunidades fuertes, que impulsan nuevas cosas, nuevas ideas (o reimplementaciones frescas de otras ideas), que en otros ecosistemas más maduros es difícil de que prendan. Recordemos Ruby On Rails como un ejemplo.

- Web Semántica: ahí afuera hay un mundo de información, que por primera vez está disponible, no sólo para seres humanos, sino para nuestras aplicaciones. La aparición de formas de aprovechar inteligentemente esta montaña(cordillera diría) de información, es un camino que veremos donde llega. Las iniciativas de web semántica son lo más promisorio. Pero también puede que “la liebre salte por otro lado”: desarrollos aislados, que encuentren una forma de comunicarse o de aprovechar lo existente.

- Aplicaciones distribuidas: los que leen mi blog (yo, y mi tía Carlota), saben de mi interés en aplicaciones distribuidas. Habrá que seguir de cerca el tema message passing, o el más prometedor y flexible, agentes. Multithreading, multicore, son simplemente una antesala a Multimachine. Ese es el camino a al escalabilidad, y superar el bloque de la Ley de Moore: multicore está bien, pero multimachine is the solution (pregúntele a Google). Sharding de base de datos, escalabilidad, datos y objetos en memoria distribuida en máquinas (más barata y rápida que los discos).

- Memoria: El último párrafo me trae a cuento esto que siempre nombro: el uso intensivo de memoria. La memoria cada vez es más barata, y más accesible. Pensemos en qué tipo de aplicaciones podemos lograr. Me imagino una base de objetos o de datos, totalmente en memoria, en máquinas distribuidas, donde el file system sea solamente otra forma de backup.

- Concurrencia y Paralelismo: un tema a estudiar. Vean lo que va surgiendo con Clojure, Software Transactional Memory, hasta NetLogo. Vería de cerca paralelismo distribuido, como MapReduce, High Performance Computing, y alrededores.

- Lenguajes funcionales: recuerdo APL, pero no con cariño. Pero vean el surgimiento de Erlang, la forma en que se usó para el desarrollo de aplicaciones, el “revival” de Lisp con Clojure y cía, F# por parte de Microsoft, Haskell, algo mixto con Scala en Java. Sumaría a los declarativos, como Prolog. ¿Será el siglo del lambda? Para mí, es hermoso que esos temas vuelvan a estar en el tapete. Todo desarrollador de software debería sumergirse en estos temas, en lo que podría llamar, los lenguajes de los dioses.

- Modelos de aplicaciones: las aplicaciones cada vez son más complejas. Encarar el desarrollo basado prácticamente en lenguajes de tercera generación, sin haber elevado el nivel de abstracción, con tecnologías de base que van cambiando año a año, mes a mes, es un camino lleno de piedras y espinas. Yo apuesto a la aparición de modelos, Domain Specific Models, Domain Specific Languages, herramientas relacionadas (el camino más cercano es la generación de código), para hacer más fácil el domino de la complejidad y el cambio.

- Desarrollo ágil: en los tiempos que corren, el trabajo en equipo es indispensable. La cantidad de tecnologías, detalles, y requerimientos que precisa un software más o menos normal, implican que va desapareciendo el desarrollador de garage, en solitario. Las limitaciones de desarrollo en cascadas, el cambio en los requerimientos, porque hasta el ambiente externo cambia, éxitos cosechados por el programación extrema y disciplinas relacionadas, todo apunta a que tenemos que ir adoptando más y más el modo ágil de construir software.

- Inteligencia Artificial: como decía más arriba, es tiempo de que agentes. Incorporar lógica, razonamiento, modelos del mundo, inferencias, objetivos, ontologías, algoritmos genéticos, redes neuronales, en todo lo que se viene.

(ahora entenderán un poco más, a que van los códigos de código abierto que publico, como una especie de ejercicio personal para entrenarme en varios de los puntos de arriba).

No he dejado enlaces en el texto, pero muchos de estos temas, como verán, me interesan desde hace un tiempo, y estos son enlaces que he coleccionado:

Tendría más para comentar, pero es hora de tomar mi medicación…:-)… Sí, ya sé, es la pastilla roja, no la verde.

Me parece suficiente para este post, ¿no les parece?

Lo que quería trasmitirles, es que aprovechen este tiempo. Hace treinta años, yo no tenía todo esto disponible: comunicación instantánea, acceso a recursos a un costo razonable, contacto con la comunidad, herramientas maduras, ideas bullendo. Y ahora está todo acá, servido para la próxima revolución.

Muchas de estas ideas, las comento en mis cursos, aunque no sé cuán bien pude trasmitirlas, o si se entendió algo del mensaje. Siempre veo que la gente pide cursos de un tema en particular, me gustaría en este post (como en otros anteriores) haber dado una visión más amplia de lo que hay en el mundo del desarrollo de software, hoy, y que sirva de ensayo futurológico, sin mayores pretensiones, de lo que puede venir como importante.

De alguna forma, en estos años, se decidirá el tipo de software que se ejecutará en las próximas dos décadas. Y como en las anteriores, el software seguirá cambiando la historia humana.

Pero el software no se hace solo. Como decía Alan Kay: “la mejor forma de predecir el futuro, es inventándolo”. Sean parte de todo esto.

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Alt.NET Hispano: VAN con Martín Salías y lenguajes en .NET

lopez — Thu, 01 Oct 2009 09:32:57 GMT

Este viernes, 2 de Octubre, la comunidad de Alt.NET Hispano preparar una VAN (desconferencia, reunión virtual), a las 5:00pm GMT (2 de la tarde acá en Buenos Aires), sobre lenguajes en .NET, con el bueno de Martín Salías (@MartinSalias). Pueden ver más detalle en:

Por primera vez tendremos VAN entre semana con Martín Salías

Explica ahí Martín:

mi idea es charlar un poco entre todos sobre el florecimiento de los lenguajes en entornos manejados. Me parece que no es coincidencia que en el ambiente Java esté pasando algo similar a lo que tenemos en .NET.

Lenguajes Dinámicos:
JVM: Jython, JRuby, Groovy
.NET: IronPython, IronRuby

Lenguajes funcionales:
JVM: Scala, Clojure
.NET: F#, C# (¡cada vez más!)

Otros:
Ioke (JVM/.NET), Boo (.NET)

…

Me parece interesante repasar juntos los objetivos y desarrollo histórico del CLR, el DLR, y cómo impactó en esta nueva tanda de lenguajes la influencia del ambiente Open Source, que es tan cercano al espíritu Alt.NET.

El bueno de Martín, menciona algunos proyectos míos de lenguajes… snif… me van a hacer llorar de la emoción… snif… :-)

Si no conocen qué es una reunión VAN, pueden consultar VAN meetings. Para ver cómo se desarrolla una VAN de ALT.NET Hispano, y qué software necesitan para asistir, ver Descripcion-de-Reuniones-VAN. Pueden ver el historial de anteriores reuniones VAN (visiten las que dieron, por ejemplo, sobre NHibernate, WPF y demás) (yo ya participé en VAN sobre Scrum y en otra sobre generación de código, que quedará publicada en estos días). Supongo (pero confirmen) que la URL de entrada de la VAN de Martín será http://snipr.com/virtualaltnet. Cualquier cosa, pueden consultar la lista de correo de ALT.NET Hispano. También pueden suscribirse para proponer nuevos temas, y colaborar con la comunidad.

El año pasado con Rodolfo Finochietti (@rodofof) y Martín, dimos un Technight en las oficinas de Microsoft Argentina (Buenos Aires), sobre lenguajes de programación e implementaciones en .NET. (Lean el material de Rodolfo sobre C# 4.0). Me pareció muy interesante esa charla, y me divertí mucho preparándola y compartiéndola con Martín y Rodolfo. Creo que deberíamos invitar a Rodolfo para que siga con una próxima VAN completando el tema que inicia Martín.

Post relacionados:

Javascript, la programación del futuro
Babel de lenguajes en .NET
Papas fritas, cervezas y una babel de esos raros lenguajes nuevos

(Me gustó tanto la pintura de la Torre de Babel, aludiendo a múltiples lenguajes, que usé en otro post, que la vuelvo a usar acá, con mi propio permiso… :-)

Como es hábito, colecciono enlaces sobre estos temas en:

Bueno, como siempre, los enlaces de estos temas, que colecciono, desde:

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

VAN (Reunión Virtual) en ALT.NET Hispano sobre Generación de Código

lopez — Fri, 25 Sep 2009 09:32:16 GMT

Gracias a la comunidad de ALT.NET Hispano, mañana sábado 26 de septiembre, participaré de una VAN (Reunión virtual) sobre generación de código (hora internacional 6PM GMT, son15hs Buenos Aires). La idea es que al principio presente algunas ideas, ejemplos de AjGenesis, panorama de generación de código, comentar otras herramientas y aproximaciones, pros y contras, y luego, se discutan los temas, entre todos.

Quisiera presentar:

Los por qué de la generación del código
Qué pedirle a una herramienta de generación de código
Elevar el nivel de abstracción, partiendo de un modelo
Resolviendo paso a paso, la aplicación más simple
Mostrar que es más que templates/plantillas
Resolver una aplicación con entidades, desde el mismo modelo, en distintas tecnologías y plataformas (Java, .NET, PHP)
Generación de código como servicio en línea

Si no conocen qué es una reunión VAN, pueden consultar VAN meetings

Para ver cómo se desarrolla una VAN de ALT.NET Hispano, y qué software necesitan para asistir, ver Descripcion-de-Reuniones-VAN

Pueden ver el historial de anteriores reuniones VAN (visiten las que dieron, por ejemplo, sobre NHibernate, WPF y demás)(ya había participado de VAN sobre Scrum).

Gracias al bueno de Jorge Gamba (@jorgegamba) que publicó el evento en su blog:

[Evento] Viendo la luz respecto a “Generación de Código”

Copio de ahí:

La comunidad ALT.NET Hispano realizará un evento virtual con el tema Generación de Código, con la exposición principal del reconocido especialista y maestro en desarrollo de software Angel “Java” Lopez. Será el día sábado 26 de septiembre a la hora internacional 18:00 GMT/GTU (Greenwich), con una duración aproximada de 2 horas. Para atender la reunión deben usar el programa Microsoft Office Live Meeting 2007 client, abriendo el enlace http://snipr.com/virtualaltnet.

Adicionalmente, pueden plantear sus comentarios e inquietudes sobre el tema de la reunión en la discusión Invitación a VAN Hispano Sábado 26 de septiembre - "Generación de código" con Angel "Java" Lopez, en nuestra lista de correo.

La comunidad ALT.NET hispano está muy activa, y los invito a participar de ella. Jorge escribe:

les dejo la lista de recursos compartidos de los que disponemos en la comunidad:

Lista de Correo del Grupo de Usuarios

Wiki

Twitter

Facebook

viddler

Mapa de ubicación geográfica

Calendario de eventos

Como comenta Jorge, pueden ir leyendo:

Sobre la generación de código
Diez reglas principales en generación de código
La generación de código y el trabajo de desarrollo de software

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

AjSharp: un lenguaje dinámico en C#

lopez — Tue, 22 Sep 2009 10:04:06 GMT

Durante el desarrollo de AjGenesis, mi proyecto de generación de código, definí y usé un lenguaje interpretado, llamdado AjBasic, que me dió libertad para implementar tareas, plantillas y acceso a .NET, de una forma muy flexible. El año pasado comencé a separar la implementación de AjBasic del núcleo de AjGenesis, para poder irlo mejorando. Escribí el núcleo de un intérprete, AjInterpreter, y como prueba de concepto, construí sobre él a AjBasic, y a otro lenguaje AjSharp, con una sintaxis más tipo C#. Más információn en:

AjSharp- a C Sharp-like interpreter, work in progress
AjSharp – un intérprete a la C# trabajo en progreso

Ahora, este año, lo reescribí en una implementación nueva, dentro de mi AjCodeKatas Google Code. El núcleo del intérprete es ahora AjLanguage, y AjSharp es el lenguaje con un parser que se apoya en la “virtual machine” que da el AjLanguage, para armar y ejecutar un árbol de comandos y expresiones:

Pueden ver el código en desarrollo y bajarlo desde:

http://code.google.com/p/ajcodekatas/source/browse/#svn/trunk/AjLanguage

Variables, expresiones y comandos

Las variables no son tipadas, y son automáticamente declaradas cuando son usadas:

a = 1;

b = 2;

Estas variables contienen valores enteros, pero pueden asignarles valores de otros tipos en cualquier momento:

a = “one”;

b = “two”;

Los comandos habituales son soportados:

if (k>0)

   return;

for (k=1; k<=10; k++)

   sum = k+sum;

while (j<10)

   DoProcess(j);

foreach (element in elements)

   AddElement(element);

Las condiciones puede ser cualquier expresión, no solamente una que de resultado booleano. Ver más adelante, la explicación sobre el valor False.

Funciones y rutinas

Esta es la sintaxies para escribir una función factorial.

function Factorial(n)

    if (n<=1)

        return 1;

    return n * Factorial(n-1);

La palabra sub puede ser usada para definir subrutinas.

Funciones y subrutinas son como cualquier otrosvalores. Puede ser definidos sin nombre y asignados a variables:

Add1 = function (n) { return n+1; }

two = Add1(1);

function Apply(func,values)

    list = new List();

    foreach (value in values)

        list.Add(func(value));

    return list;

numbers = new List();

numbers.Add(1);

numbers.Add(2);

numbers.Add(3);

function Square(n) { return n*n; }

squared = Apply(Square, numbers);

squared2 = Apply(function (n) { return n*n; }, numbers);

Manejo de objetos .NET nativos

Uno de los objetivos de diseño de AjLanguage es que pudiera acceder a objetos .NET. Pueden ser creados con la palabra new:

ds = new System.Data.DataSet();

dinfo = new System.IO.DirectoryInfo(“.”);

foreach (fi in dinfo.GetFiles()) {

    PrintLine(fi.FullName);

Objetos dynámicos

Pueden ser creados usando la palabra new. Un objeto dinámico acepta nuevos miembros (variables y métodos):

dynobj = new DynamicObject();

dynobj.FirstName = “Adam”;

dynobj.LastName = "Genesis”;

dynobj.Age = 800;

dynobj.FullName = function() { return FirstName + “ “ + LastName; }

Otra notación:

dynobj = new { Name = “Adam”, Age = 800 };

Otra notación:

dynobj = new { var FirstName = “Adam”; var LastName = “Genesis”;

 function FullName() { return FirstName + “ “ + LastName; }

Los objetos dinámicos se definen automáticamente, poniendo valores en sus propiedades:

Project.Database.Provider = “…”;

Project.Database.ConnectionString = “…”;

crea el objeto dinámico Project, con una propiedada Database que es a su vez otro objeto dinámico. Ese código equivale a:

Project = new DynamicObject();

Project.Database = new DynamicObject();

Project.Database.Provider = “…”;

Project.Database.ConnectionString = “…”;

Un experimento (veré si queda en la implementación final) las litas se definen automáticamente usando el método Add:

Project.Entities.Add(new { Name = “Customer”, Table = “dbo.Customers” });

equivale a:

Project = new DynamicObject();

Project.Entities = new List();

Project.Entities.Add(new { Name = “Customer”, Table = “dbo.Customers” });

Clases dinámicas

Una clase puede ser definida usando esta sintaxis:

class Person {

    var FirstName;

    var LastName;

    var Age;

    function FullName() {

        return FirstName + “ “ +

            LastName;

Una nueva instancia puede ser creada como siempre:

adam = new Person() { FirstName = “Adam”, LastName = “Genesis”, Age = 800 };

La instancia, a su vez, es dinámica: nuevos miembros pueder serle adosados, y pueden agregar o redefinir métodos:

adam.FullName = function() { return “The “ + FirstName; };

Pueden crear una clase como un valor:

Person = new DynamicClass();

pero todavía tengo que definir bien la interfaz para agregar miembros de instancia.

Clases ya definidas

Hay algunas clases predefinidas:

dynobj = new DynamicObject();

list = new List(); // implementing IList

dict= new Dictionary(); // implementing IDictionary

Funciones primitivas

Hay unas pocas funciones y subrutinas definidas:

Print(“Hello”);

PrintLine(“Hello World”);

Hay tres funciones predefenidas para ejecutar y evaluar código dinámicamente:

Include("program.ajs");

Evaluate("k+1");

Execute("k=1;");

Include ejecuta los comandos dentro de un archivo. Evalue analiza y evalúa una expresión. Execute compila y ejecuta comandos.

El valor false

Cualquier valor que sea false, null, 0 o el string vacío, será evaluado como falso dentro de una expresión condicional:

if (k)

    PrintLine(“true”);

else

    PrintLine(“false”);

El ejemplo de arriba imprime “false” en ejecución, si k es zero o indefinida. Si una variable es indefinida, cualquier acceso a sus miembros (que no sean métodos) retorna null, no una exception:

if (Project.Database.ConnectionString)

    PrintLine(“true”);

else

    PrintLine(“false”);

Este comando imprime de nuevo “false”, si la variable Project está indefinida.

Arreglos, listas y diccionarios

Vectores nativos puede ser definidos, usando una longitud:

firstprimes = new int[10];

o con valores:

firstprimes = new int[] { 1, 2, 3, 5, 7, 9 };

Una lista es creada dinámicamente si comenzamos a asignar valores con subíndices consecutivos, desde 0, a una variable no definida aún:

numbers[0] = “zero”;

numbers[1] = “one”;

numbers[2] = “two”;

numbers[3] = “three”;

Un diccionario es automáticamente creado si los subíndices no son numéricos:

numbers[“one”] = 1;

numbers[“two”] = 2;

numbers[“three”] = 3;

Si necesitan más características, siempre pueden usar el framework .NET nativo.

Interfaz de consola

El proyecto AjSharp.Console es una aplicación de consola, donde pueden ingresar y ejecutar comandos AjSharp (no expresiones):

No hay comando para salir, todavía. Simplemente, Control+C en Windows (no lo probé, pero todo el código debería ser recompilable en Mono).

Próximos pasos

Hay varias cosas que quisiera agregar. Una lista parcial:

- Implementar AjBasic como otro lenguaje que use AjLanguage
- Soporte de Generics
- Soporte de plantillas/templates (como en AjGenesis)
- Integrar a la generación de código de AjGenesis
- Compilar el AST a Dynamic Language Runtime (DLR)

Nos leemos!

Angel “Java” Lopez

http://www.ajlopez.com
http://twitter.com/ajlopez

Preparando un curso de .NET: aplicaciones, patrones y arquitectura

lopez — Sat, 19 Sep 2009 14:20:00 GMT

Estoy preparando los temas y material, para un curso que dictaré en el Microsoft User Group de Argentina, en Octubre (seguramente quedará anunciado en el sitio del MUG). La idea es ir más allá de lo que ya dí en los cursos de .NET clásico (donde se muestra el framework, distintos tipos de aplicaciones), y un poco más extenso que el que ya dí sobre Arquitectura .NET.

Mi lista de temas (tentativo) a tratar, con ejemplos a desarrollar (tengo que ordenar los temas):

Capas lógicas, y el gran patrón: Service Layer
Capas físicas, Service Interface/Service Gateway
Object Relational Mapping
Domain-Driven Design
Test-Driven Development
Dependency Injection
Validaciones y Reglas de Negocio
Cambiando la presentación
Model View Controller, Model View Presenter y variantes (con distintas tecnologías de presentación)
Esas raras arquitecturas nuevas: aplicaciones distribuidas, grid computing, sharding, …
Tecnologías: WinForms, ASP.NET, ASP.NET MVC, ASP.NET Ajax, WPF (quizás Silverlight)
Herramientas y librerías: Moq, NUnit, NHibernate, VS Tests, Spring.NET, Rhino Mocks, …

y seguramente algún proyecto AjX… :-)

Como siempre, lo que produzcamos en el curso, enlaces a ejemplos ya existentes, ejemplos armados para el curso, quedarán en mi sitio, en

Materiales de Cursos

Como no sé si me dará el cuero para tratar tantos temas, les pregunto por acá: Cuáles serían sus temas preferidos? Falta alguno que prefieran a éstos?

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Twitter para todo: TweetMyPC (y TweetMyMac también)

lopez — Tue, 01 Sep 2009 09:55:34 GMT

Una idea que quería explorar es crear un pequeño estándar de cómo usar mensajes cortos para enviar comandos y recibir respuestas de una aplicación cualquiera. Un paso hacia eso, muy ingenioso, es la de TweetMyPc (http://tweetmypc.codeplex.com/). El autor principal es Shoban, Microsoft MVP de la India.

La aplicación es chica, y cuando la ejecutamos en nuestra máquina, ingresamos los datos de nuestra cuenta de Twitter:

Una vez que arranca la aplicación, comienza a leer nuestros tweets cada 1 minuto. Es conveniente usar una cuenta para cada PC. Desde esa cuenta, desde cualquier otro lugar, podemos enviar comandos como: Shutdown, Hibernate, Lock, y hasta Download, que comienza a bajar un archivo. Una lista parcial de comandos la pueden ver en:

http://www.codegeeks.net/tweetmypc-what-next

Si uno saca un Screenshot remoto, la aplicación responde enviando un comando con una URL de la imagen tomada. Este es el tipo de respuesta que tenía en mente en el primer párrafo de este post: una forma de enviar algo más grande que un mensaje, es mediante una URL.

La aplicación está escrita en .NET. No vi el código todavía, pero está originalmente escrita en VB.Net y hay versión en C#.

Tienen también aplicación para

Otra aplicación del mismo autor:

http://www.codeplex.com/jata

Jata is a Google Talk like Twitter Application which was developed using VB.net and Twiteroo Twitter API framework.
jata automatically checks for new messages periodically. You can post your status right from jata post message screen.
You can also reply to tweets using jata.

Habría que seguir explorando la idea de manejar aplicaciones con mensajes cortos, desde Twitter u otros.

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Próxima reunión VAN de ALT.NET Hispano

lopez — Fri, 24 Jul 2009 07:07:08 GMT

Han pasado dos meses desde la última reunión virtual de ALT.NET Hispano. La última fue el pasado 24 de Mayo, con la participación del bueno de Fabio Maulo, por supuesto hablando de NHibernate. Ya han habido 5 reuniones VAN:

Si no conocen qué es una reunión VAN, pueden consultar

VAN meetings

Para ver cómo se desarrolla una VAN de ALT.NET Hispano ver

Descripcion-de-Reuniones-VAN

Ahora se viene una nueva reunión virtual, el próximo 1ro. de Agosto, pueden registrarse en:

http://eventioz.com/admin/events/van-hispano-1-de-agosto-de-2009/registrations

El tema será CSLA.NET, el framework de aplicaciones para .NET, que nació en su tiempo en Visual Basic clásico.

Pueden ver el resultado de las anteriores reuniones virtuales en:

http://altnet-hispano.pbworks.com/Historial-de-reuniones

Algunas reuniones fueron pasadas a video, como ejemplo, pueden ver al bueno de Fabio Maulo en:

http://altnet-hispano.pbworks.com/NHIbernate.2009-06-22-12-54-41

Si no conocen qué es ALT.NET pueden visitar:

¿Qué es ALT.NET?

Es un movimiento… así de sencillo, pero también de entrada hay que decir que no hay una definición totalmente oficial ni exacta, hay descripciones y principios (tal vez no leyes) que rigen cómo piensa y actúa un alt.netero. De hecho, si buscas en la Web, seguramente vas a encontrar diferencias en como lo entienden unos y otros, aunque también es necesario aclarar que las diferencias son muy pequeñas y no muy distantes.

que nació de un post original de Jorge Gamba:

Que es ALT.NET

Pueden seguir la actividad del movimiento en Twitter:

@AltNetHispano

El sitio wiki de la comunidad:

http://altnet-hispano.pbworks.com/

Ahí leemos:

(tomado del sitio altdotnet.org)

"Somos una comunidad, independiente y con fines específicos, de desarrolladores comprometidos por un deseo de superarse, desafiar supuestos, y que se ayudan entre sí perseguiendo la excelencia en la práctica de desarrollo de software."

Posts relacionados:

ALT.NET Argentina, ALT.NET Hispano, primera reunión en Buenos Aires

ALT.NET Buenos Aires Primera Reunión

(Imagen tomada de http://altnet-hispano.pbworks.com/)

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Ejemplos de ASP.NET, capas y Linq

lopez — Thu, 23 Jul 2009 10:03:45 GMT

Hace dos semanas, terminé de dar un curso de ASP.NET, con máquinas, en el laboratorio del Microsoft User Group de Argentina, en Buenos Aires, contando con diez asistentes, con los que tuvimos 30 horas explorando el desarrollo de sitios dinámicos con .NET. Los ejemplos que fuimos desarrollando y otros que bajamos de ejemplos míos, están disponibles para bajarse desde:

Material del Curso de ASP.NET en el MUG

(Siempre pueden bajar lo que tratamos en mis cursos, desde

Materiales de Cursos

ya sea ASP.NET, .NET, arquitectura, Java, JSP, Spring, Struts, etc… así como las presentaciones que se usaron)

Hay varios ejemplos para estudiar, que podría explicar más en detalle en algún post, pero vaya ahora una introducción:

AjFirstExample

En este ejemplo

tenemos una base de datos, que pueden instalar usando cualquiera de los dos directorios Sql, y dos soluciones, una en VB.NET y otra en C#.

En el directorio Sql, tenemos:

Podemos lanzar la creación de la base con el comando ExecuteAll.cmd, que contiene

@REM  -------------------------------------------------------------

@REM  You can change server.

@REM  -------------------------------------------------------------

SET sqlServer=%1%

if "%1%"=="" set sqlServer=(local)

call CreateDatabase %sqlServer%

rem TBD:

rem call LinkData %sqlServer%

rem call InsertData %sqlServer%

goto end

:end

Si lo invocamos sin parámetros, va a conectarse con nuestro MS SQL Server (local). Si queremos ir contra otra instancia, por ejemplo, contra .\SQLEXPRESS, hay que invocarlo como:

ExecuteAll.cmd .\SQLEXPRESS

Crea una base simple, AjFirstExample, con dos tablas, clientes y proveedores, y procedimientos almacenados:

El ejemplo sigue algunos linemamientos de Patterns & Practices, de Microsoft, como tener separados Business Entities de Business Components. La solución tiene varios proyectos:

WebClient es el sitio web. AjFirstExample.Services es una capa de servicios lógicos (no tecnológicos, como podría ser un Web Service), que es un .DLL que se invoca directamente de el sitio web. Es lo que en patrones llamamos una Service Layer. AjFirstExample.Entities contiene entidadas simples, con datos, sin conducta ni persistencia. Está muy orientada al ejemplo, que apenas es un CRUD (Create Read Update Delete) de entidades, fragmento:

Imports System.Collections.Generic

Imports AjFirstExample.Entities

Imports AjFirstExample.Business

Imports AjFramework.Data

Public Class SupplierService

    Private Shared mSupplierComponent as new SupplierComponent

    Public Shared Sub Insert(entity as Supplier)

        mSupplierComponent.Insert(entity)

    End Sub

    Public Shared Sub Update(entity as Supplier)

        mSupplierComponent.Update(entity)

    End Sub

    Public Shared Sub Delete(id as Integer)

        mSupplierComponent.Delete(id)

    End Sub

    Public Shared Function GetById(id as Integer) as Supplier

        return mSupplierComponent.GetById(id)

    End Function

AjFirstExample.BusinessComponents tiene lógica de validación antes de grabar o insertar una entidad, y AjFirstExample.Data termina encargándose de la persistencia, usando un DataService, que yo había codificado dentro de algo que uso en mis cursos, AjFramework.

En las páginas web, es común conversar con el servicio, para tomar y enviar datos a ese proyecto:

Public Partial Class Admin_CustomersPage

    Inherits System.Web.UI.Page

    Protected Sub Page_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Me.Load

        'Put user code to initialize the page here

        If Not IsPostBack Then

            gvwData.DataSource = CustomerService.GetList

            gvwData.DataBind()

        End If

    End Sub

End Class

Este ejemplo lo tienen también en ese mismo .zip implementada en C#. Van a ver que ha sido generada directamente por AjGenesis, el generador de código que uso para armar gran parte de mis ejemplos y del desarrollo del día a día que emprendo:

' File generated using AjGenesis

' http://www.ajlopez.com/ajgenesis

' http://www.ajlopez.net/ajgenesis

' Open Source Code Generation Engine

Si tienen que cambiar el string de conexión, deben modificar el web.config del proyecto web, en el sector:

<AjFramework>

    <Parameters>

        <Parameter Name="ConnectionString" Value="server=.\SQLEXPRESS;database=AjFirstExample;Integrated Security=true"/>

    </Parameters>

</AjFramework>

Hay otro ejemplo para bajarse e instalar de la misma manera:

AjTest

Con las mismas ideas:

pero con más entidades:

Cada departamento contiene empleados. Los proyectos contienen tareas, y las tareas se pueden asigna a empleados. Cada empleado tiene "Skills”, competencias, y cada competencia tiene empleados. Desde las páginas de administración, pueden ingresar los datos de estas entidades.

Sin embargo, la relación entre estas entidades, no está en la entidad misma, sino en cómo recuperamos los datos necesarios desde el servicio. En vez de tener dentro de Department una lista de Employee, los empleados de un departamento se obtienen desde código, ejemplo:

protected void Page_Load(object sender, System.EventArgs e)

    // Put user code to initialize the page here

    if (!IsPostBack) {

        IdEntity = Convert.ToInt32(Request["Id"]);

        Entity = DepartmentService.GetById(IdEntity);

        dtgDataEmployees.DataSource = EmployeeService.GetByDepartmentEx(IdEntity);

           DataBind();

Un ejemplo, donde usamos una base similar, pero en el código establecemos las relaciones, está en:

AjTestCSharp3Linq.zip

Acá usamos Linq2Sql

donde las entidades, generadas por el wizard de Linq2Sql, ya tienen las relaciones incorporadas. Entonces, una vez obtenido un Deparment, podemos pasar a Employees en una simple propiedad que tiene el objecto departamento:

protected void Page_Load(object sender, System.EventArgs e)

    // Put user code to initialize the page here

    if (!IsPostBack) {

        LinqDepartmentsService service = new LinqDepartmentsService();

        IdEntity = new Guid(Request["Id"]);

        Entity = service.GetDepartment(IdEntity);

        dtgDataEmployees.DataSource = Entity.Employees;

           DataBind();

Un último ejemplo más, para este post rápido:

AjFirstExampleWcfCSharp3.zip

En este caso, seguimos usando Linq, lo que viaja a la presentación, son mensajes Windows Communication Foundation, hay un sitio web que expone servicios WCF, y de la parte del cliente, código de gateway para llegar a esos servicios:

En vez de llegar a la presentación las entidades de .Data, de Linq, pasamos mensajes de Data Contract de WCF:

namespace AjFirstExample.Services.Contracts

    using System;

    using System.Runtime.Serialization;

    [DataContract]

    public class Customer

        [DataMember]

       public Guid Id { get; set; }

        [DataMember]

       public string Name { get; set; }

        [DataMember]

       public string Address { get; set; }

        [DataMember]

       public string Notes { get; set; }

Bueno, espero que puedan sacar algo útil de estos ejemplo, vean también los archivos de ejemplos que fuimos desarrollando en cada clase.

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez