Integración Continua con el nuevo modelo de Builds de VSO/TFS 2015 (II)

Bueno, ya salimos de Fiestas Patrias y toca cumplir lo prometido, ir conociendo el nuevo modelo de Builds que ha sido introducido en Visual Studio Online y en Tean Foundation Server 2015 (que ya esta disponible en su versión final) y como comentabamos, se usara el ejemplo Parts Unlimited, que por tener ya las cosas hechas respecto a integración con BD nos servira para dar una visión integral del despliegue.

Los pasos que seguiremos seran los siguientes:

1) Descargar el código fuente de Github, crear nuestro repositorio en VSO y hacer las pruebas en local.

2) Preparar los Resource Group y todas los recursos Azure necesarios para el despliegue desde Visual Studio, de esta manera no tendremos que crear las cosas manualmente desde el Portal, salvo que sea estrictamente necesario.

3) Preparar la Build propiamente dicha y probarla.

Lo primero es crear un proyecto en Visual Studio Online, nótese que como siempre elegimos Scrum como plantilla y en este caso usaremos Git como modelo de repositorio.
Clipboard04

Luego de esto toca conectarse a dicho proyecto desde nuestro Visual Studio, y luego proceder a clonar el repositorio (que forma parte del proyecto de VSO), en este caso el repositorio aun estará vació (a menos que hayamos creado un readme desde el portal de nuestro proyecto), en mi caso particular edite la carpeta local donde se va a clonar el repositorio pues por defecto Visual Studio intenta crear los repositorios locales de Git en el disco C:

Clipboard05Ahora viene la parte interesante, Parts Unlimited es un proyecto muy interesante que si bien empezo con ASP.NET 4.x ahora están trabajando en una version basada en ASP.NET 5, pero para efectos de esta demo de Integración Continua nos basaremos en la versión 4.X para lo cual deberemos dirigirnos a este branch en GitHub, desde donde podremos bajarnos un Zip con todo el proyecto, lo descargamos luego de lo cual estaremos listos para integrarlo en nuestro repositorio Git de VSO. Finish Reading: Integración Continua con el nuevo modelo de Builds de VSO/TFS 2015 (II)

No todo tiene igual riesgo

Mucho se habla de gestión de riesgos, ya sea en metodologías ágiles como en, cof cof, waterfall, y claro, mucho se colocan tablas y con una mayor o menor pericia se indican los impactos y probabilidades respectivas, hasta ahí “lo normal”.

Lo usual es que por lo usual los criterios de experiencia que se toman están basados en el tipo de proyecto: ERP, almacén, web o desktop o también en el grado de complejidad del negocio, estado de las relaciones con el cliente, primera vez, time to market etc, nada fuera de lo habitual.

El problema es que muchas veces la visión “de negocio” logra opacar al criterio técnico en un factor muy importante: no todas las tecnologías tienen igual riesgo, y no, no me refiero al hecho de que por ejemplo un consultor de SAP cobre mas que un diseñador gráfico (llevándolo a extremos), sino que las diversas tecnologías tienen diferentes niveles de disponibilidad de recursos de aprendizaje, lo cual quieras que no, impacta en las previsiones que se requieren tomar para un proyecto.

En algunos casos es evidente que hay muchos mas recursos (ojo, en este blog nunca hablamos de personas como “recursos”, ¿ok?) para SQL Server y Oracle que para Informix o Sybase, por lo cual el tiempo en que un equipo puede llegar a ser productivo en un proyecto con estas dos tecnologías “raras” es mayor, pero mal que bien se puede solventar con la experiencia previa en otros motores de base de datos, así que tenemos un riesgo ligeramente mayor, pero justificable.

Visto a este contexto debemos pasar a un diferente tipo de escenario, los frameworks o soluciones “listas para usar”, productos que se espera que puedan ser usados directamente por un usuario final, “casi” sin necesidad de desarrollo, pero claro eventualmente terminan pidiendose personalizaciones y como la aplicación tiene una API en un lenguaje “conocido” como PHP, C# o Java pues se empieza el desarrollo tomando los mismo criterios que cualquier otro proyecto a medida y .. ahi empiezan los problemas.

En concreto estas aplicaciones (concretamente los CMS que son con los que he tenido experiencia) presentan dos problemas que los hacen “bestias” diferentes a cualquier desarrollo a medida:

  1. Esfuerzo extra para configurar los entornos, tanto de desarrollo, como de producción, en el caso de SharePoint por ejemplo era muy complicado, tan así que no se podía trabajar contra un servidor compartido sino que cada desarrollador debía de tener una Maquina Virtual para tener un entorno de trabajo, todo lo cual involucraba un esfuerzo que no era trivial.
  2. Cambio de paradigma respecto a como desarrollar y/o depurar, pues aquí no eres tu desarrollando una aplicación, estas intentando construir algo sobre los cimientos que alguien mas hizo, y que le puso reglas que pueden ser no usuales (y sobre todo contraintuitivas), pero necesarias para que el producto funcione, lo cual deriva en una necesidad de conocimiento (y tiempo de aprendizaje) mas allá de cuan experto uno crea ser en el lenguaje en cuestión.

Queda claro que estos dos factores tienen alta probabilidad de incidir sobre el tiempo que le puede tomar al equipo implementar la solución, por lo que seria un grave error asumir proyecciones sin tomar en cuenta el esfuerzo extra mencionado, si, es difícil acometer estas cosas que nos dejan productos como Magnolia, Vignette, o SharePoint, pero al final son retos técnicos que terminan siendo superados, a menos claro que la dirección asuma que “.net es .net” y no tome en cuenta detalles como estos en sus proyecciones, ahora que si a estas dos cosas, se le suma la poca experiencia local, o poca documentación actualizada en foros, asumimos grandes riesgos que no podemos dejar de informar de antemano, y créanme, en el caso de CMS (salvo que tengas miembros del equipo que actúen como pilares del resto) siempre pasa algo de lo mencionado, por lo que debemos estar alertas, regresando al titulo de este post, no todo tiene igual riesgo (técnico).

En defensa de Visual Basic.Net y las “buenas practicas”

Primero el Disclaimer: La herramienta a la que le tengo mas cariño y con la que he sido mas productivo es Borland Delphi (ahora Embarcadero, pero la que yo conocí era de Borland), dicho esto pasemos al grano.

El titulo del post proviene a razón de la ultima sesión de Mad.Nug en la que Jorge Serrano compartió su experiencia sobre las posibles acciones a tomar cuando se tienen aplicaciones en Visual Basic 6 y existe la necesidad/presion/requerimiento de migrarlas a .Net, la sesion fue muy explicativa, recordandonos cuales son los puntos donde hay mas incompatibilidades y las posibles opciones:

– Herramienta de migración automática
– Entorno mixto (Microsoft Interop Forms Toolkit 2.1 y wrappers)
– Empezar todo desde cero.

De acuerdo a su experiencia (corrígeme si te estoy referenciando mal, Jorge) debería procurarse por la ultima opción (en ese sentido Jorge facilito un buen enfoque para acometer esos proyectos), y estar alertas ante el riesgo de que una solución puntual como un entorno mixto crezca y pierdas el control.

