May 2006 - Posts

¡¡¡Intellisense en SQL Server!!!
Aunque parezca mentira, llegó el día en que podemos disfrutar de algo de Intellisense en SQL Server. SQL Prompt es un producto de Red Gate Software y estará disponible de forma gratuita hasta el 1 de Sept. de 2006.

Intellisense for SQL Server

¡A descargar!

Comparte tu código en CodePlex
En este nuevo sitio, construido sobre Team Foundation Server, podrás compartir tus proyectos y código fuente con tus compañeros de trabajo en cualquier lugar del mundo.
Starter Kit para Manejo de Requerimientos
Con este Starter Kit para Visual Studio Team System tu equipo de desarrollo puede agrupar, interpretar, distribuir y sincronizar requerimientos de tu proyecto en documentos de Word estructurados, utilizando las VS 2005 Tools for Office y VS 2005 Team Foundation Server.

Lo puedes descargar desde aquí: Microsoft Downloads – Requirements Authoring Starter Kit

Por acá un par de artículos que hablan de este starter kit:

  • Using the Requirements Authoring Starter Kit (Part 1 of 2)
  • Using the Requirements Authoring Starter Kit (Part 2 of 2)

    Las buenas ideas abundan entre la gente de Microsoft. ¿No creen?

  • Seis productos de Microsoft que se construyen sobre Windows Workflow Foundation
    Windows Workflow Foundation ya está sirviendo de base para algunos productos que ya han entrado incluso en fase de beta testing:
    • Microsoft Office Sharepoint Server 2007. Le agregará escenarios de Workflow al ya sonado Office 2007.
    • Microsoft System Center Service Desk. Automatiza la IT de la empresa involucrando gente, procesos y tecnologías.
    • Microsoft Speech Server 2007
    • Microsoft Biztalk Server (próxima versión). Sienta las bases para el Business Process Management (BPM) de nueva generación.
    • Microsoft Identity Integration Server. Para el manejo de las cuentas de usuario.
    • Microsoft Dynamics. Soluciones para el negocio ahora con escenarios de workflow.

    Ya decía yo que el "Foundation" tenía que venir de algún lado.

    Mide la velocidad de tu código con el Stopwatch

    Esta nueva clase llamada Stopwatch, que es parte del System.Diagnostics y que viene como parte del .NET Framework 2.0, hace sumamente sencilla la tarea de medir el tiempo que se toma en ejecutarse una determinada sección de código. Por ejemplo:

    Stopwatch watch = new Stopwatch(); 
    watch.Start();

    Asistencias.ProcesarHorasExtra(DateTime.Today); 
     
    watch.Stop();
    TimeSpan ts = watch.Elapsed;string tiempo = String.Format("{0} horas, {1} minutos, {2} segundos y {3} milisegundos", 
    ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds);
     
    Console.WriteLine("Tiempo transcurrido: " + tiempo);

    Con esas cuantas líneas pude saber rápidamente cuánto tiempo tomaba en ejecutarse mi proceso de cálculo de horas extra.

    Gran utilidad para estas cuestiones del día a día.

    MSBuild a Fondo

    En este artículo de la edición de Junio de la MSDN MagazineSayed Ibrahim Hashimi escribe sobre los fundamentos de MSBuild, el motor de "builds" o generación de compilados que incluye el .NET Framework 2.0.

    "In this article I will introduce you to MSBuild and show you how to use it to customize your builds. I will demonstrate how to use MSBuild from the command line and show you how you can replicate the same process that is used when your projects are built from the Visual Studio IDE."

    Leer artículo...

    Desarrollo de Software Basado en Componentes

    El presente artículo trata sobre los beneficios del desarrollo de software basado en componentes, su evolución, su industrialización gracias a nuevas tecnologías como la plataforma .NET y su relación con el nuevo esquema de las Fábricas de Software.

    1. Introducción

    La complejidad de los sistemas computacionales actuales nos ha llevado a buscar la reutilización del software existente. El desarrollo de software basado en componentes permite reutilizar piezas de código preelaborado que permiten realizar diversas tareas, conllevando a diversos beneficios como las mejoras a la calidad, la reducción del ciclo de desarrollo y el mayor retorno sobre la inversión. Al comparar la evolución del ambiente de IT con el crecimiento de las metrópolis actuales, podemos entender el origen de muchos problemas que se han presentado históricamente en la construcción de software y vislumbrar las posibles y probables soluciones que nos llevarán hacia la industrialización del software moderno.

    Este proceso de industrialización ha dado ya sus inicios con implementaciones como la plataforma .net, la cual impulsa la idea de industrializar el software utilizando tecnologías de componentes. Los avances y mejoras presentados en esta plataforma van mucho más allá de las implementaciones iniciales como COM y CORBA, convirtiendo a los componentes .net en verdaderas piezas de ensamblaje, en un estilo muy similar a las líneas de ensamblaje modernas. Asimismo, los nuevos paradigmas como las Fábricas de Software proveen de los medios para hacer la transición desde el 'hacer a mano' hacia la fabricación o manufactura de software.

    Si hay algo que ha aprendido el ser humano desde tiempos muy antiguos es a reutilizar el conocimiento existente para sus cada vez más ambiciosas empresas. En efecto, al reutilizar trozos de experiencias, ideas y artefactos, no solo nos aseguramos de no cometer los mismos errores del pasado, sino que logramos construir cosas cada vez más grandes y maravillosas, con bases firmes y calidad incomparable. Este concepto de la reutilización, uno de los primeros que se nos enseñan a quienes entramos al mundo del desarrollo de software, habremos de utilizarlo desde el mismo instante en que escribamos nuestra primera línea de código.

    Los sistemas de hoy en día son cada vez más complejos, deben ser construidos en tiempo récord y deben cumplir con los estándares más altos de calidad. Para hacer frente a esto, se concibió y perfeccionó lo que hoy conocemos como Ingeniería de Software Basada en Componentes (ISBC), la cual se centra en el diseño y construcción de sistemas computacionales que utilizan componentes de software reutilizables. Esta ciencia trabaja bajo la filosofía de "comprar, no construir", una idea que ya es común en casi todas las industrias existentes, pero relativamente nueva en lo que a la construcción de software se refiere.

    Para este momento, ya muchos conocen las ventajas de este enfoque de desarrollo y, de la misma forma, muchos se preguntan día a día el por qué son tan pocos los que realmente alcanzan el éxito siguiendo esta filosofía. En realidad, hasta ahora solo hemos tanteado un poco con las posibilidades del software basado en componentes, y es justo hora, en la presente década, que la industria del software despegará y se perfeccionará para estar a la par de cualquier otra industria del medio. Las analogías que nos han llevado a estudiar a los sistemas comparándolos con las complejas metrópolis de la actualidad, así como las iniciativas más innovadoras como las Fábricas de Software de Microsoft, son la clara representación de que estamos a punto de presenciar un nuevo gran cambio en la forma como pensamos en software.

    2. Beneficios del Desarrollo de Software basado en Componentes

    En esencia, un componente es una pieza de código preelaborado que encapsula alguna funcionalidad expuesta a través de interfaces estándar(1). Los componentes son los "ingredientes de las aplicaciones", que se juntan y combinan para llevar a cabo una tarea(2). Es algo muy similar a lo que podemos observar en el equipo de música que tenemos en nuestra sala. Cada componente de aquel aparato ha sido diseñado para acoplarse perfectamente con sus pares, las conexiones son estándar y el protocolo de comunicación está ya preestablecido. Al unirse las partes, obtenemos música para nuestros oídos.

    El paradigma de ensamblar componentes y escribir código para hacer que estos componentes funcionen se conoce como Desarrollo de Software Basado en Componentes. El uso de este paradigma posee algunas ventajas:

    1. Reutilización del software. Nos lleva a alcanzar un mayor nivel de reutilización de software.
    2. Simplifica las pruebas. Permite que las pruebas sean ejecutadas probando cada uno de los componentes antes de probar el conjunto completo de componentes ensamblados.
    3. Simplifica el mantenimiento del sistema. Cuando existe un débil acoplamiento entre componentes, el desarrollador es libre de actualizar y/o agregar componentes según sea necesario, sin afectar otras partes del sistema.
    4. Mayor calidad. Dado que un componente puede ser construido y luego mejorado continuamente por un experto u organización, la calidad de una aplicación basada en componentes mejorará con el paso del tiempo.

    De la misma manera, el optar por comprar componentes de terceros en lugar de desarrollarlos, posee algunas ventajas:

    1. Ciclos de desarrollo más cortos. La adición de una pieza dada de funcionalidad tomará días en lugar de meses ó años.
    2. Mejor ROI. Usando correctamente esta estrategia, el retorno sobre la inversión puede ser más favorable que desarrollando los componentes uno mismo.
    3. Funcionalidad mejorada. Para usar un componente que contenga una pieza de funcionalidad, solo se necesita entender su naturaleza, más no sus detalles internos. Así, una funcionalidad que sería impráctica de implementar en la empresa, se vuelve ahora completamente asequible.

    3. Metrópolis: Analogía de la Evolución del Software basado en Componentes

    Pat Helland(3), uno de los arquitectos con mayor experiencia en Microsoft, ha desarrollado recientemente una metáfora llamada Metrópolis(4), en la cual compara la evolución de las tecnologías de la información con la forma como las ciudades de Estados Unidos han evolucionado durante los 2 últimos siglos. Al comprender la evolución de las ciudades actuales, podemos darnos una idea del futuro promisorio que tiene el desarrollo de software basado en componentes.

    Como lo menciona Helland, las ciudades y las casas de software comparten un pasado muy similar, pues ambas empezaron en ambientes que se desarrollaron aisladamente. Este desarrollo independiente conllevó a diferencias de cultura con respecto a la forma como se hacían las cosas. A mediados del siglo XIX, las vías de ferrocarril conectaron la mayor parte de las ciudades en los Estados Unidos. Esto permitió que las personas y distintos artículos empezaran a trasladarse de una forma que no era posible anteriormente. Se inició entonces una carrera por asegurar que los artículos trabajen entre sí y cumplan estándares de compatibilidad. Estos cambios en expectativas y capacidades alimentaron la explosión del comercio, la fabricación y llevaron a la urbanización de la vida, tal y como la conocemos hoy.

    Por muchos años, las casas de software han desarrollado aisladamente, con aplicaciones creadas independientemente y sin mayor necesidad de interacción entre ellas. Dado que estas aplicaciones no estaban conectadas, no había mayores consecuencias para aquello. Pero recientemente se ha vuelto muy práctico el interconectar tanto las aplicaciones dentro de una casa de software, así como entre múltiples casas de software alrededor del mundo. Ahora la gente ya puede navegar y visitar aplicaciones muy distantes. Cantidades cada vez más grandes de información son fácilmente transmitidas entre aplicaciones. Pero lo que aún es difícil es hacer que estos datos trabajen entre distintas aplicaciones.

    Para entender entonces lo que está ocurriendo en este momento con el ambiente IT hay que explorar 6 facetas de esta analogía:

    Ciudades - Casas de Software
    Las ciudades evolucionaron gradualmente como lugares para hacer comercio y manufactura. En estas ciudades existían edificios con poca o ninguna conexión entre ellos. Las ciudades tenían un contacto muy limitado con sus ciudades aledañas y desarrollaron su propia cultura, estilo y forma de hacer cosas (Ver Figura 1). De la misma forma, las casas de software evolucionaron gradualmente mientras nuevas aplicaciones fueron construidas y luego extendidas. Cada aplicación separada e independiente de sus similares en la misma casa de software. Cada casa de software tenía su propia cultura, estilo y forma de hacer las cosas (Ver Figura 2):





    Figura 1: Evolución de las ciudades. Volver al texto.
     



    Figura 2: Evolución de las casas de software. Volver al texto.

    Las presiones económicas cambiaron nuestras ciudades, ya que fue la oportunidad económica la que realmente llevó a las ciudades a la modernización, a compartir servicios y a pensar en medios creativos para alcanzar eficiencias. Asimismo, las presiones económicas están cambiando nuestras casas de software. Mientras se construyen nuevas aplicaciones y se renuevan las más antiguas, hay que considerar cómo enlazarlas a la infraestructura compartida, cómo conectarlas y cómo dividirlas de manera que se maximice la reusabilidad de las mismas. Este es el reto al que todos nos vemos enfrentados en la actualidad.

    Fábricas y Edificios - Aplicaciones
    En los primeros años del siglo XIX, la manufactura típicamente era simple e independiente. Los bienes producidos estaban limitados tanto por las necesidades del mercado local, como por la sofisticación del proceso de manufactura. Las fábricas producían todas las partes del ensamblado final, armaban el ensamblado e incluso lo vendían. Si uno quería un par de zapatos, tenía que irse a la fábrica de zapatos. Esta no era la forma más eficiente de fabricar bienes y los ítems fabricados eran caros y usualmente no de la mejor calidad (Ver Figura 3). Muchas de nuestras aplicaciones actuales son como aquellas fábricas. Producen datos procesados independientemente unos de otros, los cuales se entregan en 'mercados' limitados. Están integradas verticalmente y usualmente no aceptan el trabajo de otras aplicaciones como entrada (Ver Figura 4).



    Figura 3: Fábricas y edificios. Volver al texto.
     

    Figura 4: Aplicaciones. Volver al texto.

    El ferrocarril alteró profundamente la manufactura. Al bajar los costos de transportar las partes fabricadas, el mismo permitió que los fabricantes locales produjeran bienes más sofisticados y de mayor calidad. La componentización les permitió a los artesanos enfocarse en sus principales competencias, en lugar de tener que entender los diversos procesos necesarios para producir todo un ensamblado sofisticado. Los negocios se especializaron e independizaron. Tanto para las fábricas como para las aplicaciones, la independencia es esencial. Uno no puede terminar su trabajo si se necesita hacer que todo trabaje en conjunto perfectamente. Pero, aunque la independencia es esencial, no se pueden olvidar las ventajas de la interconexión, ya que es a través de la reutilización del trabajo de los demás que uno logra cumplir su trabajo con éxito y es justamente la demanda que ejercen los demás sobre nuestro trabajo lo que nos da el estímulo económico para seguir existiendo.

    Transporte - Comunicaciones
    A mediados del siglo XIX llegó el ferrocarril. Se hicieron enormes cantidades de dinero moviendo personas, carbón y trigo de un lugar a otro. Con una demanda arrolladora de transporte, eventualmente todo Estados Unidos estaba interconectado por ferrocarril. No solo que la gente empezó a viajar a nuevos lugares para conocer nuevas culturas, sino que ahora los comerciantes podían vender artículos de formas nunca antes pensadas. Pero más importante aún, el movimiento de los artículos despertó la expectativa de que las cosas funcionen en conjunto. Antes del ferrocarril simplemente no importaba si los bienes de un fabricante eran incompatibles con los de otro fabricante.



    Figura 5: Transporte. Volver al texto.
     

    Figura 6: Comunicaciones. Volver al texto.

    Al final del siglo XX llegó Internet. Se invirtieron montos enormes en navegación, correo electrónico, JPEGs, MP3s y chat. Se tendieron los hilos para permitir la navegación y el movimiento de las formas más simples de datos. El navegador le permitió a la persona el transportarse para interactuar directamente con una aplicación distante. Sin embargo, el movimiento de los datos aún no funciona bien en conjunto, haciendo muy limitados los procesos de negocios a través del Internet. Las nuevas conexiones implicaron nuevos cambios en la estandarización de los artículos y los datos. Pronto esto implicaría cambios en los procesos de negocios.

    Bienes Fabricados - Datos Estructurados
    A inicios del siglo XVIII los bienes se hacían a mano. Los ensamblados se creaban "haciendo ajustes". Si una llave no encajaba en la cerradura, se ajustaba la cerradura de alguna manera para que permita el paso de la llave. Pioneros como Honore LeBlanc y Eli Whitney propusieron la idea de crear partes estandarizadas en el proceso de manufactura. Al establecer controles severos sobre la especificación y producción de las partes componentes, se pudieron realizar masivas producciones de todo tipo de artículos. Sin embargo, esta era una estandarización hacia dentro de las empresas. Pero para finales del siglo XVIII la idea ya se había expandido entre los fabricantes y se produjeron todo tipo de estándares para las partes comunes. Había tamaños y medidas para los artículos, con la expectativa de que aquellos producidos por una fábrica serían intercambiables e interoperables con componentes similares y complementarios producidos por otra. Las compañías que produjeron las partes con un alto grado de precisión tuvieron éxito; lo que tenían un proceso menos consistente, fracasaron (Ver Figura 7 y Figura 8)



    Figura 7: Bienes fabricados. Volver al texto.
     

    Figura 8: Datos estructurados. Volver al texto.

    Hoy en día aún tenemos estructuras de datos no estandarizadas. Cada aplicación modela la información a su propia manera y dependemos de operadores humanos para 'ajustar' las aplicaciones y así lograr integrarlas. Es necesario agregar semántica para hacer que las aplicaciones se entiendan. De la misma forma como el mercado demandó que se pudieran intercambiar artículos a finales de los '80, el mismo demandará el intercambio de datos en un futuro cercano. Esto significa estandarizar la funcionalidad de conceptos de negocio como un 'cliente' o una 'orden de compra'. Las organizaciones que no se percaten de las eficiencias de la integración-por-diseño perderán a la larga frente a los que persigan estas eficiencias. El resultado de este cambio será un boom económico para las compañías que sobrevivan a él y un dramático mejoramiento para el diario vivir de las personas.

    Ensamblados Fabricados - Empresas Virtuales
    La mayoría de los fabricantes de bicicletas no producen llantas, de la misma forma como quienes hacen camisas no producen sus propios botones. Al crear ensamblados con los mejores componentes disponibles, los fabricantes de bicicletas pueden crear productos más sofisticados y de mayor calidad. La competencia entre fabricantes de componentes conlleva eficiencias y mejoras en la calidad. Para lograr esto, necesitan especificaciones detalladas de las partes componentes, así como deben también considerar el contexto en el que cada parte será usada. Las compañías de hoy en día están 'creando ensamblados' de su funcionalidad de negocios (Ver Figura 9). En lugar de crear un departamento de distribución y entrega, el trabajo se entrega como outsourcing. En lugar de fabricar el producto, se delega la construcción del mismo a una compañía que se especialice en producción de bajo costo y alta calidad. La definición de 'compañía' evoluciona (Ver Figura 10).



    Figura 9: Ensamblados fabricados. Volver al texto.
     

    Figura 10: Empresas virtuales. Volver al texto.

    Las comunicaciones de alta velocidad e información estructurada ofrecen beneficios similares, produciendo la virtualización de las organizaciones. Se puede crear un modelo de componentes de negocio definiendo claramente la semántica y requerimientos operacionales de nuestras capacidades de negocios. Al definir interfaces claras, se puede encapsular los detalles de cómo estas capacidades son implementadas y cada componente puede ser orquestado como miembro de cualquier número de procesos. Se pueden incluso crear proveedores especializados que ofrezcan servicios de marketing, ventas, producción, recursos humanos, etc. Para lograr esto, se necesitan especificaciones detalladas de las capacidades de los componentes. Así, con estándares, se puede lograr la composición de cualquier cosa, porque los proveedores de componentes pueden manejar el costo de optimización a través de mercados amplios y la competencia conlleva cada vez mayores eficiencias.

    Comercialización y Distribución - Procesos de Negocio
    A finales del siglo XIX los centros de comercio urbanos se habían desarrollado. Los bienes se habían vuelto más sofisticados y las opciones del consumidor habían aumentado. Sin embargo, el ir de compras era algo tedioso. Un día de compras podía implicar el tomar el tren hacia la ciudad, luego ir donde el carnicero y luego donde el panadero, pasar comprando las verduras y por último una vuelta por la farmacia. Sin embargo, muy pronto la estandarización de los tamaños redujo significativamente el costo de muchos bienes permitiendo la producción masiva y la habilidad de transportar bienes a ubicaciones centrales para la venta y dieron origen a los centros comerciales y el supermercado. Así por ejemplo, Wal-Mart logró nuevas eficiencias al hacer primar el poder del comercio sobre los fabricantes. Wal-Mart logró proveer de una experiencia de compras placentera, de bajo costo y centralizada en un solo punto (Ver Figura 11).



    Figura 11: Comercialización y distribución. Volver al texto.
     

    Figura 12: Procesos de negocios. Volver al texto.

    Examinando la situación actual de los procesos de negocios, podemos observar dos tipos de integración. Una de ellas se basa simplemente en enviar un fax y esperar que el mismo haya sido recibido y que tal vez nos respondan. Otra técnica que reduce errores es la conocida integración ALT-TAB, la cual permite el uso del porta papeles para copiar datos entre aplicaciones. Pero si se quiere hacer algo realmente mejor, se necesita lograr el intercambio y estandarización de datos y operaciones. Los procesos de negocios aún son hechos a mano y los estándares son muy pobres. En lo futuro, los procesos de negocios crecerán para ser la fuerza que le dé la forma y defina los estándares para las nuevas aplicaciones, de la misma forma como Wal-Mart impone los estándares para cientos y miles de artículos (Ver Figura 12).

    4. Industrialización del Software a través de la Plataforma .net

    La Plataforma .net representa una nueva etapa en la evolución de COM, la plataforma de componentes de Microsoft. Con ella, Microsoft impulsa la idea de 'industrializar' el software utilizando tecnologías de componentes(5).

    Las tecnologías COM y CORBA, equivalentes a la era industrial temprana, han logrado producir partes intercambiables básicas. El mayor avance de la Plataforma .net es la implementación de la parte intercambiable de software en la herramienta de desarrollo misma, de manera que cada 'parte' de software creada es un componente intercambiable. Este es un avance equivalente a la etapa de 'línea de ensamblaje' de la industrialización. La plataforma en sí es análoga a una industria de creación de herramientas, la cual entrega a los vendedores de software ambientes especializados de desarrollo, conocidos también como 'fábricas' para el ensamblaje eficiente de 'máquinas de software' basadas en servicios Web.

    La tecnología de metadatos del Lenguaje Intermedio (IL) de .net, a través de la cual un compilador automáticamente crea un 'plano' de la interacción de componentes en 'assemblies', nos recuerda las líneas de ensamblaje recientes, donde la unidad que está siendo ensamblada lleva consigo las instrucciones para su creación. Clemens Szyperski(6), arquitecto experimentado de Microsoft, confirma esta analogía:

    El construir software ensamblando componentes conlleva grandes promesas para la ingeniería de software de la nueva generación. Yo iría más allá y aseguraría que no se puede hablar de ingeniería antes de haber dominado este paso ... Si no, se está hablando de hacer las cosas a mano, algo similar a la manufactura temprana previa a la Revolución Industrial. Así que, es claro que deberíamos empezar a construir software basado en componentes.

    Estos 'planos' conocidos como metadatos representan la interfaz del componente, la clave para el intercambio e interoperabilidad, en términos de un 'contrato' que la interfaz hace con su infraestructura. Los lenguajes de definición de contratos están en el límite de la ciencia de las computadoras.

    Así, la plataforma .net se convierte en una implementación ejemplar que ya es parte de la Revolución Industrial del Software que nos mencionaba Bill Gates(7) hace varios años ya:

    ... La Revolución Industrial del software está finalmente ante nosotros. La especialización de recursos, estándares para partes intercambiables, y herramientas de ensamblaje de última generación han sido usadas en otras industrias por cientos de años para acelerar el desarrollo de productos altamente complejos. A pesar de su ubicuidad, la aplicación de estos conceptos a la industria moderna del software solamente ha empezando.

    5. Fábricas de Software: el Nuevo Paradigma

    Las Fábricas de Software son una iniciativa propuesta por Microsoft que plasma la necesidad y provee de los medios para hacer la transición desde el 'hacer a mano' hacia la fabricación o manufactura. En sí, una Fábrica de Software es un ambiente de desarrollo configurado para soportar el desarrollo acelerado de un tipo específico de aplicación. Las Fábricas de Software no son más que el siguiente paso lógico en la evolución continua de los métodos y prácticas de desarrollo de software; sin embargo, prometen cambiar el carácter de la industria de software introduciendo patrones de industrialización(8).

    ¿Es posible automatizar el desarrollo del software? En realidad, ya lo hemos hecho. Los editores WYSIWYG por ejemplo, hacen mucho más fácil el construir y mantener interfaces gráficas de usuario, proveyendo beneficios como independencia de dispositivos y el ensamblaje visual. El diseño de base de datos ofrece formas similares de automatización. El tema recurrente que podemos observar en la creación de este tipo de herramientas es el hecho de pensar en modelos, más que solamente en objetos(9).

    Uno de los elementos clave de este patrón es el elevar el nivel de abstracción de los desarrolladores. Actualmente usamos UML para la documentación. Sin embargo, lo que buscamos hoy en día es la productividad. Mientras los estereotipos y los tags pueden ser usados para decorar modelos UML, la experiencia muestra que se necesitan características más precisas del lenguaje para soportar compilación, depuración, pruebas y otros tipos de tareas de desarrollo.

    Pero aún cuando los modelos juegan un rol importante, no lo son todo. Para llegar a niveles más altos de productividad necesitamos la habilidad de configurar, adaptar y ensamblar rápidamente componentes desarrollados independientemente, autodescriptivos e independientes de ubicación, para producir así familias de sistemas similares, pero diferentes. Para ello, será necesaria la creación de patrones con dominio específico, frameworks y herramientas que se alineen tanto con la arquitectura del producto como con el ciclo de vida del producto. Más aún, debemos considerar los procesos que usamos para analizar requerimientos, desarrollar software y ponerlo en producción. Necesitamos disponer de las mejores prácticas, contenido reutilizable y distintos tipos de patrones. La aplicación de todo esto en conjunto se conoce como Fábrica de Software.

    Una fábrica de software es una línea de producto que configura herramientas de desarrollo extensibles como Microsoft Visual Studio Team System con contenido empaquetado y guías, cuidadosamente diseñadas para construir tipos específicos de aplicaciones. Una fábrica de software contiene tres ideas básicas:

    • Un esquema de fabricación. La analogía de esto es una receta. En ella se listan ingredientes, como proyectos, código fuente, directorios, archivos SQL y archivos de configuración, y explica cómo deberían ser combinados para crear el producto. Especifica qué Lenguajes de Dominio Específico (DSL) pueden ser usados y describe cómo los modelos basados en estos DSLs pueden transformarse en código y otros artefactos, o en otros modelos. Describe la arquitectura de la línea de producto, y las relaciones clave entre componentes y frameworks que la componen.
    • Una plantilla de fábrica de software. Esta es una gran bolsa de supermercado que contiene los ingredientes listados en la receta. Provee los patrones, guías, plantillas, frameworks, ejemplos, herramientas personalizadas como herramientas para edición visual de DSLs, scripts, XSDs, hojas de estilos, y otros ingredientes para construir el producto.
    • Un ambiente de desarrollo extensible. Un ambiente como Visual Studio Team System es la cocina en la cual la comida es cocinada. Cuando se configura con una plantilla de fábrica de software, Visual Studio Team System se convierte en una fábrica de software para la familia de productos.

    Si llevamos más allá la analogía, los productos son como comidas servidas en un restaurante. Los clientes de la fábrica de software son como los clientes que ordenan comidas de un menú. Una especificación de producto es como una orden de comida específica. Los desarrolladores del producto son como cocineros que preparan las comidas descritas en las órdenes, los cuales podrían modificar las definiciones de las comidas, o preparar comidas fuera del menú. Los desarrolladores de la línea de producto son como chefs que deciden qué aparecerá en el menú, y qué ingredientes, procesos, y equipo de cocina se usará para prepararlos.

    Un ejemplo más concreto del uso de una fábrica de software sería el diseño de un esquema para la construcción de aplicaciones de clientes livianos para comercio electrónico usando el Microsoft .net Framework, C#, el Microsoft Business Framework, Microsoft SQL Server, Microsoft Biztalk Server y el Microsoft Host Integration Server - una familia amplia pero muy útil de aplicaciones. Podríamos usar este esquema de fábrica de software para configurar Visual Studio Team System para convertirse en una fábrica de software que construya miembros de esta familia.

    Para este ejemplo, el esquema de software podría contener un DSL que represente requerimientos configurables, un DSL para describir procesos de negocios, un DSL para describir modelos lógicos y físicos, un DSL para describir la navegación Web, y un DSL para describir entidades de negocio. Podríamos usar las características de extensibilidad de Visual Studio Team System para hostear una plantilla de fábrica de software basada en este esquema. En esa plantilla incluiríamos algunos bloques de aplicación liberados por el grupo de Microsoft Patterns and Practices, políticas de check-in de Team Foundation Server, estructuras de proyecto, la guía de proceso de Microsoft Solution Framework (MSF), entre otros. Con esta fábrica de software, el equipo de desarrollo podría rápidamente lanzar una variedad de aplicaciones de comercio electrónico, cada una conteniendo características únicas basadas en requerimientos únicos de clientes específicos.

    Las fábricas de software son posibles hoy en día y representan el intento de aprender de otras industrias que encaran problemas similares, y aplican patrones específicos de automatización a tareas de desarrollo manual existentes. Las fábricas de software vuelven más rápida, barata y fácil la construcción de aplicaciones, concretando así la visión de la industrialización del software moderno.

    6. Conclusión

    Tenemos la fortuna de presenciar el nacimiento de una nueva forma de hacer software, que traerá beneficios inmensos para todos. El desarrollo de software basado en componentes desde siempre fue la idea revolucionaria que nos llevó a pensar que sí era posible el construir software de calidad en corto tiempo y con la misma calidad que la mayoría de las industrias de nuestro tiempo. Al mirar hacia atrás, vemos los increíbles avances que hemos logrado en la comprensión de la forma correcta de reutilizar el software y el conocimiento existente, y nos asombramos cada vez más al darnos cuenta de que este solo es el inicio.

    El desarrollo de software basado de componentes se convirtió en el pilar de la Revolución Industrial del Software y se proyecta hoy en día en diversas nuevas formas de hacer software de calidad con los costos más bajos del mercado y en tiempos que antes eran impensables. Empresas como Microsoft entendieron el potencial de esta metodología hace años y hoy nos ofrecen nuevas iniciativas y herramientas que buscan llevar al proceso de construcción de software hacia el sitial privilegiado en el que debió colocarse desde un principio.


    (1) WebCab Components, About Component Based Development, http://webcabcomponents.com/componentization.shtml

    (2) ComponentSource, What are components?, http://www.componentsource.com/Services/WhatAreComponents.asp?bhcp=1

    (3) Pat Helland tiene 25 años de experiencia en la industria del software y ha sido arquitecto en Microsoft desde 1994. Ha trabajado por más de 20 años en bases de datos, procesamiento de transacciones y sistemas distribuidos. Fue uno de los fundadores del equipo que implementó y llevó al mercado el Microsoft Transaction Server (MTS), ahora conocido como COM+.

    (4) Microsoft Architects Journal 2, Metrópolis, http://msdn.microsoft.com/architecture/journ/default.aspx?pull=/library/en-us/dnmaj/html/aj2metrop.asp

    (5) Components Online, .NET Platform as Component Infrastructure,
    http://www.components-online.com/NETPlatform/default.htm

    (6) Clemens Szyperski se unió a Microsoft Research como Arquitecto de Software en 1999. Su enfoque está en el uso efectivo del softwre de componentes para construir nuevos tipos de software. Su galardonado libro "Component Software: Beyond Object-Oriented Programming" fue revisado y extendido hacia una segunda edición en el 2002. Ha servido en numerosos comités de programas, incluyendo ECOOP, ESEC/FSE, ICSE, y OOPSLA y ha organizado varios eventos internacionales.

    (7) Bill Gates, Chairman y Chief Software Architect de Microsoft. Dueño de uno de los imperios de software más grandes que jamás haya existido y probablemente una de las personas más influyentes del mundo moderno, por sus ideas innovadoras y altamente acertadas, como aquella de 'un computador en cada hogar'. El extracto presentado fue sacado de una publicación hecha en el año de 1997.

    (8) Microsoft Architects Journal, The Case for Software Factories, http://msdn.microsoft.com/architecture/journ/default.aspx?pull=/library/en-us/dnmaj/html/aj3softfac.asp

    (9) Jack Greenfield, Industrializing Software Development, http://blogs.msdn.com/askburton/archive/2004/09/20/232065.aspx

    Usa una Outlook Bar en tus aplicaciones CAB

    Haciendo uso del CAB (Composite UI Application Block), Matias Woloski creó un OutlookBarWorkSpace, el cual es sumamente parecido a la OutlookBar de Microsoft Outlook 2003. Dicho workspace se puede incorporar fácilmente a un cliente Windows para dar al usuario la misma flexibilidad y productividad que se obtiene de Outlook.

    OOutlook Bar Workspace Show more/few buttons

    Leer artículo...

    Accediendo a bases de datos externas utilizando CLR stored procedures

    Ciertas aplicaciones necesitan acceder a información de múltiples orígenes de datos, es decir, más de una base de datos. Más aún, los datos pueden venir de servidores diferentes e incluso de motores de base de datos diferentes. Estos son escenarios comunes en ambientes que almacenan grandes cantidades de datos heterógeneos, en donde no solo intervienen bases de datos Oracle o SQL Server, sino también otros tipos de motores como DB2 y similares.

    En los casos en los que SQL Server interviene como uno de los motores que proveerán de información a la aplicación, puede aprovecharse la capacidad de escribir código CLR en SQL Server para lograr que sea SQL Server quien consulte a los otros motores de bases de datos que intervienen en la aplicación. ¿Con qué objetivo? Pues una razón válida, aunque no necesariamente ideal, puede ser para abstraer por completo a nuestra aplicación .NET de la necesidad de interactuar con múltiples bases de datos simultáneamente.

    Típicamente, para acceder a orígenes de datos diferentes a SQL Server y Oracle, utilizamos el proveedor de datos ODBC que incluye el .NET Framework. Siendo así, la estrategia sería utilizar aquel proveedor desde nuestro stored procedure escrito, por ejemplo, en C#.

    Sin embargo, el acceder a una base de datos externa mediante ODBC desde un stored procedure hecho en CLR presenta desafíos con respecto a las seguridades predeterminadas que maneja SQL Server 2005. Si queremos instruir a SQL Server para que "confíe" en nuestro código que accederá a bases de datos externas, debemos hacer lo siguiente:

    1. En el proyecto que contiene al stored procedure hecho en CLR:
      1. Abrir las propiedades del proyecto.
      2. Seleccionar el Tab "DataBase"
      3. En Permission Level seleccionar "Unsafe"
    2. En SQL Management Studio de SQL Server 2005, en la base de datos que contendrá el stored procedure, ejecutar el siguiente query:

    ALTER DATABASE <NombreBaseDatos> SET TRUSTWORTHY ON

    Una vez hecho esto, la interacción con la base de datos externa no debe presentar ningún inconveniente. Aquí un código ejemplo que consulta la base de datos NorthWind en un servidor externo por medio de un DSN accedido por ODBC:

    using System;
    using System.Data;
    using System.Data.SqlClient;
    using System.Data.SqlTypes;
    using Microsoft.SqlServer.Server;
    using System.Security.Permissions;
    using System.Data.Odbc;
     

    public partial class StoredProcedures
    {
        [Microsoft.SqlServer.Server.SqlProcedure]
        public static void EmpleadosTraerLista()
        {
            using (OdbcConnection cn = new OdbcConnection("DSN=NorthWind;UID=elUserId;PWD=elPassword"))
            {
                OdbcCommand cmd = new OdbcCommand("SELECT CustomerID, CompanyName FROM Customers", cn);
                OdbcDataReader rdr = null;
     
                try
                {
                    cn.Open();
                    rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                    while (rdr.Read())
                    {
                        SqlContext.Pipe.Send(rdr.GetString(0) + " " + rdr.GetString(1));
                    }
                }
                finally
                {
                    if (rdr != null)
                    {
                        rdr.Close();
                    }
                }
            }
        }
    };

    De esta forma, nuestra aplicación nunca tendría que conocer cómo interactuar con cada base de datos, pues únicamente invocaría el stored procedure hecho en CLR.

    Escogiendo entre DataSets y DataReaders

    El escojer una metodología de acceso a datos adecuada para las necesiades de la aplicación en construcción es uno de los temas que más polémica y dudas causa a los desarrolladores de la plataforma .NET. En este pequeño artículo resumo algunas de mis razones y conclusiones que sigo fielmente a la hora de escojer mi propia metodología.

    La regla fundamental es esta:

    Usar siempre DataSets, a menos que se tenga una buena razón para utilizar DataReaders.

    Explico esta afirmación desde los dos puntos de vista más importantes a considerar: Rendimiento y Productividad.

    Rendimiento

    Los DataReaders son usualmente más rápidos, dado que no poseen el costo asociado con la creación de los DataSets. Sin embargo, los DataReaders son menos flexibles y son poco útiles en situaciones en las que se necesita hacer caché de datos en memoria y pasar los datos hacia componentes en una aplicación que tiene varias capas.

    Se prefiere el uso de DataReaders cuando se cumplen las siguientes condiciones:

    • Se necesita acceso solo hacia adelante y de solo lectura a los datos y se requiere acceder a los datos tan rápido como sea posible y no se necesita hacer caché de los mismos.
    • Se posee un contenedor, como por ejemplo un componente de negocios en el cual se puede colocar los datos.

    Se prefiere el uso de DataSets cuando las siguientes condiciones sean ciertas:

    • Se necesita hacer caché de datos o pasar los datos entre capas.
    • Se necesita tener una vista relacional de los datos en memoria.
    • Se desea actualizar algunas o todas las filas retornadas y/o se desea hacer actualizaciones en batch a través del DataAdapter.
    • Se necesita enlazar datos a un tipo de control al que los DataReaders no pueden ser enlazados. La mayoría de los controles de Windows Forms necesitan un origen de datos que implemente la interfaz IList. El DataSet implementa IList, pero el DataReader implementa IEnumerable. Por ello, los DataReaders se pueden enlazar a la mayoría de los controles Web, pero no a la mayoría de los controles Windows.
    • Se necesita accesar a múltiples sets de datos al mismo tiempo, y no se quiere mantener abiertas las conexiones al servidor.
    • Los DataSets en ADO.NET 2.0 han sido mejorados (prácticamente reescritos) de tal forma que ahora pueden procesar millones de registros en tan solo unos pocos segundos, cosa que en ADO.NET 1.1 usualmente tomaba varios minutos e incluso horas.
    • Los DataSets en ADO.NET 2.0 soportan serialización binaria, lo cual les permite viajar entre el cliente y el servidor mucho más rápido que en ADO.NET 1.1, ya que antes solo podían viajar en formato XML.

    Productividad

    El utilizar DataReaders como medio para acceder a los datos lleva irremediablemente a construir entidades o clases de negocios que alojen los datos traidos por los Readers para así poder llevarlos hacia capas superiores. Esto es el inicio de un largo camino en el que hay que ingeniárselas para resolver cientos de problemas que se presentan al tener que trabajar con entidades personalizadas, cosa que no ocurre nunca con los datasets, pues estos ya incorporan todo lo que se necesita para llevar los datos entre capas.

    En la mayoría de los casos, se debería diseñar la aplicación para que se centre en los datos. Se puede utilizar la flexibilidad y la funcionalidad nativa de los DataSets para soportar múltiples clientes (Windows, Web, etc) con gran facilidad, reducir la cantidad de código personalizado y usar una API (Interfaz de Programación de Aplicaciones) que sea familiar a la mayoría de los desarrolladores. Aunque el trabajar con datos de una forma puramente orientada a objetos tiene sus beneficios, el codificar a mano entidades de negocios complejas incrementa drásticamente el tiempo de desarrollo y los costos de mantenimiento en proporción a la cantidad de características que se desea proveer.

    Se prefiere el uso de DataReaders cuando se cumplen las siguientes condiciones:

    • Se tiene todo el tiempo del mundo para ponerse a escribir entidades de negocio propias y para construir varias abstracciones que le permitan a uno escribir rápidamente el código que llevará los datos desde el Reader hacia tus clases de negocio. Escribir entidades de negocio personalizadas es una tarea que conlleva múltiples complejidades y que requiere un nivel bastante alto de conocimientos de todos los desarrolladores que intervendrán en el desarrollo de la aplicación.
    • Se posee los recursos ($$$) sufientes como para comprar un excelente generador de código ó un excelente ORM (Object Relational Mapper) que resuelva todos los problemas de convertir datos en entidades de negocios.
    • Los "jefes" o el cliente han impuesto unas métricas de rendimiento tan pero tan altas que uno se ve forzado a utilizar DataReaders por su alta velocidad. Este caso es muy pero muy poco usual, ya que los DataSets tienen un rendimiento sumamente alto hoy en día y rara vez se nota la diferencia entre el comportamiento de ambos.

    Se prefiere el uso de DataSets cuando se cumple lo siguiente:

    • Se tiene un cronograma que no da tiempo para hacer nada más que resolver el problema del cliente de la mejor forma posible. Por lo tanto, no hay tiempo para reinventar la rueda haciendo entidades de negocio propias. Los datasets tienen un impresionante número de funcionalidades que son increíblemente útiles en el trabajo diario. Cuestiones como búsquedas, filtrados, tranferencia de datos, traida de datos, actualizaciones masivas, manejo de errores, enlace con controles, manejo de valores Null, etc. Los Datasets poseen todo lo que le tomaría meses y hasta años construir y estabilizar a uno solo o a un equipo de desarrollo.
    • Se necesita tener una manera tan estándar de trabajar con los datos que el incorporar a nuevos desarrolladores no force a enseñarle a cada uno la manera de utilizar las clases personalizadas que solo el líder de desarrollo conoce como usarlas. Toda persona que aprende ADO.NET conoce cómo hacer las típicas tareas de acceso a datos y manipulación de los mismos utilizando DataSets.
    • No se quiere lidear con las complejidades que implica el serializar objetos complejos entre capas de la aplicación, como cuando se utiliza clientes Windows y Servicios Web y se necesita transferir datos entre ellos.
    • Se desea reducir dramáticamente la cantidad de código escrito para acceder a datos. Al usar datasets se utiliza interfaces sumamente amigables y listas para usar, más aún si se utiliza DataSets tipificados, los cuales pueden ser diseñados visualmente en el Diseñador de Datasets de Visual Studio. Aquí cabe recalcar que el nuevo diseñador de datasets de Visual Studio 2005 es sumamente poderoso y amigable, mucho más que el de Visual Studio 2003, de manera que, usualmente, no se tendrá que escribir casi ninguna línea de código para hacer las tareas de acceso a datos desde .NET.

    Es realmente recomendable utilizar DataSets para el acceso y manipulación de datos, a menos que una de las condiciones descritas arriba lleve a la persona a utilizar Readers. Lo expuesto aquí tampoco significa que se deba usar 100% DataSets o 100% DataReaders. Lo más común es escojer DataSets para resolver el 80% o 90% de los escenarios y utilizar Readers para resolver escenarios muy especiales que realmente demandan un rendimiento muy superior para ser factibles.

    Lecturas adicionales recomendadas:

    Asegurando una sola instancia de una forma hija en un MDI

    Típico te piden que desean que, en tu aplicación MDI, cada vez que escogen abrir un formulario hijo este se abra en la misma ventana, mas no en ventanas separadas. Es decir, si la forma hija ya está abierta, elegir esa, sino ahí sí abrirla. Bueno, es un requerimiento válido, aunque no necesariamente siempre deba ser así. Dado que me gusta hacer cosas un poco fuera de lo común, en mi aplicación MDI yo no tengo una barra de menús, sino más bien un TreeView desde el cual los usuarios eligen el formulario a abrir. Entonces, lo que yo quisiera poder hacer es esto:  

    Private Sub RecursosHumanosTreeView_NodeMouseClick(...) Handles ...
            Select Case e.Node.Name
                Case "Forma1Node"
                    MostrarForma("Mi forma 1")
                Case "Forma2Node"
                    MostrarForma("Mi forma 2")
                Case "Forma3Node"
                    MostrarForma("Mi forma 3")
            End Select
    End Sub  

    ¿Cuál sería la forma ideal de lograr un código así de sencillo? Recuerden que la función MostrarForma() debe instanciar la forma correcta según el parámetro enviado. Eso si es que no está ya abierta, porque en ese caso debe más bien activarla. Dado que estoy usando VB 2005, se me ocurrió sacarle provecho a los nuevos Generics. Así, logré hacer a una pequeña función que me redujo el código de una manera increíble y elegante. Esta es mi pequeña función:  

    Private Sub MostrarForma(Of T As {Form, New})()
            For Each formaAbierta As Form In My.Application.OpenForms
                If TypeOf (formaAbierta) Is T Then
                    formaAbierta.Activate()
                    Exit Sub
                End If
            Next
            Dim forma As New T
            forma.MdiParent = Me
            forma.Show()
    End Sub  

    Lo interesante aquí, como podrán notar, está en la declaración de la función. Básicamente al decir MostrarForma(Of T...) estoy indicando que el método recibe un parámetro de un tipo T, es decir, un tipo que solo será conocido en tiempo de ejecución. Pero, dado que yo sé de antemano que lo que recibiré será siemrpe un formulario, pues apliqué un constraint que solo permita formas: MostrarForma(Of T As {Form...}). Así mismo, dado que yo sé que, si la forma hija aún no está abierta deberé instanciarla, agrego otro constraint de tipo New. Así, mi declaración quedó: MostrarForma(Of T As {Form, New})().   De allí creo que lo demás es obvio. Simplemente busco de entre todas las formas abiertas si alguna de ellas es del tipo T (el tipo de la forma solicitada). Si es así, pues simplemente la activo. Caso contrario creo una nueva instancia de ella y la muestro. Con esta función lista, la llamada queda entonces así:  

    Private Sub RecursosHumanosTreeView_NodeMouseClick(...) Handles ...
            Select Case e.Node.Name
                Case "Forma1Node"
                    MostrarForma(Of MiForma1)
                Case "Forma2Node"
                    MostrarForma(Of MiForma2)
                Case "Forma3Node"
                    MostrarForma(Of MiForma3)
            End Select
    End Sub  

    ¿Simple no? Por supuesto en estas cosas siempre hay una forma más simple de hacerlo. ¿Saben de una mejor forma? Please, ¡háganmela conocer!

    Más envíos