Si bien comparto la idea de que hay casos en que no queda otra que proceder de esa manera, creo que esa decisión tiene que ser sopesada teniendo en cuenta criterios como: cantidad de lineas de código existente, dependencia de terceros, disponibilidad de conocimiento funcional, etc… en ese sentido se sintió la falta de cubrir posibles estrategias de cuando se ha decidido ir por el camino de la migración (que igual se hace para algunas aplicaciones, dejando el resto a un rehacer desde cero).

Bueno, a lo que iba, como parte del camino de un rehacer desde 0, Jorge planteo que había que procurar migrar hacia C# en lugar de hacia VB.Net, ¿por qué? es lo que nunca me queda claro, salvo por un hecho (mencionado en la reunión) que es la mayor disponibilidad de recursos en Internet para C# que para VB.Net, pero fuera de ello el acceso hacia el Framework de .Net es básicamente el mismo (salvo excepción que contare luego), por lo que también en la conversación con los asistentes se dejo caer que con C# se es mas ordenado y se encamina hacia las buenas practicas, por lo que ya entramos a un tema de preferencias y es a donde quería llegar.

Admitamoslo, por sus propias características en Visual Basic 6 era muy muy fácil desarrollar con malas practicas y que el código spaghetti generado sea muy difícil de mantener, pero si una cosa tiene Visual Basic .Net es que significo una ruptura sin pasos intermedios con respecto a VB6 a fin de volverlo OOP y compatible con el nuevo Framework (*), y por lo tanto mucha de la laxitud inherente al viejo VB6 ya no existe, es un buen lenguaje OOP y muy valido para aprovechar los conocimientos de sintaxis propios de Basic: Dim, as, Next, End…, el problema gordo es la herencia de mala imagen que lastra el lenguaje, asi que explicar a un manager que seria menos traumatico continuar con VB.Net en vez de C#…. complicado, triste realidad.

Siendo así creo que solo hay dos razones no personales para optar por desarrollar un proyecto en C#:
– Es muy critico contar con todos los recursos de documentación disponibles para un tema en concreto, que lamentablemente en su mayoría están en C# (p.ej. hay casi tres veces mas info para Generics en C# que para Visual Basic).
– Te ha tocado acceder a una parte del Framework que expone justamente un tipo de datos existente en C# pero no en Visual Basic.Net, eso me paso con la versión 1.1, no se si lo habrán solucionado, pero … queda como alerta.

En contraparte tengo algunas razones de productividad para seguir usando VB.Net siempre que puedo:
– Detección automática de algunos errores y de su corrección, esa potencia de mostrarte un subrayado en algunos errores de sintaxis es de veras de agradecerse, y lo mismo con el hecho de que si compilas y saltan errores no tienes que recompilar para ver si has corregido bien o no, conforme vas corrigiendo tu pila de errores se reduce.
– No sensible a las mayúsculas/minúsculas, esta característica va de la mano con lo anterior, si defines bien una variable (usando Camel y Pascal case adecuadamente) y luego la invocas, el hecho de que se te auto corrijan las mayúsculas y minúsculas es una señal inmediata de que no te has equivocado al invocar el nombre de dicha variable.
– Las instrucciones (begin..end..next..) son mas claras que las llaves ({}) para poder hacerse una idea del ámbito de un bloque de código.

Dicho esto, como desarrollador he venido a conocer ambos lenguajes, pero lo fundamental es el Framework, siendo que el saber C# me ha facilitado acceder a ciertos recursos no existentes para VB.Net, pero que luego a la hora de implementar no he vacilado en aplicarlos sobre proyectos en VB.Net, así que es bueno saber ambos, pero uno no debería de inhibirse y proponer el uso de VB.Net en los proyectos.

Pero algo se me quedo dando vueltas ya desde la sesión a propósito de eso de que C# te ayuda a ser mas ordenado (o algo así), y a esto se sumo el comentario de uno de los asistentes comento que ellos tenían una aplicación grande en VB6, basada en COM+/MTS, hecha según las recomendaciones que daba Microsoft por entonces para el desarrollo en COM, lo cual me hizo retroceder a la época en que este diagrama salia en toda presentación de arquitectura y diseño de aplicaciones alla por el final de los 90s:

Pongámonos en contexto, para el lanzamiento de Visual Basic 6, ya había un gran parque de aplicaciones en VB4 y VB5, pero la fama del “DLL Hell” ya era muy fuerte, así que Microsoft emprendió una campaña muy intensiva para explicar el concepto de desarrollo de aplicaciones distribuidas, las ventajas del multicapas en la mantenibilidad de las aplicaciones, etc etc… conceptos que ahora son el pan de cada día en los objetivos de los diversos proyectos actuales, fueron recien conocidos para muchos gracias a Microsoft, y la verdad es que en ese entonces Microsoft se preocupo mucho en hacer pedagogía de las buenas practicas, tan así que en los cursos de certificación se hacia énfasis en lo que hay detras de la instanciación de objetos en COM para de esa manera impulsar formas mas ordenadas de programar, y lo bueno de todo es que esa pedagogía era de manera no agresiva, planteándola como una evolución de las aplicaciones que habia en desarrollo entonces, a fin de que los programadores mejoraran sus practicas frente a la fama de caos, o sea se pugnaba (por entonces) un cambio evolutivo en las formas de hacer las cosas apoyándose en lo que los desarrolladores ya conocían, lo cual condujo a que los partners serios si que hicieran aplicaciones buenas y solidas usando VB6.

Para bien o para mal todo cambia con la introducción de .Net, que como ya hemos indicado en este y otros posts vino a ser un ruptura muy fuerte, en la que sobrevivía el que tenia mejor las bases de OOP y/o Windows DNA. Claro, ya lo peor paso (salvo las app VB6 que se resisten a morir) y la cosa esta mas o menos estabilizada, salvo por la nueva tendencia del famoso patron SOLID, sobre el cual ya comente que tenia mis dudas sobre si facilitaban la mantenibilidad de las aplicaciones, pero que en todo caso hay que entenderlas y saber como y cuando aplicarlas, siempre sin dogmatismos.

Y es justamente que ahora los dogmatismos se hacen presentes, pues en lugar de introducirnos progresivamente a las nuevas “buenas practicas” se nos pide que ya no usemos ni Windows Forms (aunque si, podríamos pasar a WPF) ni Windows Forms, diciendonos que “no es testeable” “no permite xxx principio” de buenas a primeras sin mostrar evolutivamente como mejorar el código que estamos desarrollando, de ahi a lo que dije en un twitt reciente: Si nos explicasen las pruebas unitarias con ejemplos basados en multicontroles, eventos y mantenimientos, igual las adoptariamos #digonomas (o este otro), digo eso porque la mayoría de las aplicaciones corporativas de uso interno (no portales de contenido) terminan siendo eso y no los clásicos ejemplos de calculadoras o números perfectos, así que seria bueno que los planteamientos de difusión sobre TDD o SOLID partan de un enfoque evolutivo y no rupturista (dando cobertura tanto a VB.Net como C#) a fin de lograr una mejor adopción.

A ver si no llega alguien por aquí diciendo que he “perdido el punto”… xD

(*) Y si, sigo creyendo que muchos traumas se hubieran evitado si al hacer .Net (y C#) se hubiera mirado lo que tenia VB6 a fin de hacer la ruptura menos dolorosa.

Pensando en estrategias de migración de VB6 a VB.Net

Casi a hilo de lo que comentaba en el anterior post, hace poco Jorge Serrano publico Cada vez que migras una línea de código de VB6 a .NET se muere un gatito en el mundo, interesantisimo post que vale la pena leer pues resume muy bien los dilemas, actitudes,creencias erróneas y decisiones que se acometen cuando se tienen aplicaciones en Visual Basic 6 y se piensa el migrar a .Net como una opción a considerar.

Me detendré poco en el tema de la discusión de si migrar si o migrar no, pero en mi modesta opinión creo que los criterios de discusión deberían girar alrededor de (entre otras) estas preguntas:
– ¿Qué tan diferente son los procesos de negocio de la organización de como eran cuando la aplicación fue construida?
– ¿Son los algoritmos técnicos de las aplicaciones aun validos para los procesos de datos?
– ¿El esfuerzo de “entender” la aplicación actual y documentar la especificación de la nueva es mayor que el de la “simple” migración? (Cuando no queda nadie del equipo original)

Llegados a nuestro escenario “pues si, necesitamos migrar esa aplicación pues ya cada vez es mas difícil mantenerla y vamos a migrar de plataforma….. ” hay que plantearse las cosas de como acometerla, no tanto desde el punto de vista técnico, que para eso hay suficiente información en Internet, sino mas bien de cuales serian los pasos razonables para lograr el objetivo de una migración exitosa.

Con esas miras puestas, la experiencia que he tenido recientemente me llevan a plantear dos pequeñas metas antes de la migración en si:
– Reducir todo lo que se pueda la cantidad de lineas a migrar.
– Reducir y aislar los comportamientos críticos no migrables.

Cuando hablo de reducir la cantidad de lineas a migrar, parto del hecho de que es mas que probable que la aplicación a migrar hay sufrido modificaciones durante su tiempo de vida, lo cual haya ocasionado que métodos o clases que antes eran invocados se hayan convertido en código muerto, y reducir ese código muerto antes de la migración deberá ser uno de los principales objetivos que debamos de plantearnos, puesto que es preferible saber de antemano que código ya no es invocado (y eliminarlo/comentarlo) que matarnos en hacer que funcione para luego saber que … sorpresa.. sorpresa… era código muerto.

El tema de los comportamientos de lenguaje no migrables (“As any”, redimensionamiento de arrays …) es complicado, por lo que creo que es conveniente, en la medida de lo posible tomar las acciones para reducirlos antes de la migración y si eso no es posible marcar dicho código como problemático.

Ahora bien, estos son objetivos loables, pero lamentablemente difíciles de conseguir con las herramientas de Microsoft “out of the box”, que si que el Code Analysis de VS .Net nos facilitara el encontrar las referencias “muertas”, pero lamentablemente el tener una información completa de este tipo solo sera posible cuando el código migrado compile sin errores, pero claro… volvemos a lo mismo podemos pasarnoslas divertidos corrigiendo código para luego descubrir que ese código no era invocado en ningún lugar.

Entonces queda claro que el análisis de dependencias es critico, y lamentablemente no queda sino recurrir a herramientas de terceros, concretamente he estado probando Project Analyzer con resultados muy interesantes pues ademas de encontrarme con la opción de encontrar todo el código muerto, me detecto todos las porciones de código que requerían migración manual.

Así pues, creo que el contar con una herramienta de ese estilo (he mencionado Project Analyzer, pero igual podría ser alguna otra) cobra un importancia muy especial en esta clase de proyectos, ya que permite cubrir los dos primeros objetivos señalados y llevando de rebote una ventaja adicional: darnos cuenta, mediante el análisis de dependencias de que porciones de código no compatible como llamadas a la API de Windows, podrían ser reemplazadas por código .Net.

Ese análisis e identificación de codigo critico seria un primer paso, de ahí vendrían los siguientes:
– Refactorización, si, se puede, y nos ayudara a tener nuestro código heredado mas legible.
– Preconversión de código no migrable a código migrable, donde sea posible y se sepa que se seguirá usando luego de la migración.
– Migración en si, ya sea usando Visual Studio o una herramienta de terceros, y de ahí las sucesivas iteraciones para estabilizar el producto hasta el nivel deseado (reemplazo de ADO por ADO.Net, eliminación de los Interop….)

Es obvio que este proceso iterativo por lo que no conviene dar un paso nuevo hasta que no se sepa que la nueva versión sigue haciendo lo que hacia antes, de ahí la importancia de tratar de acometer la mayoría de los cambios posibles antes de la migración en si.

¿Qué le hubieramos pedido a un hipotetico VB 6.5?

Pues si, ya han pasado poco mas de 10 años en que .NET fue anunciado (recordemos que antes era llamado NGWS), por lo que ya tendría poco sentido hablar de su predecesor, pero la experiencia de volver a tener que lidiar con VB6 me ha hecho volver a reflexionar algunas cosas…

Primero situémonos en el contexto, VB6 fue lanzado durante 1998 he incluía mejoras como: ADO 2.0 (un enésimo santo grial en la unificación de los modelos de acceso a datos), WebClasses, mejoras en el soporte a COM e integración con MTS; con todo no fue un modelo rupturista y las empresas entusiastamente dieron el salto desde VB5 (versión que por primera vez libero a VB del p-code permitiendo compilar en modo nativo).

Todo bien excepto algunos detalles…. como la herencia, lo cual le hacia ser denostado como un lenguaje no totalmente orientado a objetos, palideciendo en ese sentido ante sus rivales: Delphi y Java. Admitamoslo, durante buen tiempo los fans de VB actuaron con la política de la zorra y las uvas, diciendo que la herencia no era totalmente necesaria, y pregonando la potencia de las interfaces para lograr el polimorfismo. Aun así Microsoft decidio explorar por el lado de una OOP sin las complicaciones del C++, y el resultado fue Visual J++ 6.0 el cual tuvo problemas con Sun, por lo que el producto no tuvo tanto éxito, aunque si que me he topado con un cliente en el cual había herencia de su uso.

Visto ese escenario, para principios del 2000 se rumoreaba sobre lo que seria el inminente ASP+ y el NGWS (Next Generation Windows Services), pero Microsoft sorprendió al mundo cuando en Julio anuncio a .NET, C# y el hecho de como el nuevo VB.Net seria un lenguaje totalmente orientado a objetos, luego vendrian las primeras versiones beta de Visual Studio .Net, sobre cuyo primer contacto ya me he explayado.

Como ya he comentado mi adaptación como desarrollador al nuevo entorno fue fácil, gracias a la base OOP proveída por Delphi, así como a las buenas practicas de los cursos de certificación, pero eso no impedia que mantuviera un ojo en los problemas que se iban a presentar en la transición de VB6 a VB.NET….

Estos cambios venian dados por dos lados: cambios en el lenguaje y cambios en el Framework (de COM a .NET) y ambos eran muy agresivos, tan asi que dos respetados gurues de la época dieron su explicación (muy acalorada por cierto) de porque VB.Net era un nuevo lenguaje (para ellos peor) y no una evolución de VB6:

Karl E. Peterson: VB Fred, A Marketeer’s Worst Nightmare
Bruce McKinney: The End of Hardcore Visual Basic

Sugiero dar un vistazo a esos artículos y a los enlaces ahí contenido para entender la magnitud de los cambios, y si bien luego las cosas no fueron tal como se pintaban en la beta, los cambios si que son muy rupturistas e intentar asumir una migración es algo de veras intimidante.

He realizado migraciones de aplicaciones .NET de la version 1.0 a 1.1 y de la 1.1 a la 2.0 y se puede decir que el camino es mas o menos controlado, pues el lenguaje siempre es compatible hacia atrás, y si bien el Framework evoluciona, dejando algunas tecnologías obsoletas (como Remoting) siempre se puede recompilar en una versión superior, siendo que los potenciales problemas están por el lado de:

– Dependencia de una librería de terceros, cayendo en esta categoría el Enterprise Library, el cual si que tuvo cambios que obligaban a modificar el codigo, problema no presentado en una libreria comercial como Dundas.
– Necesidad de apuntar a una plataforma especifica (como x64 o Itanium), lo cual sumado a lo anterior da para pruebas y comprobación de entornos.
– Alguna cosa que compile, pero que en ejecución falle, son pocas pero las hay, aunque siempre se pueden controlar añadiendo un mayor control de excepciones.
– Cambio de estructura de proyectos, como en el caso de los Servicios Windows, pero se soluciona creando el proyecto desde cero e inyectando progresivamente las clases y métodos necesarios.

En resumidas cuentas, un camino que puede ser mas o menos pesado dependiendo de cuan complejo sea el proyecto, pero en el cual siempre hay vías de hacer que la migración funcione.

Planteemoslo de otra manera, ¿para 2002 habían en producción aplicaciones en VB5 o VB4? Lo dudo sinceramente, el punto de quiebre fue VB5 y como comentaba la migración de VB5 a VB6 era totalmente transparente, salvo (como de costumbre) en la dependencia de algún control de terceros.

Osea, que para migrar dentro de versiones de VB.NET o de Visual Basic “clasico” los caminos han estado mas o menos marcados y eran controlables, pero… para migrar de VB6 a VB.Net… ahi es otra cosa.

Como mencionaba lineas arriba los cambios vinieron por dos frentes: cambios traumaticos en el lenguaje y reemplazo del framework basado en COM por uno basado en .NET. (los dos primeros capitulos de este libro pueden dar una vision de los cambios), si le sumas esto al hecho de que cuando Anders Hejlsberg acometio el desarrollo de .Net, decidió crear un nuevo lenguaje C#, e hizo muchos de los diseños del CLR y el CLI sin tomar en cuenta las particularidades (ya muy usadas por los desarrolladores) de VB, esta claro que lidiar con los cambios seria una tarea harto compleja, cito el libro arriba mencionado:

The Decision to Break Compatibility

When did Microsoft decide to break compatibility with Visual Basic 6? It was actually in early December 1999, during the development of Visual Basic .NET. Until that time, Visual Basic .NET was being developed to support the notion of “Visual Basic 6 sourced” projects that allowed you to edit and compile Visual Basic 6 projects in Visual Basic .NET. These projects would have a compatibility switch turned on, meaning that the language would be backward compatible with Visual Basic 6 and would even have access to the old Visual Basic 6 forms package.
By the end of 1999, it was obvious that this strategy wasn’t working.
Little differences were slipping through: The old forms package could not be fully integrated into .NET, and the Visual Basic 6 sourced projects could not use some of the new features of the .NET platform. At that point Microsoft made the decision to break compatibility and instead concentrate on ensuring that people could upgrade their projects from Visual Basic 6 to Visual Basic .NET.

En fin, es cierto que muchos cambios (de lenguaje) eran inevitables y demandados por la comunidad de desarrolladores: soporte de herencia, excepciones y threading, pero esta claro que Microsoft pudo haberlo hecho mejor en algunos aspectos (de hecho, parte de las criticas de los gurus arriba citados van por el lado de que algunos cambios no eran necesarios para hacer a VB un lenguaje OOP) como la gestión de los arrays, no forzando a tener que hacerlos basados-en-zero y si por el contrario permitir que su gestión de limites sea equivalente a la de VB6.

Entonces esa es la situación a la que llegamos cuando sale al mercado Visual Studio .Net 1.0, el gap del Framework y el lenguaje es tan grande que solo proyectos triviales son susceptibles de ser migrados a .NET, para lo demás muchas veces es mejor hacer el proyecto desde 0, o sino… seguir manteniendo y parchando el código en VB6 hasta que se decida tomar la decisión de migrar (pues ya se sabe lo que dicen las gerencias “Si funciona ¿para que tocarlo?”, claro, es así como el COBOL no muere). La dura realidad es esa, que las organizaciones se han quedado con un parque de aplicaciones para un lenguaje/plataforma que ya no evoluciona y si bien ahora se cuenta con una buena herramienta como el Artinsoft Visual Basic Upgrade Companion, la verdad es que en todo proyecto complejo nos toparemos con situaciones como estas:

– Las inevitables llamadas a la API de Win32, ya no funcionan, y no hay forma directa de hacer un cambio que permitan la recompilacion.
– A revisar todos tus arrays para estar seguro de su comportamiento.
– Replantearte como gestiona el ciclo de vida de tus objetos.
– Los controles y clases tienen otras propiedades, no hay equivalente directo en .NET para algunas clases de terceros y la importación (wrapping) no siempre es segura.

Previo al lanzamiento de VS.Net, algunos articulistas pedían que saliera una ultima versión de VB basada en COM que facilitara la transición y/o introdujera algunas mejoras a VB6, la verdad es que mire de lejos esas peticiones, claro… estaba entusiasmado por el giro a OOP que no mire la complejidad que estoy narrando, pero ahora luego de estos 10 años de .Net (contando desde su primer anuncio y Beta) creo que si que Microsoft debió intentarlo y proveer esa herramienta a fines del 2000 o principios del 2001 a fin de que hubiera un punto intermedio en el camino desde VB6 hacia .Net, lo cual me lleva a la pregunta planteada como titulo de este post….

Personalmente yo hubiera excluido la herencia como caracteristica de un VB 6.5, implementarlo es complejo y el problema radica en como gestionar caracteristicas usadas en las aplicaciones hechas en VB 6 para que funcionen luego en .NET, siendo asi, VB 6.5 debería haber tenido (como anticipo al cambio en .Net):

– Soporte dual para arrays con limites libres y basados-en-zero. Si MS seguia terco en lo de no permitir los limites libres, la compilación debería permitirlo pero indicar que esa característica estaba “deprecada” y no soportada en futuras versiones.
– Fin de las propiedades por defecto de los objetos.
– Eliminación del tipo Variant.
– Cambio en el ámbito de la visibilidad de las variables.
– Uso obligado de paréntesis en las subrutinas.
– Ofrecer un mecanismo de llamadas a la API Win32 cercano al uso que luego tendria DLLImport, pero respetando (temporalmente) la mayoría de los hacks que se tuvieron que hacer para trabajar con dicha API.
– Opcional: soporte para try..catch..finally
– Únicos cambios en el IDE: Encontrar todas las referencias, herramienta imprescindible ahora para una adecuada inspección del código, y un compilador que devuelva una lista de errores y no uno por uno.

La idea de esto seria que los desarrolladores acometieran ciertos cambios sin retorno, sin todavía decirle adiós a COM, para de esta manera tener hechos los deberes en el grueso del lenguaje, quedando (en teoría) cambios menores en el lenguaje y “solo” adaptarse al .Net Framework.

Si Microsoft hubiera hecho esto, a estas altura no habria esas aplicaciones en VB6 que se resisten a morir, haciendo a VB6 el nuevo COBOL, pues eso es lo que esta pasando… un nicho de aplicaciones que persisten mas alla de su ciclo de vida.

Y tu ¿que característica le hubieras puesto a un VB 6.5 todavía basado en COM?.

¿Los nuevos patrones ayudan a la mantenibilidad de aplicaciones?

Si tuviera que decir que funcionalidad del Visual Studio (y de VB6 ya puestos) he estado usando mas ultimante, la respuesta seria “Go to Definition” (seguida de “Find All References”).

La razón de esto es debido a que ahora me corresponde estar en mantenimiento de aplicaciones, lo cual implica que cuando hay un error tratar de encontrar que metodo o clase fallo y ver que hacer para solucionar el error, y en otras ocasiones añadirle una funcionalidad a cualquiera de las aplicaciones ya existentes (en cuya creación yo no intervine).

Como ya explique anteriormente esta es una situación en la que no se empieza de cero, y se requiere tratar de entender de manera rápida el como esta montado todo a fin de encontrar la raiz del problema, por lo cual usualmente tengo dos caminos:

– Ubicar la aplicación e ir haciendo una “depuración sin ejecutar” mediante el “Go to definition” tratando de ubicar los puntos de paso críticos que hay durante la cascada de llamadas de los sucesivos métodos involucrados en la funcionalidad.
– Buscar el texto con el mensaje de error reportado, y de esa manera mediante el “Find all references” identificar de abajo hacia arriba la posible pila de llamadas y en el camino encontrar lo que ocasiono el problema.

Pero llegados a este punto vemos que se ha incrementado la demanda por desacoplamiento y pruebas unitariasdentro de nuestros codigos, todo como parte de los patrones SOLID:

* SRP: The Single Responsibility Principle (Principio de Responsabilidad Única)
* OCP: The Open/Closed Principle (Principio Abierto / Cerrado)
* LSP: The Liskov Substitution Principle (Principio de Sustitución de Liskov)
* ISP: Interface Segregation Principle (Principio de Segregación de Interfaces)
* DIP: The Dependency Inversion Principle (Principio de Inversión de Dependencias)

Principios muy interesantes, que valen la pena revisar, pero que introducen tendencias como la Inyección de Dependencias y la Inversión de Control, para lo cual recomiendo este muy bien explicado articulo de Gisela Torres de donde extraigo esta explicacion;

Generalmente, cuando tenemos una clase que depende de otras para ciertas acciones, necesitamos inicializar instancias de las mismas para poder utilizarlas posteriormente. En ocasiones, una de las alternativas puede ser crear un objeto de dichas clases de forma privada e inicializarlas, utilizando el constructor de la clase principal.

Si vemos estas acciones desde el punto de vista de la Inyección de Dependencias y la Inversión de Control, no sería la forma más óptima debido a que la clase que sufre estas dependencias no debería ser la responsable de la creación de las mismas.

¿QUÉ CONSEGUIMOS?

  • Desacoplamiento.
  • Mejora la posibilidad de testeo de la aplicación.
  • Mejor mantenimiento a la hora de realizar cambios de los componentes, gracias a la modularidad.
  • […]

Ambos conceptos están tan ligados que, en ocasiones, no se hace distinción. Se utiliza el concepto Inversión de Control para delegar en otro componente, un framework por ejemplo, la responsabilidad de crear las instancias necesarias en lugar de crearlas nosotros mismos. Por otro lado, la Inyección de Dependencias es el término utilizado cuando una clase depende de otra y, a través del constructor generalmente acepta un parámetro del tipo del cual depende. 

Siguiendo el ejemplo, podemos ver que en lugar de el tradicional mecanismo de instanciación de la clase que necesitamos, por detras existe un interesante mecanismo de Configuración y Factoria de Objetos que nos permiten que en lugar de:
public class HomeController : Controller
{
private readonly ITwitterService _twitterService;
public HomeController()
{
_twitterService = new TwitterService();
}

public ActionResult Index()
{
return View(_twitterService.FetchTweets());
}
}

Tengamos:
public class HomeController : Controller
{
private readonly ITwitterService _twitterService;

public HomeController(ITwitterService twitterService)
{
_twitterService = twitterService;
}

public ActionResult Index()
{
return View(_twitterService.FetchTweets());
}
}

Nada mal según parece, usamos interfaces, y se logra una mayor facilidad para pruebas unitarias, lo cual es uno de los objetivos a lograr, pero oh sorpresa… si ahora le hacemos “Go To Definition” al FetchTweets notaremos que ya no vamos a la implementación del método en cuestión (definido en la clase TwitterService), sino al cuerpo de la Interfaz ITwitterService, lo cual detendría nuestra búsqueda en cascada, al no tener mucha idea de cual es la implementación real que se esta invocando, por lo cual nos quedan dos potenciales soluciones:

– Correr la aplicación y en tiempo de ejecución ver la implementación real para así tomar las medidas de análisis necesarias a fin de resolver el problema.
– Tratar de entender la configuración de las dependencias y así inferir cual es la clase que se esperaba instanciar.

Como se comprenderá esta circunstancia puede hacer complicado una tarea de mantenimiento, y la idea de que esas tendencias pueden significar un problema, no en el tiempo de desarrollo, sino en posteriores mantenimientos me han dado vueltas en la cabeza durante un buen tiempo, hasta que encontré este interesante articulo, del cual cito y traduzco:

Yo lo he experimentado de primera mano, en muchos diferentes proyectos donde he tenido que hacerme cargo de codigo despues de que un desarrollador dejo la compañia, y puede ser una experiencia exasperante. Una mejora es solicitada, o un bug es reportado, digamos que se trata de un bug. Se me puede haber dado una excepcion en la pila, y eso al menos me lleva al codigo fuente en donde empezar. Lo que usualmente encuentro es un bonito set de pruebas unitarias que puedo correr y comprobar que todas se ejecutan correctamente, lo cual no es una gran sorpresa; pero, todos los tests usan “mocks” por lo que no puedo reproducir inmediatamente el bug como no sea escribiendo un lindo mock test para simular como el código debería responder ante un particular error de entrada, puesto que yo puedo “mockear” facilmente el error. Eso esta bien, pero no es util si mi objetivo principal es evitar que el error ocurra.

¿Que clase en concreto es la responsable del bug? Aqui es donde se pone complicado, en la mayoria de los casos, la pila no te da ninguna pista. Leer el codigo y examinar la configuración puede ser una enorme perdida de tiempo y termina siendo una tediosa búsqueda en amplitud.

Como el autor apunta “la capacidad para obtener información rápidamente y entender un programa al leer el código es degradada por IoC debido al desacoplamiento”, y así.. esa seria la alerta con la que nos deberíamos quedar, ver cual es el lugar de estos patrones, y si la búsqueda de objetivos en este momento como el desacoplamiento y las pruebas unitarias, no vendrían a significar un lastre en el largo plazo, cuando la aplicación tenga que ser mantenida por un equipo diferente.

El paso por mantenimiento de aplicaciones te hace tener en cuenta estas otras consideraciones.

Otro articulo interesante:
Dependency Injection makes code unintelligible

No siempre empezaras desde cero

Como desarrolladores generalmente esperamos estar desde el arranque de un proyecto, con la idea de que asi “esta vez hacer las cosas bien” usando una buena arquitectura y claro, con lo ultimo de la tecnología, al final terminamos llegando al estado de “parecia una buena idea en su momento” y que hay que terminar el proyecto “como sea”, bueno… exagero un poco, pero debe quedar claro que estar en el proyecto desde un inicio no es una garantia para que todo vaya como una seda todo el tiempo.

Pero para bien o para mal, si uno es un desarrollador “desde las trincheras” y no un “guru”, no sera rara la situación en que nos veamos en la necesidad de dar mantenimiento a un programa que alguien mas haya hecho o empezado (en cualquier grado de avance), y ahí es donde empieza nuestra historia…..

Antes de proseguir, debo decir que cuando he estado una buena temporada en un proyecto, trato de pensar (sobre todo en las ultimas etapas) en “como hacerle mas simple la vida al pobre tipo que se hara cargo de esto” para lo cual opto por un enfoque realista, dejar comentarios en las secciones de código que se que pueden ser mas crípticas, y de ser el caso dejar documentación útil, ¿y cuando una documentación es útil? ¿no se supone que lo útil es documentar todo lo posible? ¡Error! una documentación es util cuando uno honestamente sabe que leyéndola proveerá una idea para entender la lógica detras de la implementación de un código.

Entonces como decia, nos encontramos en la situación de que hay una aplicación existente, en cuya creación no hemos intervenido, y se nos pide ver porque ha dejado de funcionar o que le agreguemos una nueva funcionalidad, la documentación es escasa y con suerte tenemos las referencias de los servidores involucrados.

Asi que con esta premisa vamos tras el codigo fuente a ver que podemos sacar en claro (*), con lo que nuestra rutina es mas o menos como sigue:
– Ubicar el punto de entrada de la aplicacion, o sino, los controles y sus eventos respectivos que desencadenan la accion a investigar.
– Ubicado el punto de entrada o el evento deseado (capa de Interfaz de Usuario), ir viendo como se van creando las sucesivas instancias de las capas de Negocio, Fachada, Datos y los métodos involucrados.
– De ser necesario ir depurando para evaluar los valores que van tomando las variables criticas…

En fin, este es el mundo real y creo que alguna vez todos habremos pasado por este lió, siendo nuestros dilemas el saber a que clase/metodo se esta invocando desde un punto del código, así que me he sentido afortunado cuando he podido hacerme una idea del código usando las herramientas para encontrar la “Definicion” de un método invocado.

Es que así es el código típico:

– Método f1 de la clase A necesita llamar al método f2b de la Clase D.
– Método f1 instancia un objeto “miD” de la Clase D.
– Método f1 ejecuta el método miD.f2b.
– Método f2b de la clase D necesita……

Si el código esta mas o menos estructurado (y no es un spagetti por supuesto), esa es la lógica que uno busca, con las debidas excepciones de cuando se tienen que ejecutar instancias remotas y/o usando Interfaces en vez de clases directas.

Una de las cosas que tienen de bueno los entornos RAD como Delphi y .NET (WebForms y Winforms) es que brindan un mecanismo comprensible para empezar a depurar, sabes el control y quieres ver que hace, pues entonces… a ver los eventos vinculados y de ahi para adelante, de capa en capa. Quienes hemos trabajado con ASP Clasico recordamos la pesadilla que eran los puntos de entrada de las paginas, revisando todas las posibles combinaciones de parametros que venia en el Request razon por la que la introducción de WebForms fue la respuesta a nuestros problemas, y para mi lo sigue siendo.

Pero la evolución del desarrollo de software es imparable, y asi hemos visto como han surgido tendencias que han procurado añadir valor a nuestros ciclos de desarrollo como: WebServices, Refactorizacion, SOA y varios intentos de mecanismos para construir una arquitectura distribuida: DCOM, COM+, .Net Remoting, WCF….

Pero al margen de como vayan evolucionando las tendencias, una cosa que siempre procuro en mis desarrollos, es dejar el camino mas o menos despejado para que el que venga luego pueda entender el código que esta leyendo, procurando tener las inevitables sofisticaciones bajo control. Teniendo esto en cuenta… cabe preguntarse si tendencias como el “desacoplamiento” y la necesidad de “pruebas unitarias” facilitan o no la vida del que luego tiene que enfrentarse a mantener tu código, pero ese análisis lo dejo para un posterior post.

De momento quiero dejar la reflexión de que a veces estamos tentados a emplear unos patrones novedosos, potentes, pero… también debemos pensar que no todos los desarrolladores siempre desarrollan desde cero, que se llega a proyectos ya empezados, a código terminado en producción que hay que mantener, y que no hay que complicarle la vida en aras de lucirte con lo mas novedoso en metodologias y arquitecturas si es que no es de veras necesario, ya que estas no solo deben prometerte mas facilidades para ti, si no para el que luego tendra que mantener tu codigo.

(*)Aunque alguna vez no contamos ni siquiera con el código fuente, como me paso en un cliente hace 3 años, por lo que toca ver si podemos desensamblar el código, pero eso ya es otra historia y mas bien un extremo de irresponsabilidad por parte del cliente.

Lo tenia delante pero no sabia decir porque no me gustaba: Java

Cuando uno llega a una situacion u opinion es porque ha recorrido un camino previo, nadie te ha teletransportado ahi, solo que a veces nos olvidamos de dicho camino.

Concretamente debo referirme a la predileccion como desarrollador que tengo para con la plataforma .Net, el porque termine ahi y lo prefiero frente a Java … tiene su historia.

Luego del paso obligatorio por Pascal, C/C++, COBOL tocaba enfrentarse a las herramientas de desarrollo “real”, con la que se hacian las cosas en las empresas, y sobre todo, las que permitian desarrollar para Windows. Tuve ocasion de hacer un curso de Gupta SQL Windows, el cual me dejo un mal sabor de boca.

Es por esa epoca que tambien me expongo ante Visual Basic 4/3, se comenta algo sobre Java, pero aun no recuerdo el como y porque (creo que lo que lei por ahi) termino en mi casa haciendo experimentos con Borland Delphi 1 y fue quedar seducido por la propuesta hecha: un poderoso lenguaje Orientado a Objetos, con una interfaz que cogia lo mejor de los conceptos drag and drop popularizados por Visual Basic.

Pero claro, lamentablemente en Peru Delphi era un lenguaje casi de “culto”, por lo que urgia revisar las cosas que iban apareciendo en el mercado y una de esas cosas fue algo que me comentaron a poco de terminar mi primera Feria del Hogar: un lenguaje llamado Java el cual prometia traer la interaccion a la web mediante los llamados “applets”, propuesta interesante la verdad, el caso es que no me pude poner a probar Java sino hasta el 97 en que pude instalar Windows 95, esto debido a que no habia opciones para correr Java en W3.11 como no sea mediante el proyecto ADK que no se en que habra terminado.

Intente darle su espacio a Java, pero entonces me topaba con unos problemas que para entonces eran criticos:
– Ausencia de un IDE lo suficientemente rapido, aun el Borland JBuilder era muy lento, siendo que aun VB (5 para entonces) era mucho mas rapido y ni que hablar de Delphi (3 y 4).
– No continuidad en el modelo de presentacion grafica, de un momento a otro se decidio que las AWT debian dar paso al modelo Swing.

El lenguaje en si no daba muchos problemas (regresaremos a esto), pues ya contaba con la base de saber C/C++, pero lamentablemente costaba mucho ser productivo, siendo que con Delphi implementar algo era relativamente simple (pero no tan innecesariamente simple como con VB). Tambien es conviente notar que como el enfoque era hacia dar “dinamismo” a la web, surgieron herramientas que proponian alejarte del codigo para generar applets (semi prefabricados) de manera mas agil, hablo de Kinetix y Jamba. Y claro, por otro lado teniamos a Kawa, que fundamentalmente era un gestor de proyectos que tras bastidores llamaba por linea de comandos al JDK.

Es asi que me volvi en uno de los pocos defensores de Delphi en Lima de esa epoca, hice experimentos con las opciones de desarrollar paginas con ISAPI, controles ActiveX incrustados, desarrollo en 3 capas mediante Midas, y claro un buen rato metido en el newsgroup non-technical de Borland asi como en ClubDelphi, circunstancias que me llevaron a conocer a Claudio Briceño (responsable comercial de Borland para Latinomaerica) quien me vino a visitar a mi trabajo de entonces, lo cual luego conduciria (gracias a la posterior coordinacion de un comunidad de Linux en el Peru) a la posterior presentacion de John Kaster en el Hotel Los Delfines para presentar los avances que hacia Borland en desarrollar Kylix un entorno Delphi para Linux, y si, ahi estoy yo… :

Luego me tocaria cenar tanto con Claudio y John a la espera de posteriores acciones que permitieran potenciar la presencia de Delphi en el mercado peruano, lo cual no logro a materializarse.

En esas circunstancias, veo que las cosas cambian, nadie habla de applets, todo se orienta hacia los servlets, y a los EJB, les doy una revision… nuevamente, cuesta hacer algo simple de manera rapida, se nos habla de que ya saldran los JSP….. Lo interesante es que a pesar de esas limitaciones Java estaba cogiendo un mayor arrastre, el cambio de lo “visual” hacia los modelos de componentes orientados a servidor habian probado ser buenos para la estrategia de Sun, ya que habia una demanda en el mercado por una solucion no atada a Microsoft, mas orientada a objetos y que fuera robusta, en ese sentido los Application Server lanzados por diversos fabricantes permitieron consolidar su posicion en el mundo corporativo.

Es en esas circunstancias que (me)ocurrieron varios eventos de manera casi consecutiva, Microsoft anuncia .NET prometiendo una plataforma totalmente Orientada a Objetos(*), soy admitido en una beca de Microsoft para estudiar VS 6 y ceso en mi trabajo de entonces.

Estudiar lo que ofrecia VS (VB + Interdev fundamentalmente) me hace ver ciertos detalles que no eran tan claros para mi, era perfectamente viable construir aplicaciones robustas con esas herramientas, pero que muchas veces la simplicidad te conducia a errores de diseño que penalizaban la performance y la mantenibilidad, siendo necesario un conocimiento serio de la arquitectura detras (algo en lo que los cursos de Certificacion enfatizaban bastante).

A pesar de haber “cambiado” de herramienta por razones de mercado, sabia que esto era algo transitorio, pues veia la fuerza que iba a arrastrar el lanzamiento de .NET, producto al que recibia con expectativas positivas debido a que el cerebro detras de esto era nada menos que Anders Hejlsberg quien habia sido arquitecto de Delphi en sus dos primeras versiones, del cual solo podria esperar que introdujera en la nueva plataforma la evolucion de las innovaciones que habian sido introducidas originalmente en Delphi.

(Para ese entonces Borland libera Kylix, el cual debo decir que nunca use)

Obviamente que apenas pude me consegui una de las primeras Beta de Visual Studio .NET, aparatoso como buena beta, ya dejaba ver que habia asumido totalmente el modelo de objetos, y por todas partes se notan los guiños a Delphi, especialmente en C# en el tema de la gestion de eventos, comprendi entonces que me encontraba ante una herramienta potente y sobre todo que introducia la programacion RAD y orientada a eventos al desarrollo Web, algo tan simple y a la vez potente era algo por lo que los desarrolladores habiamos estado esperando buen tiempo. Pero lo mas importante era que todo lo aprendido sobre OOP en Delphi se aplicaba directamente en la nueva plataforma, y a estas alturas creo que mi transicion fue mucho mas simple que si hubiera venido solo procedente de VB6, lenguaje que con todo lo flexible que era, te enmascaraba muchos detalles los cuales no te permitian una total potencia en el desarrollo.

Para cuando llegue a España ya habia experimentado con la Beta 2 (y una pre-Beta2 no lanzada masivamente pero que me fue facilitada en Microsoft Peru), por lo que seria cuestion de tiempo que me terminara involucrando en proyectos de .NET como ha sido hasta la fecha, incluyendo examenes de certificacion en el interin.

Han pasado los años y es gracias a CampusMVP que me entero de unos articulos de Ian Marteens(al cual ya habia leido por 1999) en los que se hacen interesantes comparativas entre Java y C#, enterandome de que la implementacion de los Generics en C# es mejor que en Java, pero confirmando algo que ya habia intuido en mis primeras peleas con Java: su implementacion de eventos es penosa, ya que como el mismo Marteens dice “Los diseñadores de Java eran personajes que odiaban los punteros, y nunca hubiesen aceptado implementar los eventos al estilo Delphi. De hecho, ni siquiera tuvieron en cuenta el soporte para eventos cuando crearon Java”. No vieran el alivio que tuve al leer esto, durante mucho tiempo creia que era yo quien podria estar haciendo algo mal cuando trate de implementar cosas en Java, pero como se puede ver en esta serie de articulos, hay errores (llamalos caracteristicas si quieres) en la implementacion del lenguaje, y era algo que alguien que provenia del entorno Delphi podia intuir, pero es bueno saber que hay bases formales para entender las ventajas de un lenguaje (lenguaje, no plataforma, esa es otra guerra) sobre otro.

Como digo, es un camino el que me ha traido hasta aqui y ese camino empezo con la experimentacion de Delphi, herramienta que a pesar de no trabajar con ella en años, no puedo sino recordar con cariño y agradecimiento por las bases que me dejo.

(*)Recordemos los fuertes ataques que recibia VB por no incluir algo tan simple como la herencia.

Repasando el Remix en el SIMO


Como ya lo tenía planeado hoy día asistí al reMIX España el cual se llevo a cabo dentro del SIMO Network, sonaba interesante la idea, pues a diferencia de la mayoría de conferencias de Microsoft esta estaba centrada en el tema de interfaces de usuario, lo cual nunca está de mas saber.

El lado negativo de esta conferencia no debo atribuirlo a Microsoft sino al propio personal de IFEMA, tradicionalmente he asistido a diversos eventos de Microsoft con solo dar mi nombre y comprobando este en la lista de asistentes, pero lamentablemente la cerrazón del personal de Ifema me impidió asistir el día de ayer a la presentación de Windows 7, por lo que tuve que ir a una cabina a imprimir mi invitación y de esta manera no perderme el reMix, para que el día de hoy notara la insistencia de los empleados en pedir tarjeta o datos de empresa, mal de su parte.

Microsoft siempre tiene un objetivo en sus presentaciones, en este caso introducirnos a las ventajas que trae Windows 7, y lo mas fundamental plantear el paradigma de integración en los procesos de diseño de interfaz de usuario y la programación “pura y dura”, amen de lo usual en estos eventos: promocionar sus herramientas de desarrollo y tecnologías, curiosamente el plato fuerte en este sentido no fue Visual Studio sino Silverlight y Microsoft Expression.

Luego del clásico discurso motivador de uno de los Developer Evangelist de Microsoft, dos empresas playmusic.fm y Telecinco enseñaron el estado de sus desarrollos usando estas tecnologías, y la verdad es que la primera para ser un startup ha apostado por crear una interfaz moderna, yendo mas allá del clásico formulario de caja de texto y botones (paradigma contra el cual se iría a lo largo de la jornada), la verdad es que para quien toda la vida ha trabajado en esta clase de interfaces, primero con Delphi, luego VB y ASP.NET el pensar en carruseles y drag and drop … cuesta un poco, pero no hay que perder esto de vista a la hora de plantearse un diseño de aplicaciones.

También toco un vistazo a Azure, el cual si bien esta en beta no dudo que en breve sera demandado por las empresas, por lo que tocara estar listos.

Luego se explico sobre el Expression SketchFlow, herramienta la verdad que era completamente desconocida para mi, la cual sin ser totalmente revolucionaria la veo muy útil, siendo la sesión eminentemente practica se nos enseño como se crea un prototipo de aplicación navegable, siendo el objetivo transmitir la clase de cosas que podrá hacer la aplicación al cliente, esta herramienta resulta muy practica para discutir y definir ajustes de una manera más clara que mediante enésimos powerpoints o documentos de Word. El pequeño problema, como comentábamos con Jordi, es que Microsoft partió de la idea de ofrecerla como una herramienta para los diseñadores gráficos antes que como una utilísima herramienta para el Analista Funcional.

Esto me hizo pensar en un detalle, si bien Microsoft nos recalca la evolución que se está dando desde el punto de vista de las interfaces de usuario y como quienes desarrollamos debemos pensar más de acorde a estos tiempos y a los nuevos tipos de usuarios, por otro lado no se recalco mucho en la necesidad que hay en el “lado del diseño” de pensar en la funcionalidad y sobre todo en desarrollar buenas prácticas que permitan un trabajo de equipo de manera integrado, algo de esto lo comente hace dos años, y creo que aún permanece vigente y se hará necesario reflexionar sobre cómo hacer que las bonitas interfaces que nos mandan (gracias a Photoshop o Corel) sean fácilmente trasladables a una aplicación “real” ya sea en ASP.NET, Silverlight o Windows Forms.

La siguiente sesión antes del almuerzo ya fue más light y con pretensiones de ser divertida, se trataba de dar un vistazo a las novedades de Windows 7 en cuanto a interfaz de usuario y sobre la forma de acceder programáticamente a ellas, por lo menos se cumplió con el objetivo de dar ese vistazo y dejarnos con la curiosidad de intentar explorar.

A la vuelta del almuerzo (bocadillo de tortilla de patatas y ensalada cortesía de Microsoft) tocaba una sesión a la cual le tenía interés pues a Silverlight solo lo he visto cuando alguna web (como esta imprescindible Web dedicada al evento de ALM del año pasado) lo utiliza en vez de Flash (palabra que no fue mencionada en ningún momento del remix, lo cual es una señal clara de intenciones), lamentablemente el nerviosismo del expositor no permitió explotar totalmente un tema que de por si era muy interesante.

En contraparte, la conferencia final dedicada a Surface, sí que cumplió con las expectativas ya que tanto la claridad del expositor de Plain Concepts como los ejemplos (sencillitos pero efectivos prueba de concepto) permitieron consolidar la idea sobre el cambio de paradigmas de uso de la informática, la nueva clase de usuarios en estos tiempos, y como pensar a la hora de tratar de aprovechar la tecnología que está saliendo.

En resumen una de las mejores conferencias de Microsoft a la que haya asistido, también será por el factor novedad de mi parte, pero al menos me dejo la idea de cosas a tomar en cuenta para el desarrollo futuro de aplicaciones. Lo malo: es que no se menciono en ningún momento a Windows Forms, es que claro todo el empuje va hacia Silverlight y Windows Presentation Foundation.

 

Ya es oficial… LINQ to SQL es obsoleto

Hace unos meses decidi hacer un experimento en casa, se trataba de combinar (y asi practicar) el uso de SQL Server 2008, Windows Presentation Foundation y… LINQ to SQL. El proyecto consistia en meter en una Base de Datos el grueso de mi coleccion de MP3, sus posiciones relativas al Ranking de Doble9, y mediante LINQ (en vez de T-SQL) efectuar las respectivas consultas.

Pues si, el experimento ha funcionado bien a efectos de las consultas, no tanto a nivel de WPF, pues…. como buen ingeniero a veces fallamos en la parte de la estetica y la funcionalidad, pero el caso es que mejor hubiera sido al reves (al menos ya lo tengo todo en SQL Server) pues hoy gracias a Directions on Microsoft me vengo a enterar que Microsoft ha decidido reemplazar LINQ to SQL por el ADO.NET Entity Framework, que si.. que seguira funcionando pero no se beneficiara de las innovaciones que vaya desarrollando Microsoft.

En parte tiene sentido el movimiento, cuando empece con mis primeras pruebas una de las primeras cosas que intente fue ver si era capaz de conectarse a Oracle, lo cual… no era posible, y por ahi salian las recomendaciones de que eso debia de hacerse mediante el Entity Framework, y claro.. entre trabajar un API que solo te permite conectarte a una BD (por mas de que sea la mejor) y otra mas abierta… las cosas caen por su peso.

LINQ to SQL debuted with LINQ in the .NET Framework 3.5 in 2007. LINQ is a set of APIs and programming language features that enable data access queries to be written in programming languages such as C# and Visual Basic, rather than treated as text data. LINQ simplifies data access code and enables the developer to use the Visual Studio tools, such as the compiler and IntelliSense command completion, to help write queries. At its launch, LINQ supported a variety of data sources, including in-memory data objects and XML documents, and the Microsoft C# team had built a stopgap LINQ connector to SQL Server—LINQ to SQL.

However, when LINQ to SQL shipped, the Microsoft data access team had already begun work on the ADO.NET Entity Framework, a more general data access technology that provides LINQ connectivity to SQL Server and other database management systems, including Oracle and IBM DB2. When the Entity Framework was introduced with the .NET Framework 3.5 SP1 in July 2008, LINQ to SQL became largely redundant.
…….
Microsoft has begun publishing documentation for migrating applications from LINQ to SQL over to the Entity Framework. Migration is manual, and both application-side LINQ code and data access code might have to change. Furthermore, the Entity Framework itself is due for major changes, some designed to simplify migration from LINQ to SQL and address requests from LINQ to SQL developers. Consequently, developers who have existing LINQ to SQL applications might want to wait for the next version of the Entity Framework, due in late 2009 with the .NET Framework 4, before attempting a migration.

Creo que sera buena idea estar pendiente de las betas para saber como va evolucionando el Entity Framework, asi que … mi experimento sigue sin terminar 😉