Blog de Miguel Llopis

Microsoft Data Explorer Preview para Excel

Hoy en Microsoft hemos anunciado la disponibilidad pública de Microsoft "Data Explorer" Preview para Excel.

Para aquellos que han seguido mi blog en el pasado, quizá recordaréis posts anteriores sobre la version “SQL Azure Lab” de Data Explorer… Como podréis intuir, en los últimos meses no he podido escribir aquí al haber estado bastante ocupados mejorando “Data Explorer” y convirtiéndolo en lo que podéis probar hoy como Preview (Excel add-in), y que estará disponible próximamente dentro de Excel.

Descarga Microsoft Data Explorer Preview para Excel

¿Qué aporta “Data Explorer”?

"Data Explorer" enriquece la experiencia de Self-Service Business Intelligence en Excel proporcionando una forma muy fácil de descubrir e importar datos desde una amplia variedad de fuentes de datos, refinar y aumentar esos datos fácilmente y ayudar a los usuarios a llevar estos datos a Excel para su análisis posterior con Excel, análisis en memoria con PowerPivot y visualización de datos con PowerView.

"Data Explorer" soporta una amplia variedad de fuentes de datos, incluyendo bases de datos relacionales (SQL Server, Windows Azure SQL database, Oracle, IBM DB2, Access, etc.), diferentes formatos de archivos (texto/Csv, Excel, XML, entre otros) y algunas otras fuentes de datos no tradicionales como Web (tablas de HTML, XML/JSON APIs, etc.), Hadoop (HDFS), OData, Active Directory, Facebook, etc.. Además, "Data Explorer" también proporciona capacidades de búsqueda en Internet sobre millones de tablas de Wikipedia, a través de Bing… Encuentra tablas de datos disponibles en la web, directamente desde Excel e impórtalos en tu hoja de Excel en un par de clicks!

Además de proporcionar conectividad a una gran variedad de fuentes de datos, con "Data Explorer" también es fácil transformar y refinar los datos al proporcionar una interfaz de usuario intuitiva que ayuda a los usuarios a definir pasos de transformación con gestos fáciles. Estas capacidades se ofrecen de forma consistente a través de todos los orígenes de datos soportados, sin necesidad de ningún conocimiento sobre las tecnologías subyacentes para el usuario final en Excel.

"Data Explorer" también permite aumentar tus datos fácilmente y te ayuda a combinar los datos provenientes de todas estas fuentes de datos mediante “Merge” (join) o “Append” (union).

Finalmente, la integración entre "Data Explorer" y el resto de las herramientas de BI en Excel (incluyendo PowerPivot y PowerView) es tan fácil como puedas imaginar... Simplemente importa tus datos en la hoja de Excel, o cárgalos en el modelo de datos de Excel 2013 en un solo click.

Escribiré unos cuantos artículos con análisis y ejemplos sobre cada una de estas áreas en las próximas semanas y meses, pero por ahora puedes ver este video de resumen y descargar “Data Explorer”.

 

Enjoy!

Disponible el vídeo de mi sesión sobre Data Explorer en “Las 12 horas de SQL Server 2012”

Desde hace unos días ya es posible acceder a los vídeos de las distintas sesiones del evento “Las 12 horas de SQL Server 2012”, evento en el cual tuve el privilegio de participar hace unas semanas con una sesión acerca de Microsoft Codename “Data Explorer”.

 

Si todavía no has tenido ocasión de probar “Data Explorer”, puedes solicitar acceso a nuestro cloud service y también probar la versión Desktop la cual tiene integración con Excel 2007/2010 y el resto de características disponibles en la versión Cloud a excepción de las opciones de publicación y colaboración.

Por último me gustaría reiterar mis agradecimientos y enhorabuena al equipo de organización del evento, a la asociación PASS Spanish Group, a Eladio Rincón, a la gente de Microsoft Iberica y al resto de colaboradores que hicieron posible que el evento fuera todo un éxito en participación y en nivel de contenidos.

Posted: 30/12/2011 15:59 por Miguel LLopis | con no comments |
Archivado en:
Y tú… ¿has encontrado ya al poni escondido en tus datos?

Esta semana hemos lanzado oficialmente el lab de “Data Explorer”, disponible dentro de SQL Azure Labs… Desde hace unos días ya podéis descargar la versión local de “Data Explorer” y, si fuísteis de los primeros en pedir acceso a nuestro cloud service, ya habréis recibido o estaréis a punto de recibir vuestra invitación por email. También podéis visitar nuestra Learning Page donde encontraréis una cantidad considerable de tutoriales y vídeos sobre “Data Explorer” o nuestro blog oficial en MSDN.

Y por supuesto, no os podéis perder hoy Lunes las “12 horas de SQL Server 2012” donde tendré el privilegio de compartir una hora con vosotros gracias a la enorme labor de organización llevada a cabo por el amigo Eladio Rincón y el resto de gente del PASS Spanish Group… Sin duda será uno de los mejores eventos del año en lengua hispana!

Probad “Data Explorer”, buscad al poni que se esconde en vuestros datos, enviadnos feedback

Gracias!!

Microsoft Codename “Data Explorer”: Un vistazo a fondo…

En mi post anterior anunciaba Microsoft Codename “Data Explorer”, un nuevo servicio en la nube de Azure que permite generar valor añadido a partir de tus fuentes de datos mediante la posibilidad de descubrir nuevas fuentes relacionadas con el dominio en cuestión, enriquecer esta información mediante la creación de nuevos “mashups” que integren varias de estas fuentes y finalmente publicar el resultado de diversas formas para compartirlo con quien tú quieras. En este post describiré un escenario de principio a fin empleando Data Explorer.

En este escenario, una consultora de negocio (Anna) debe asesorar a la empresa Contoso Yogurt para decidir dónde deberían abrir sus tres próximas tiendas en el área de Seattle.

A fin de responder a esta pregunta, Anna necesita considerar diversos aspectos acerca de los clientes objetivo, las características demográficas de cada ubicación potencial, etc. Anna también debe predecir la posible reacción de la gente que vive cerca de las nuevas ubicaciones después de que las tiendas estén abiertas; es decir, cuál es la percepción o sentimiento de estas personas acerca de estas tiendas.

Anna ya tiene acceso a la mayoría de las fuentes de datos que contienen la información que necesita, bien porque ella es propietaria de los datos o porque los datos son parte de los sistemas de información de su empresa. Además, Anna sabe que hay otras piezas útiles de información en “su entorno” que puede aprovechar, como páginas web, foros, redes sociales u otros lugares en Internet. Anna todavía no sabe cómo podría aprovechar estos valiosos datos, pero gracias a la potencia de "Data Explorer", ahora ella puede utilizar estos datos y obtener nuevas conclusiones.

Estas son las diferentes fuentes de datos que Anna tiene previsto emplear y considera útiles para ayudarle en el proceso de decisión:

  • Listado de tiendas de Contoso Yogurt existentes: Esta información está disponible en una base de datos de SQL Azure que pertenece a su empresa.
  • Listado de nuevas ubicaciones potenciales: Anna ha realizado algunas investigaciones y ha creado una lista de posibles ubicaciones para nuevas tiendas de Contoso Yogurt. Esta lista contiene algunos de los centros comerciales más populares en la zona. Estos datos se almacenan en una hoja de cálculo de Excel.

Anna tiene un amigo en el equipo de Data Explorer que le ha dado acceso a Data Explorer.

Una vez que ha iniciado sesión, se encuentra con la página de bienvenida.

En esta página, Anna selecciona Dashboard para comenzar a trabajar con sus datos.

Anna selecciona Add data source para añadir las dos fuentes de datos que necesita. Esto conduce a Anna a la página para agregar una nueva fuente de datos, en la que puede añadir una gran variedad de fuentes de datos… Puede conectar a recursos de red como bases de datos (SQL Server y SQL Azure), consumir contenidos de una página web, un feed de OData o datos provenientes de Windows Azure Marketplace. Alternativamente, puede añadir datos de su propia máquina (archivos de Excel, Access, texto, etc.) o incluso crear datos “in situ” tecleando, copiando/pegando o calcularlos empleando una fórmula.

Anna conecta a la base de datos de SQL Azure introduciendo información del servidor, base de datos, usuario y password…

A continuación, Anna añade el archivo de Excel con información de centros comerciales para las nuevas ubicaciones potenciales.

Ahora que Anna ha añadido sus dos fuentes de datos, regresa a la página de Dashboard, donde puede encontrar estas dos fuentes en la parte derecha. Además, obtiene información sobre clasificación semántica de los datos que ya ha añadido, así como recomendaciones de otros datasets interesantes que puede añadir a su análisis, provenientes de Azure Marketplace y Bing.

Anna encuentra estas recomendaciones interesantes y las incorporará a su análisis más adelante. Lo próximo que va a hacer Anna es combinar la información de tiendas existentes con la lista de nuevas ubicaciones potenciales… Es decir, combinar una tabla de SQL Azure con otra tabla de Excel… Esto, generalmente, no es una tarea trivial; sin embargo, empleando Data Explorer, Anna puede conseguirlo simplemente seleccionando ambas fuentes y haciendo click en Mashup.

Al hacer esto, Anna accede al “Mashup Editor”, en el cual podrá comenzar a manipular, transformar y enriquecer los datos de ambas tablas.

En próximos posts hablaré en detalle acerca de este editor; no obstante, hay algunos conceptos básicos que introduciré hoy para hacer el resto del post más fácil de comprender…

En la esquina superior izquierda del editor, encontramos el panel de recursos, el cual muestra los dos recursos que Anna está tratando de combinar, ShoppingCenters y ContosoStoreTraq. La opción New le permite añadir otra fuente de datos, mientras que Merge le permite combinar ambos recursos en una única tabla.

 

El recurso seleccionado es ContosoStoreTraq, por lo que obtenemos una vista previa en el editor. Justo encima de la ribbon hay dos “cajas” de color gris; a esta región la conocemos como la Secuencia de Tareas (Task Stream), y representa el conjunto de tareas o transformaciones que han sido aplicadas al recurso actualmente seleccionado. Estas tareas son útiles para filtrar, reordenar, analizar, agrupar, transformar nuestros datos; y pueden ser encontradas en el ribbon.

Empleando la secuencia de tareas, podemos navegar por todas y cada una de las tareas, regresando a una tarea anterior para modificarla o incluso eliminarla o renombrarla. Al navegar por estas tareas, la vista previa se actualiza para mostrar el resultado parcial después de aplicar la tarea en cuestión.

Es importante mencionar también que ninguna de estas tareas modifica el estado de los datos en el origen; estamos construyendo una vista sobre estos datos, de sólo lectura. Después de definir una secuencia de tareas, esta secuencia es almacenada de modo que la podamos reutilizar posteriormente; definiremos o diseñaremos el flujo de datos y transformaciones una vez, para posteriormente aplicarlo cada vez que queramos de forma automatizada.

En el editor también encotramos recomendaciones sobre datasets relevantes en el dominio de datos en el que estamos actualmente trabajando (mostrados en la esquina inferior izquierda en color azul). Puesto que Anna está trabajando con direcciones de tiendas y centros comerciales, los datasets recomendados son datos demográficos en estas áreas (provenientes de Data Market) e información de Bing PhoneBook API.

A continuación, Anna quiere combinar estos dos recursos porque la información sobre tiendas existentes contiene un indicador de rendimiento/rentabilidad (basado en los ingresos generados por cada tienda). A Anna le gustaría que este indicador apareciera junto a cada centro comercial en los que ya existe una tienda de Contoso Yogurt. Puede hacer esto fácilmente añadiendo una columna de lookup en ShoppingCenters

Después de añadir esta columna, Anna selecciona el dataset recomendado con información demográfica y lo añade a su mashup… Seguidamente va a combinar este nuevo recurso con ShoppingCenters, relacionándolos mediante el Zip Code (Código Postal).

Una vez que ha combinado ambos recursos, Anna va a incorporar otro de los datasets recomendados, en este caso, añadiendo datos de Bing PhoneBook para complementar el listado de centros comerciales con información de números de teléfono.

Empleando la Bing Phone Book API, Anna es capaz de crear también una nueva columna con la cuenta de institutos y escuelas situadas en un radio inferior a 10 kilómetros respecto a cada una de las nuevas ubicaciones potenciales, para tratar de maximizar el beneficio de estas nuevas tiendas teniendo en cuenta que los niños y adolescentes son clientes habituales de este tipo de tiendas.

Adicionalmente, Anna podría incluir otro de los datasets recomendados para medir el sentimiento o afinidad de la gente por cada uno de los centros comerciales en la lista, de modo que pueda seleccionar aquellos que van a tener mejor aceptación por parte de los clientes.

Resumiendo, Anna ha comenzado su análisis con una tabla proveniente de SQL Azure y otra proveniente de un archivo de Excel, las ha relacionado y ha incorporado información de otros datasets recomendados que provienen de Azure Marketplace y Bing API. Un escenario de integración de datos bastante avanzado para un usuario de negocio, pero que Anna ha podido realizar de forma rápida, sencilla e intuitiva mediante el uso de Data Explorer.

Finalmente, Anna quiere compartir los resultados de su análisis con sus compañeros y para ello hace uso de las opciones de publicación incluidas en Data Explorer, que le permiten publicar los resultados en diversos formatos de archivo (Excel, texto, etc.), o exponer el resultado de forma que sea consumible desde otras herramientas de análisis como por ejemplo PowerPivot, o incluso exponer un feed de OData que pueda ser consumido desde cualquier otra aplicación. En próximos posts entraré en detalle a describir cada una de estas alternativas de publicación…

Pronto tendréis la oportunidad de probar Data Explorer, podéis registraros aquí para recibir acceso próximamente.

Desde el equipo de Data Explorer estamos trabajando intensamente para que la funcionalidad y calidad de Data Explorer sea óptima. Como consecuencia de esto, quizá el aspecto de alguna de estas capturas sea diferente de lo que encontréis en el producto cuando lleguéis a usarlo dentro de unas semanas…

No obstante, espero que el post haya servido a modo de ejemplo ilustrativo de uso de Data Explorer y de las nuevas posibilidades que representa.

Posted: 23/10/2011 22:24 por Miguel LLopis | con no comments |
Archivado en:
Anunciando Microsoft Codename "Data Explorer"

Durante la keynote de Ted Kummert en PASS Summit 2011, hemos realizado el primer anuncio oficial acerca de Microsoft Codename "Data Explorer".

Regístrate aquí si quieres probarlo…

¿En qué consiste "Data Explorer"?

"Data Explorer" proporciona una revolucionaria forma de trabajar con tus datos! Estas son algunas de las características principales (de las cuales hablaré largo y tendido en próximos posts...): 

  • Identifica las fuentes de datos relevantes para ti, bien aquellas que te pertenecen u otras disponibles "en la nube". 
  • Obtén recomendaciones automáticas sobre conjuntos de datos (feeds, servicios, etc.) que puedan ser de interés para ti, basados en el tipo de información con la que estás trabajando. 
  • Enriquece y combina todas estas fuentes de datos para generar valor e información que te ayude a tomar decisiones. 
  • Trabaja con fuentes de datos heterogéneas como si fueran una única fuente, olvídate de los detalles sobre cómo acceder a todas estas fuentes y céntrate en generar valor a partir de ellas (datos de SQL Server y SQL Azure, feeds de OData y Windows Azure DataMarket, archivos de Excel, documentos de texto, etc.) 
  • Colabora y comparte tus "mashups" con quien tú quieras para refinar la información. 
  • Publica los resultados para que otros puedan visualizarlos, o incluso consumirlos desde otras aplicaciones.

 

¿Suena interesante?

 

                - Regístrate aquí para probar "Data Explorer" próximamente.

                - Sigue nuestro blog oficial (en Inglés).

                - Participa en nuestros foros de MSDN.

                - Síguenos en Facebook, y en Twitter.

 Y, por supuesto, sigue pendiente de este blog... Prometo publicar nuevos posts con mucha mayor frecuencia que en estos últimos meses... : )

Posted: 13/10/2011 7:13 por Miguel LLopis | con 1 comment(s) |
Archivado en:
PDC 2010: Os esperamos en Redmond!

Esta semana se han hecho públicos los detalles acerca del PDC 2010.

¿Dónde? Campus de Microsoft en Redmond (WA).

¿Cuándo? 28 y 29 de Octubre

Para más información y registro (plazas limitadas!), visitad la web oficial del evento: www.microsoftpdc.com

¡Os esperamos!

Posted: 17/7/2010 4:00 por Miguel LLopis | con 2 comment(s)
Archivado en:
Modeling in Text: Serie de screencasts sobre el lenguaje M

Durante las últimas semanas he tenido la oportunidad de grabar una serie de cinco screencasts sobre el lenguaje M para nuestra web en MSDN.

La serie está dividida en cinco capítulos, en los cuales partimos de un conocimiento previo sobre M prácticamente nulo para posteriormente incrementar la funcionalidad de nuestro ejemplo a medida que introducimos nuevos conceptos del lenguaje. El contenido de cada uno de los capítulos es el siguiente:

  1. “Modeling a Language”: En este capítulo explico de qué forma podemos modelar nuestros propios lenguajes, comenzando por la creación de un lenguaje sencillo que reconozca una única sentencia (“Chris is 24 years old”) para posteriormente incorporar nuevos conceptos y funcionalidades del lenguaje y poder generalizar dicho lenguaje, así como modificar la estructura del AST / proyección resultante.
  2. “Data”: Esta segunda parte de la serie se centra en explicar cómo consumir el resultado obtenido en el capítulo anterior (estructuras de datos en M generadas a partir de la “compilación” de un archivo de texto escrito en nuestro propio DSL), de modo que podamos importar dichos datos a SQL Server, vía herramientas de línea de comandos (M.exe y Mx.exe), así como visualizar dichos datos en Quadrant una vez forman parte de nuestro repositorio en SQL Server.
  3. “Transformation”: En este vídeo veremos la estructura general de la transformación de M a sentencias T-SQL, así como diferentes alternativas para escribir funciones de manipulación sobre dichos datos en M, que posteriormente serán transformadas en vistas de SQL.
  4. “Constraints”: Este capítulo muestra de qué forma podemos imponer restricciones sobre nuestros datos (definir el tipo de datos de cada atributo, etc.), y analizamos cómo su traducción a T-SQL resulta diferente en función de dichos cambios.
  5. “Identity and relationships”: En la última parte de la serie, describimos cómo crear relaciones entre distintas entidades, mediante el uso de IDs, etiquetas y colecciones que referencian a dichos elementos.

Aprovecho para recomendar a aquellos interesados en SQL Server Modeling (M, Quadrant, Repositorio) que visiten nuestra sección de videos en la cual no sólo podréis encontrar esta serie sino también vídeos de las sesiones del PDC de Don Box, Chris Anderson, Chris Sells, etc., así como bastantes más screencasts sobre las tecnologías que estamos construyendo.

Enjoy!

He leído: “CLR Via C#”, 3ª Edición

Este fin de semana he tenido la ocasión de leer la última edición del libro “CLR via C#”, que saldrá a la venta próximamente.

CLR via C# 3rd Edition (Pro-Developer)

No descubro nada diciendo que este es uno de los libros de imprescindible lectura para todo aquel programador de .Net que se precie… Sin embargo, me gustaría destacar algunas de las novedades incluídas en esta nueva edición, que constituyen un motivo más que suficiente para que aquellos que han leído alguna de las ediciones anteriores se animen a volver a leerlo… En realidad, creo que quien haya leído este libro con anterioridad, no necesita motivos que le animen a volver a leerlo, más allá de la noticia de que una nueva edición ha sido publicada…

En esta edición, la principal novedad es la inclusión de una nueva sección (unas 200 páginas extra) dedicadas a Threading, mecanismos de gestión concurrente en Windows y su correspondencia en el “nuevo” CLR 4.0, operaciones asíncronas y políticas de sincronización entre hilos.

Otra sección totalmente nueva que ha sido incorporada al libro está dedicada a serialización en tiempo de ejecución.

En el resto de secciones, se han añadido o modificado conceptos para adaptarlos a las nuevas versiones del CLR y del propio lenguaje C#.

En cuanto a C# 4.0, algunos de los conceptos incorporados al libro son: tipo dynamic, parametros opcionales, variables locales implícitamente tipadas, propiedades implementadas automáticamente, tipos anónimos, inicializadores de objetos y de colecciones, uso de expresiones lambda para delegados, etc.

Respecto al CLR 4.0, se ha reescrito completamente el capítulo dedicado al manejo de excepciones en el framework, así como modificaciones notables en cuanto a la gestión automática de memoria (novedades en el garbage collector), soporte para múltiples CLRs cargados en un mismo proceso, novedades en el manejo de AppDomain, etc.

Sin duda, una lectura más que recomendable…

Disfrutadlo!

Posted: 9/2/2010 23:00 por Miguel LLopis | con 1 comment(s)
Archivado en: ,,
Pongamos que hablo de MSN Entretenimiento

Me cuenta un pajarito que el próximo jueves 4 de Febrero, a partir de las 23:30h (GMT+1) podremos disfrutar a través de MSN Entretenimiento en primicia mundial del nuevo videoclip del Maestro Sabina: “Viudita de Clicqcuot”.

MSN Entretenimiento es un servicio de MSN que pone a nuestra disposición una gran variedad (y cantidad) de contenidos multimedia online, de forma gratuita: Series de TV, música, videoclips, juegos, etc. Todo en Español…

A disfrutarlo compañer@s!!

Posted: 4/2/2010 3:26 por Miguel LLopis | con 1 comment(s) |
Archivado en:
Por qué no me gusta la métrica LOC (Lines Of Code)

[ Aprovechando las vacaciones navideñas y las 15 horas de vuelos desde Seattle hasta España para redactar unos cuantos posts que tenía en mente desde hace tiempo… ]

Hoy os hablaré sobre por qué considero que LOC no es una métrica de código demasiado útil (por decirlo eufemísticamente), algo sobre lo que estoy seguro de que habréis leído ya en bastantes ocasiones pero me gustaría aportar mi visión particular.

De vez en cuando me he encontrado con gente que me realiza preguntas del tipo: “¿Cuántas líneas de código tiene el proyecto Oslo SQL Server Modeling Services?" (cambiad esta última parte por Windows 7, o Visual Studio 2010, o SQL Server 2008, etc), o también “Miguel, ¿cuantas líneas de código escribes al día?”…

En el caso de la segunda pregunta, mi respuesta suele ser: “En algunos de los mejores días de mi vida como desarrollador, mi LOC ha sido un valor negativo. Afortunadamente, LOC no es directamente proporcional a mi productividad”.   : )

Hay dos matices que considero bastante descriptivos en cuanto a LOC:

  1. Para lo único que LOC es una medida válida es para medir el tamaño de la base de código de un proyecto.
  2. Un valor de LOC enorme en nuestra codebase no resulta ser, en muchas ocasiones, algo bueno.

Mi opinión personal es que LOC es prácticamente inútil para gestión de proyectos, para lo único que nos sirve es para hacer análisis del tipo:

  1. El módulo A es el doble de grande que el módulo B. (considerando que ambos están escritos en el mismo lenguaje (aunque esto sería también discutible, hay estudios que afirman que LOC es independiente del lenguaje empleado, pero no estoy de acuerdo en la mayoría de casos), que las coding guidelines son las mismas para ambos, etc… En cualquier otro caso, ni siquiera serían comparables)
  2. El módulo C ha crecido un 25% en los últimos 6 meses.
  3. Podemos ver cómo el módulo D tiene un elevado número de bugs, debido a su gran tamaño.

Para cuestiones relacionadas con el análisis del crecimiento/progreso en un determinado proyecto, es claramente mejor fijarse en otras métricas diferentes a LOC, como por ejemplo el número de features completadas/pendientes, etc. Si empleáramos LOC, el análisis sería incorrecto ya que alguien podría añadir 1.000 líneas de código a un proyecto sin completar una feature concreta, de igual forma que alguien podría eliminar 1.000 líneas de código y ser capaz de completar tres features.

Respecto a este último ejemplo, comentar que un índice LOC negativo es en bastantes casos el resultado de un trabajo de refactorización de código realizado como parte de la implementación de una nueva feature y puede tener un impacto significativo en el tamaño global de nuestra base de código.

Ahora que ya os he dado mi opinión personal, veamos qué dicen otras fuentes más documentadas que yo al respecto. Por ejemplo, la siguiente tabla (extraída del libro “Code Complete”) nos muestra la relación entre el tamaño del proyecto y el LOC por persona/año:

Tamaño del proyecto (LOC) LOC por persona/año
1.000 2.5K - 25K
10.000 2K - 25K
100.000 1K - 20K
1.000.000 0.7K - 10K
10.000.000 0.3K - 5K

El aspecto a destacar en esta tabla es que la cantidad de líneas de código que un desarrollador es capaz de escribir disminuye a medida que el proyecto aumenta de tamaño. Esto se debe a diversos factores, como son el hecho de que la complejidad aumenta, el impacto de las modificaciones realizadas es mucho mayor en otras partes del proyecto, el esfuerzo de testing necesario aumenta, el número de bugs aumenta, etc.

Por tanto, idealmente, un buen desarrollador no es aquel con mayor LOC, sino con mayor ratio Feature/LOC ya que eso significaría que el desarrollador está implementando nuevas funcionalidades (y por tanto aportando valor añadido para el cliente) a la vez que mantiene el tamaño de code base en unos límites razonables, lo cual permite incrementar la productividad de él mismo y del resto de compañeros en el equipo de desarrollo del proyecto.

Otros factores negativos sobre LOC los podemos encontrar en el libro “Applied Software Measurement” de Capers Jones, entre los que destacaré los siguientes:

  1. Las métricas LOC penalizan a los lenguajes de programación de alto nivel.
  2. Análisis comparativos de proyectos en los que se ha empleado más de un lenguaje de programación y que se fundamenten en LOC deberán ser considerados una mala práctica profesional.
  3. Las métricas de “Coste por bug” penalizan la calidad y hacen que un software lleno de bugs pueda parecer mejor de lo que en realidad es, a juzgar por los resultados de un estudio basado en LOC. Para este tipo de estudios, es mejor emplear métricas de Puntos de Función.

Por último, me gustaría recomendar otro libro bastante interesante “Measuring and Managing Performance in Organizations”, de Robert Austin. En este libro, Austin entrevista a varios expertos de la industria del software que aportan su opinión acerca de qué cosas conviene (o no) medir. Al final, casi todos ellos coinciden en que medir todo aquello que convendría medir en el desarrollo software es prácticamente imposible…

Merry Christmas!

Posted: 21/12/2009 20:15 por Miguel LLopis | con 3 comment(s)
Archivado en:
De Oslo a SQL Server Modeling: Anunciando nuestra nueva CTP de Noviembre de 2009

Una característica común a todos los grupos de producto en Microsoft es su trabajo constante para mejorar y refinar sus tecnologías. Este hecho se cumple aún cuando hay que afrontar diversos cambios tales como cambios en la organización o también el renombrado de dichos productos, así como encontrar para ellos una vía que los conduzca a un lanzamiento exitoso.

En este caso, ha llegado la hora de anunciar el cambio de nombre de lo que hasta ahora conocíamos con el nombre de OSLO. Nuestro nuevo nombre es: SQL Server Modeling. Este cambio, del cual ya os hablé hace unos meses, no debería coger por sorpresa a nadie puesto que algunas de las tecnologías incluídas en OSLO, como por ejemplo Quadrant, han estado siempre ligadas a SQL Server y otras, como el repositorio de modelos, directamente implementadas sobre SQL Server. Incluso en el caso de una tecnología como el lenguaje M, a priori agnóstico en cuanto al motor de bases de datos subyacente, tiene una sinergia natural con SQL Server.

Por supuesto, hay una serie de dudas y cuestiones que afloran como consecuencia de este cambio de nombre del proyecto, de las cuales probablemente estéis ya al tanto… No obstante, la respuesta más clara, concisa y sonora que os puedo dar es: independientemente del nombre bajo el que se aglutinen estas tecnologías, el compromiso por parte del equipo de producto sigue siendo absoluto con todas y cada una de ellas. Ahora, las respuestas largas para cada una de estas preguntas las podéis encontrar en esta página de Q&A.

Al margen de esta reflexión, la gran noticia en torno a Oslo SQL Server Modeling esta semana ha sido el lanzamiento de una nueva CTP: SQL Server Modeling November 2009 CTP. Esta CTP contiene nuevas versiones del lenguaje M, el diseñador Quadrant, y de SQL Server Modeling Services (previamente conocidos como “el repositorio de modelos de Oslo”).

Los aspectos generales acerca de estas novedades en nuestras tecnologías los podéis encontrar en las Release Notes, así como en nuevos artículos publicados en MSDN Library.

Sin embargo, me gustaría destacar aquellos que, a priori, considero más relevantes….

Cambios Generales

El primer cambio que notaréis al instalar esta nueva CTP es que el nombre de Oslo ha desaparecido (sniff sniff), tanto en el proceso de instalación, como en el menú de inicio. Sin embargo, aún encontraréis el nombre de Oslo en la carpeta de Archivos de Programa, y también veréis instalada en SQL Server una base de datos llamada “Repository”, al igual que en anteriores CTPs…. no nos dio tiempo de cambiar el nombre en todas partes, jeje… Resumiendo, a pesar de que el nombre de la CTP haya cambiado, estructuralmente veremos lo mismo que en previas CTPs.

El segundo cambio importante, lo encontraréis en los requerimientos de esta CTP: Visual Studio 2010 y .Net 4.0 Beta 2. Si aún no habéis instalado dichas maravillas tecnológicas, ¡éste es el momento perfecto!   : )

Como os decía, no hemos tenido tiempo de modificar el nombre en la parte estructural del proyecto, en buena parte debido a que hemos estado ocupados añadiendo funcionalidades al proyecto… Entre ellas, las siguientes…

Cambios en SQL Server Modeling Services

En primer lugar, el dominio UML incluido en CTPs anteriores (System.UML2) ha sufrido cambios significativos. Estos cambios suponen que aquellos ejemplos creados en CTPs anteriores sobre este dominio no funcionen tal cual, deben ser readaptados. Pero… a cambio, ahora es posible exportar estos modelos en UML para interoperar con otras herramientas de modelado UML.

Por otra parte, el modelo correspondiente al CLR (que nos permitía realizar queries acerca del uso de nuestros assemblies, entre otras cosas) también ha sufrido algunos cambios, especialmente en el modo de funcionamiento de la herramienta LoadAssembly.exe, la cual nos permite cargar assemblies en nuestro repositorio. Si os gusta, como a mí, el Algebra y estáis familiarizados con la teoría de conjuntos, la forma más precisa de definir estos cambios es: En la versión actual, LoadAssembly ya no calcula y carga en el repositorio la clausura transitiva de todos los ensamblados referenciados por ensamblados especificados en la línea de comandos”. Este cambio en la lógica de LoadAssembly.exe nos permite evitar cargas duplicadas de metadatos de ensamblados de .Net fx, lo cual, considerando el ahorro espacio-temporal y las mejoras en el rendimiento de LoadAssembly.exe, es una ventaja considerable.

El último aspecto a destacar en cuanto a las novedades en SQL Server Modeling Services es la creación de un nuevo ejemplo, denominado PatternApplication, el cual nos permite aplicar los patrones del repositorio a un conjunto de modelos, algo que hasta ahora se debía realizar para cada modelo de forma independiente. Podéis encontrar este ejemplo aquí.

Para más información sobre SQL Server Modeling Services, aquí tenéis la nueva página en MSDN (algo de lo que os hablaré un poco más abajo…)

Cambios en Quadrant

Quizá el cambio más obvio en esta nueva versión de Quadrant sea el esquema de colores de la UI. Hasta el momento, predominaba el color gris y plateado, y éste ha sido sustituido por el azul…

Pasando a cambios más profundos dentro de Quadrant, ya que para nosotros lo que cuenta es el interior, encontramos como rasgo general el hecho de que la presencia del lenguaje M integrado en Quadrant es notablemente mayor que en la CTP anterior. Algunos lugares donde esta integración se pone de manifiesto son:

  • Es posible escribir código en M directamente en una hoja de trabajo (File – New – M File) y desplegar una base de datos desde aquí.
  • Si disponemos de una BD ya existente, a pesar de no haber sido creada con M, podemos inferir su modelo y obtener el código en M necesario para representarla completamente (esquema y datos instanciados). A partir de este punto, y siempre desde dentro de Quadrant, podremos modificar dicho código en M y actualizar la base de datos posteriormente con estos cambios.
  • Una de las características principales de Quadrant tradicionalmente ha sido su alta capacidad de configuración y personalización de las vistas sobre nuestros datos/modelos. En la CTP actual, además podemos visualizar estas configuraciones (modelos!!) como código en M, modificarlo y actualizarlo en el repositorio de Quadrant, pudiendo aplicar dichos cambios al instante en nuestras vistas (probad la opción del menú Workpad – View Source).
  • El lenguaje M es ahora el lenguaje predeterminado para la barra de consultas de Quadrant, que además incluye validación sintáctica para queries en M, a medida que las escribimos.

Al margen de estos cambios, ha habido otros tantos refinamientos a nivel de UI en Quadrant: auto-ajuste en el tamaño de nuestro panel de diseño, control de cambios en nuestros esquemas, resolución de conflictos entre versiones y manejo de errores.

Una de las características con la que os recomiendo jugar en esta nueva versión de Quadrant es el concepto de comandos y visores personalizados. Un ejemplo que ilustra esta nueva funcionalidad es el de “Media Library for Quadrant”, disponible aquí.

Otros cambios dignos de mención en esta versión de Quadrant:

  • Nueva consola para T-SQL.
  • Mejoras de rendimiento, incluyendo virtualización de tablas.
  • Soporte para autenticación en SQL Server.

Por si esto fuera poco, coincidiendo con el lanzamiento de esta CTP, nuestros compañeros PMs de Quadrant han publicado una serie de videos explicando algunos de los escenarios principales de Quadrant. Uno de mis favoritos es Quadrant UI Overview, el cual muestra cómo personalizar la visualización de datos en Quadrant de formas que ninguna otra herramienta actual es capaz de hacer. WOW!!

Para más información sobre Quadrant, podéis acceder a la nueva página de Quadrant en MSDN.

El lenguaje M y herramientas relacionadas

Bueno, llegamos a la parte de mi querido M… Esta vez, he procurado dejarlo para el final y trataré de ser breve, para posteriormente ampliar información en futuros posts…  ; )

¿Qué hay de nuevo en M en esta CTP? Al margen de la integración con Quadrant de la que hablaba previamente (y que bastantes horas de trabajo ha supuesto…) podemos destacar las siguientes novedades:

  • Las entidades y colecciones ahora soportan evaluaciones de igualdad.
  • Nuevos operadores lógicos añadidos al lenguaje.
  • Concatenación de strings con el operador “+”.
  • Acceso a miembros en expresiones.
  • Proyecciones.
  • Soporte para el operador .Count
  • Conversiones de tipos.
  • Expresiones en la parte derecha de nuestras gramáticas (para los puristas del mundo de las gramáticas, expresiones en RHS).
  • Capacidad para referenciar instancias etiquetadas de entidades en expresiones, y también en sucesivos episodios de compilación (entre módulos importados/exportados, imágenes, etc.)

Resumiendo: Ha sido necesario reponer varias veces al día las máquinas de café en zonas cercanas a nuestros pasillos…!!

Al margen de estas novedades, hay una serie de “breaking changes” en algunas sentencias del lenguaje, azúcar sintáctico fundamentalmente, en lo referido a la creación de colecciones ( T* ahora es {T*}, T#n ahora es {T#n}, etc.). Podéis encontrar más información al respecto en las Release Notes.

Más allá de los cambios en el lenguaje, ha habido cambios interesantes en las herramientas que rodean a M, como por ejemplo en Intellipad: capacidad para comentar bloques completos de código, coloreado de sintaxis, y la capacidad de realizar ingeniería inversa sobre cualquier base de datos en SQL Server y obtener el correspondiente código en M, tal cual comentaba previamente.

Por último, hay novedades importantes en los tipos de proyectos en M dentro de Visual Studio 2010 Beta 2, pero eso os dejo que lo descubráis vosotros mismos…  ;-)

MSDN: It’s All About Data

Este es el lema de las camisetas que hemos creado con motivo del PDC 2009 en nuestro equipo, y en cierto modo, es el perfecto resumen para hablar de los cambios en nuestra web de MSDN también. Como consecuencia de los cambios organizacionales, fusiones con otros equipos, asociaciones, etc. nuestro MSDN Oslo Developer Center ha pasado a ser más amplio y a cambiar de ubicación. Ahora, nos referiremos a él como Data Developer Center, y engloba tecnologías como ADO.Net EF, Astoria, XML, LINQ2SQL y, por supuesto, SQL Server Modeling!

Para terminar el post, no me queda más que recordaros la existencia de nuestro SQL Server Modeling Forum y sitio web de connect SQL Server Modeling Connect (previamente, M Spec Community).

 

HAPPY MODELING!!

M.

Ya disponible Microsoft SDK for Facebook Platform… por fin!!

Ya está disponible para descarga gratuita la SDK de Microsoft para desarrollo de aplicaciones en Facebook. Esta SDK proporciona un conjunto de librerías cuyas funcionalidades son capaces de competir con las de las SDKs ya existentes para Facebook desarrolladas en PHP y JavaScript.

Entre las posibilidades que se abren, se encuentra la capacidad para incorporar aplicaciones web desarrolladas en ASP.Net o Silverlight a Facebook, haciendo uso de las características sociales de Facebook (listas de amigos, informacion de nuestro perfil, etc.). Tambien es posible emplear estas librerías en nuestras aplicaciones de escritorio WPF y WinForms, para dotarlas de servicios de Facebook….

Más información, ejemplos, tutoriales, descargas… aquí:

http://www.infoworld.com/d/developer-world/microsoft-brings-silverlight-facebook-592

Saludos,

M.

Channel 9 Expert-to-Expert: Don Box y Erik Meijer reflexionan sobre la historia de SOAP, la programación/modelado de datos, cómo no, el lenguaje M.

Desde sus inicios, he sido un gran seguidor de la serie Expert-To-Expert de Channel 9, en la que el gran Erik Meijer realiza entrevistas profundamente técnicas sobre alguna tecnología concreta a sus respectivos creadores. Entre los capítulos de la serie que recuerdo con mayor cariño/admiración, debo destacar el capítulo sobre el futuro del lenguaje C# con Anders Hejlsberg, el de perspectivas sobre Paralelismo y Programación Concurrente con Joe Duffy, la importancia de los DSLs con “los grandes” Martin Fowler y Chris Sells, y los fundamentos del lenguaje Small Basic con su creador el amigo Vijaye Raji.

En esta ocasión, le ha tocado el turno a Don Box, quien se sienta un rato en nuestra antigua sala de Scrum (snif snif) a dialogar con Erik Meijer acerca de la historia de SOAP, las principales decisiones que motivaron su diseño allá por finales de los 90, y posteriormente hablan sobre los conceptos que hoy en día ocupan a Don: las tecnologías de programación/modelado de datos, y concretamente, el lenguaje M.

Enlace alternativo por si no se ve el video

¡Disfrutadla!

Posted: 31/10/2009 10:40 por Miguel LLopis | con no comments |
Archivado en: ,
System.Collections.Concurrent: Estructuras de datos para computación paralela en .Net 4.0

Una de las principales novedades introducidas en .net 4.0 y Visual Studio 2010 es la inclusión de mecanismos para la resolución de problemas de computación paralela. Este soporte se ha incorporado de muy diversas formas a nuestro querido framework, mediante la adición de nuevas instrucciones con capacidades de multiprocesamiento tales como los bucles paralelos (Parallel.Foreach, etc), operadores de consultas LINQ paralelos (PLINQ), invocaciones paralelas (Parallel_Invoke), encadenamiento de operaciones (Continuations), entre otras…

Tradicionalmente, los problemas fundamentales de la Programación Concurrente han sido la implementación de mecanismos efectivos para la comunicación y sincronización. Por una parte, perseguimos el objetivo de la compartición de información entre procesos (por ejemplo, el uso de los resultados de un proceso como valores de entrada para el otro), y por otra parte, buscamos que dicha comunicación a nivel de datos sea sincronizada (de modo que un proceso “espere” datos tan sólo en el momento adecuado, cuando estos estén disponibles, ya que de lo contrario se producirían situaciones como la espera ocupada (implementada habitualmente del modo: while(true) { TryToRead(buffer); }, que degradarían el rendimiento de nuestro programa).

Estas situaciones se han tratado de resolver mediante el uso de memoria compartida entre los distintos agentes/procesos/hilos de nuestra aplicación concurrente (escoged alguna de esas tres palabras dependiendo del nivel de granularidad de nuestro paralelismo, o del patrón de concurrencia que vayamos a emplear). Para controlar el acceso a esta memoria compartida, se han implementado mecanismos cuya función principal consiste en aislar en nuestro código aquellas instrucciones que acceden a esta memoria compartida, bien sea para modificarla o simplemente consultar su contenido (a estos conjuntos de instrucciones en nuestro código se les suele conocer también con el nombre de secciones críticas). Dentro de estos mecanismos de control para el acceso a la sección crítica, podemos encontrar diversas aproximaciones, como los semáforos, monitores o procedimientos para el paso de mensajes (que a su vez pueden ser de tipo bloqueante o no bloqueante).

El uso de estos mecanismos básicos ha sido a menudo una dificultad añadida a la tarea del programador, que ha sumado una complejidad excesiva al proceso de abstracción del problema concurrente y su implementación posterior.

Un enfoque alternativo a este problema consiste en el uso de abstracciones que nos proporcionen una implementación de estos mecanismos de control de acceso a las zonas de memoria compartida de forma totalmente transparente al desarrollador. De este modo, resultará más sencillo centrarse en la resolución del problema concreto que le ocupa, y abstraer los mecanismos de control de operaciones básicas de memoria sobre las cuales deberá apoyarse para alcanzar su solución pero que, por otra parte, resultan comunes a cualquier problema de tipo concurrente.

Es sobre este último grupo, estructuras de datos para computación paralela, sobre el que me gustaría hablaros en este post: las nuevas estructuras de datos con soporte para concurrencia introducidas en el .Net framework 4.0, concretamente en el namespace: System.Collections.Concurrent

Dentro de este espacio de nombres, podremos encontrar las siguientes estructuras de datos:

  • BlockingCollection<T>: Se trata de una estructura que nos proporciona acceso a una colección de elementos. El acceso a esta colección se puede bloquear/desbloquear y también es posible acotar su capacidad.
  • ConcurrentBag<T>: Colección no ordenada de objetos.
  • ConcurrentDictionary<TKey, Value>: Colección de tuplas key-value a la que se puede acceder concurrentemente.
  • OrderablePartitioner(TSource): Permite configurar la forma en que prentendemos dividir los datos procedentes de un determinado origen en un conjunto de particiones. Idealmente, es la colección inicial a emplear ante problemas del tipo “divide y vencerás”
  • Partitioner(TSource): Similar al anterior, pero en esta ocasión dispondremos de una serie de métodos de particionado predefinidos, que podremos aplicar sobre arrays, listas y otros objetos enumerables.

Seguidamente, mostraremos un ejemplo del uso de estas estructuras de datos en un problema clásico de la Programación Concurrente: el problema del productor-consumidor.

Solución al problema del Productor-Consumidor empleando BlockingCollection<T>

Resumiendo a grandes rasgos este problema, trataremos de resolver una situación en la que dos tipos de procesos diferentes se comunican a través de un buffer de forma concurrente. Mientras uno de los dos procesos (el productor) escribe bloques de información en dicho buffer a medida que dispone de ellos, el otro (consumidor) se encarga de leerlos.

Existen diferentes variantes del problema: cambiando el número de productores o de consumidores presentes, modificando las características del buffer de forma que éste pueda tener un tamaño limitado o infinito, o también alterando la persistencia de los contenidos del buffer (por ejemplo, si un bloque de datos es borrado del buffer tras haber sido leído por un consumidor).

Vamos a ver cómo implementar algunos de estos patrones concurrentes mediante el uso de BlockingCollection<T>, proporcionada por el espacio de nombres de .Net 4.0: System.Collections.Concurrent, tal cual comentábamos antes.

1) Productor-Consumidor (1:1) con buffer ilimitado e información no persistente:

En este caso, crearemos dos nuevas tareas Producer y Consumer, haciendo uso del objeto Task (Task.Factory.StartNew). El Producer generará valores aleatorios que escribirá en el buffer mediante el uso del método Add() del mismo. Será necesario realizar una llamada al método CompleteAdding() para indicar que la actual operación de escritura sobre el buffer se ha completado.

Por su parte, el consumidor leerá los elementos presentes en el buffer iterando sobre el mismo. El método GetConsumingEnumerable() nos permite obtener nuestra BlockingCollection<int> como IEnumerable<int>. Por último, el consumidor se quedará a la espera de nuevos valores añadidos al buffer por parte del productor (consumer.Wait()).

 

using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;
using System.Threading;
 
namespace ProducerConsumer
{
    class Program
    {
        static void Main(string[] args)
        {
            BlockingCollection<int> buffer = new BlockingCollection<int>();
 
            var producer = Task.Factory.StartNew(() =>
                {
                    Random rand = new Random();
                    for (int i = 0; i < 3; i++)
                    {
                        Thread.Sleep(1000);
                        int item = rand.Next();
                        buffer.Add(item);
                        Console.WriteLine("Productor escribe {0} , item);
                                            en el buffer"
                    }
                    buffer.CompleteAdding();                    
                });
 
            var consumer = Task.Factory.StartNew(() =>
            {
                foreach (var item in buffer.GetConsumingEnumerable())
                {
                    Console.WriteLine("Consumidor lee {0} , item);
                                            del buffer"
                }
            });
 
            consumer.Wait();
            Console.ReadLine();
        }
    }
}

El resultado podemos verlo a continuación, el productor genera tres valores aleatorios y los escribe en el buffer, mientras que el lector leerá cada uno de ellos del buffer y los muestra.

image

2) Productor-Consumidor (1:1) con buffer ilimitado e información persistente:

En este segundo escenario, las restricciones del problema serán las mismas que en el caso anterior, con la única diferencia de que la información escrita en el buffer no será eliminada después de que el consumidor la haya utilizado.

Para ello, tan sólo deberemos cambiar una línea en el código mostrado anteriormente, en lugar de acceder en el consumidor al buffer mediante el metódo buffer.GetConsumingEnumerable() accederemos de la siguiente forma: foreach(var item in buffer)

3) Productores – Consumidores (N:N) con buffer ilimitado e información no persistente.

En este caso, la única diferencia con respecto a los escenarios anteriores es que deberemos “envolver” la creación del productor y del consumidor en sendos bucles, para generar el número deseado de productores y de consumidores.

4) Productores-Consumidores (N:N) con buffer limitado e información no persistente.

 

La última variante que veremos hoy sobre el problema del Productor-Consumidor es la relacionada con la limitación del tamaño de nuestro buffer. En este caso, limitaremos el número de elementos de nuestra BlockingCollection<int>.

Para ello, únicamente deberemos emplear una de las sobrecargas del constructor de esta clase, indicando el número de elementos tope de la colección:

BlockingCollection<int> buffer = new BlockingCollection<int>(3);
 
De este modo, hemos limitado a 3 el número de elementos que nuestra colección puede contener. Por tanto, si el productor desea escribir en este buffer y el número de elementos ha alcanzado el máximo, el propio productor se bloqueará, dejando paso al consumidor para que consuma un valor, y posteriormente retomando el control sobre el buffer para escribir el valor que tenía preparado.
 
La elección de un tamaño apropiado para nuestro buffer, así como el uso de una cadencia de lectura/escritura (número de items afectados por cada operación de acceso al buffer) serán dos decisiones importantes a tomar en este caso. Teniendo en cuenta que, generalmente, las situaciones de bloqueo tienen un efecto positivo y otro negativo. En el lado positivo de la balanza, un bloqueo supone una resolución a un conflicto coherente con la lógica de nuestra solución, pero por otra parte, supone cierta degradación en el rendimiento de nuestra aplicación concurrente.
 
Happy Coding!
Calentando motores para el PDC 09

Queda menos de un mes y medio para la próxima edición del PDC, a celebrarse en Los Angeles (California) entre el 17 y el 19 de Noviembre, y a pesar de que son muchas las novedades que veremos allí, me gustaría anunciaros las sesiones relativas a Oslo nuestra plataforma de modelado: lenguaje M, Quadrant y Repositorio.

Por el momento, tenemos confirmadas las siguientes sesiones (a falta de alguna más, todavía en proceso)…

  1. Data Programming and Modeling for the Microsoft .Net Developer: En esta charla eminentemente práctica, los amigos Don Box y Chris Anderson mostrarán las mejoras introducidas en forma de herramientas, lenguajes y frameworks para simplificar la forma de modelar, consumir o producir datos. Imprescindible asistir a esta charla si quieres estar informado acerca del futuro en el ámbito del modelado y programación sobre datos utilizando productos y servicios de Microsoft.
  2. Microsoft project code name “M”, the Data and Modeling Language: Esta sesión servirá para repasar los conceptos fundamentales del lenguaje de modelado M, cómo crear DSLs y esquemas de datos, y también explorará el futuro del lenguaje M, en el cual ambos conceptos convergerán en un único lenguaje, así como otro conjunto bastante interesante de características. La sesión será presentada por Don Box y Jeff Pinkston (a.k.a. Pinky)
  3. Building Data-Driven applications using Microsoft code name Quadrant and code name M: “El gran” Chris Sells nos contará, junto al no menos grande Doug Purdy, cómo podemos emplear el diseñador Quadrant y el propio lenguaje M para interactuar con SQL Server con el fin de crear aplicaciones dirigidas por datos, involucrando funcionalidades como el uso de vistas dinámicas y capacidades de edición en aplicaciones multi-usuario. Además podremos aprender cómo el uso combinado de ambas herramientas permite acelerar y simplificar el ciclo de desarrollo de las capas de datos en nuestras aplicaciones SOA desarrolladas en plataforma .net. Por último, veremos cómo personalizar Quadrant y M para proporcionar experiencias de desarrollo/usuario que sean domain-specific.
  4. Microsoft project code name “Repository”, using metadata to drive application design, development and management: El repositorio es probablemente la tecnología perteneciente a Oslo de la que menos se ha hablado en los últimos meses y, sin embargo, se trata tal vez de la que tendrá potencialmente un mayor impacto en la arquitectura de nuestras aplicaciones. Mediante el uso de un repositorio central de gestión de metadatos (modelos, configuraciones, etc.), podremos incrementar el control sobre nuestras operaciones de desarrollo, despliegue, mantenimiento y gestión de aplicaciones empresariales. Algunas de las funciones que el uso de este repositorio nos proporciona son: capacidad para realizar análisis de impacto, validación de la arquitectura de nuestro sistema, gestionar el despliegue y configuración de nuestras aplicaciones empleando UML, CLR, Identity, etc. Esta sesión correrá a cargo de Shoshanna Budzianowsky y Keith Short.

Podéis encontrar la información completa sobre estas y otras sesiones en la web oficial del evento: http://www.microsoftpdc.com

Por último, adelantaros que en próximos posts (pre y post PDC) os hablaré largo y tendido de todos estos conceptos, incluyendo presentaciones, demos, vídeos y algunas cosas más ;)

Have fun!

Update: ¿Qué hay de nuevo por Oslo?

Hace ya más de un mes desde mi último post, concretamente cinco semanas… Para cumplir con mi promesa de “al menos un post al mes” (espero que este mes pueda escribir al menos dos más que guardo en la recámara desde hace varias semanas pero para los que no he encontrado el momento oportuno todavía), vuelvo a la carga para actualizar con las últimas novedades en torno a Oslo. `

[Aviso de antemano: Es un post bastante largo y denso, aún así te agradeceré que lo leas y aportes el feedback que te parezca oportuno, será bien recibido.]

Hablando desde la “línea de combate” del proyecto, hace unos días que terminamos una etapa de desarrollo bastante sustancial en nuestro calendario. Esto incluye nuevas características tanto en el lenguaje M como en Quadrant y nuestro repositorio relacional de modelos, de las cuales os hablaré próximamente. En este momento, dedicamos nuestros esfuerzos a estabilizar todas estas nuevas funcionalidades que apenas acaban de aterrizar en el proyecto, cerrar algunos “asuntillos” pendientes y, básicamente, realizar una parada en boxes para repostar y prepararnos para volver a acelerar en el desarrollo, con una meta parcial en la mente de todos nosotros: PDC 2009.

En otro orden de cosas y hablando desde una perspectiva puramente organizativa del proyecto, la novedad principal es la asociación del equipo de Oslo con el equipo de Data Programmability (responsables de algunas tecnologías de acceso programático a datos como son ADO.Net, Astoria, EDM y Entity Framework).

Este movimiento nos aporta una serie de ventajas que repercuten en una mayor especialización y mejor posicionamiento de nuestras tecnologías, que finalmente resultarán en un beneficio global en el ecosistema de desarrollo en .Net framework.

Para comprender mejor el alcance de dichas mejoras, conviene repasar la evolución de Oslo, sus líneas generales y, por supuesto, también la experiencia adquirida a través del feedback recibido desde la comunidad.

Hace ya casi dos años desde el primer anuncio oficial sobre Oslo, realizado en la SOA & BP Conference, en Octubre de 2007 en Redmond. En aquel momento, nos referimos a Oslo como un conjunto de esfuerzos combinados a través de diferentes tecnologías y productos, para simplificar el ciclo de desarrollo de aplicaciones. Dichos esfuerzos se verían reflejados en diferentes tecnologías existentes: Visual Studio, .Net framework, BizTalk y SQL Server.

Acercándonos un poco más en la línea cronológica al momento actual, el siguiente punto de inflexión tuvo lugar hace casi un año, en el PDC 2008. En dicho evento, realizamos una serie de sesiones presentando las diversas tecnologías de modelado que formaban parte de Oslo, así como publicamos nuestra primera CTP. Al aproximarnos a este hito, nos dimos cuenta de algunos aspectos reseñables, principalmente en la forma de canalizar nuestro discurso para que llegara de forma clara y unívoca al público: en primer lugar, el hecho de englobar bajo el codename Oslo diferentes tecnologías como BizTalk, Workflow Foundation, herramientas de modelado (M & Quadrant), etc, generaba cierto grado de confusión en la audiencia. De modo que, para evitar dicho efecto, optamos por canalizar diferentes tecnologías de Oslo en nuevas versiones de productos ya existentes, en lugar de crear una nueva generación de herramientas bajo el nombre de Oslo.

Debido a esto último, algunas de las tecnologías integrantes del proyecto en su origen ya han sido liberadas. Cuando hablamos de algunas partes de .Net framework 4.0, como las nuevas versiones de Workflow Foundation y WCF, BizTalk Server 2009, el servidor de aplicaciones Dublin, MEF o la pila unificada de XAML; debemos tener en cuenta que dichas tecnologías formaron parte del proyecto Oslo en su momento, y por tanto, la motivación con la que fueron desarrolladas, el objetivo común subyacente, se encuentra totalmente alineado con las metas de Oslo.

Realizando un poco de autocrítica sobre este proceso, encontramos aspectos positivos y negativos. En el lado positivo, la habilidad del equipo para liberar partes del proyecto consolidadas (WCF 4.0, WF 4.0, etc) que fueran introduciendo en el ecosistema de desarrollo algunas de las metas transversales de Oslo, mientras que otras partes del proyecto aún en fase temprana han ido evolucionando de forma apropiada (M, Quadrant). En el lado negativo de la balanza, quizá sería reprochable el hecho de haber mantenido el codename Oslo activo durante mucho tiempo, y por ello haber contribuido a la confusión de la que os hablaba un par de párrafos más arriba… En el momento actual, emplearemos el codename Oslo para referirnos única y exclusivamente a la plataforma de modelado: M, Quadrant, repositorio.

La piedra angular de Oslo fue desde sus orígenes la evolución hacia la creciente utilización de contenidos declarativos en plataforma .Net (XAML), que fueran dinámicos y, al mismo tiempo, que pudieran ser empleados para dirigir nuestras aplicaciones y entornos de ejecución (MDD/MDA). Si pensamos en el repositorio de modelos de Oslo, concretamente, siempre hemos hablado de un repositorio relacional de modelos, implementado sobre SQL Server. Dicho repositorio contiene (meta)datos, hablando sobre datos que contienen información sobre nuestras aplicaciones y empleo el término “meta” entre paréntesis puesto que a menudo también induce a confusión el uso de dicho prefijo. Dichos metadatos son fácilmente maleables mediante nuestras tecnologías de modelado: M y Quadrant. (podéis encontrar una explicación profunda sobre esto en este artículo, y en estas dos presentaciones: 1 y 2)

Continuando con este análisis desde una perspectiva evolutiva del proyecto, cabe destacar que, especialmente en este último año, existe un hecho que se ha puesto notablemente de manifiesto para nosotros. Este hecho es la estrecha vinculación entre nuestra plataforma de modelado y la pila de programación de acceso a datos (ADO.Net, EF/EDM, Astoria, etc.).

Tal es así, que consideramos necesaria una alineación consistente entre ambos “mundos”, y es por ello que decidimos realizar esta asociación a nivel organizativo.

Por tanto, y después de una reflexión que espero no os haya aburrido demasiado…

¿Qué significa este cambio para los mortales desarrolladores en plataforma .Net?

Significa que, de ahora en adelante, vais a escuchar hablar sobre el lenguaje M de una forma mucho más ligada a EDM y Entity Framework; de la herramienta de modelado Quadrant asociada a diferentes herramientas de Visual Studio y, por último, podréis apreciar cómo el concepto un tanto abstracto de MDD/MDA (quizá rayando lo esotérico en algunos casos, jeje) evoluciona de la mano de los avances que se produzcan en las versiones futuras de .Net framework.

Y para terminar, hablando del futuro y puesto que ya he citado el PDC 2009 (por ahí comenzó el post y por ahí va a terminar), os anuncio una excelente sesión en la cual hablaremos largo y tendido sobre el estado actual del proyecto (Data Programming and Modeling for the Microsoft .Net Developer), que será impartida por los señores Don Box y Chris Anderson.

Esperamos veros por allí!!

PD.: Para aquellos ávidos de más información al respecto de estas novedades, podéis echar un vistazo a este post de Doug Purdy, “The Man” :), quien además de dominar mejor que yo la lengua de Shakespeare, explica todo ello en una mejor prosa.

Teleriks crea su propia implementación de “LINQ to M”

Uno de los aspectos que más me apasionan de la comunidad de desarrolladores que se han animado a probar Oslo hasta el momento es la cantidad de herramientas y tecnologías que, haciendo uso de Oslo, lo complementan en escenarios concretos o proporcionan funcionalidades adicionales bastante interesantes.

Buena muestra de ello es la implementación de LINQ to M, creada por Teleriks y lanzada la semana pasada, que nos permite realizar consultas sobre datos estructurados en M (MGraph) con un estilo muy similar al de LINQ to XML. Veamoslo con algo más de detalle…

El formato de datos “MGraph”

Como ya hemos comentado en posts previos, el lenguaje M, que en un futuro no muy lejano será un único lenguaje, está hoy por hoy dividido en tres “dialectos”: MSchema, MGrammar y MGraph.

M es un lenguaje cuya principal función es la de definir datos y restricciones sobre dichos datos, todo ello en forma de texto. Existe una conexión “emocional” entre la gran mayoría de desarrolladores y el formato de tipo texto, ya desde tiempos remotos los desarrolladores hemos vivido en entornos de tipo texto (consola, MS-DOS, etc), y además hemos representado nuestras ideas y algoritmos en forma de texto, mediante el uso de lenguajes de programación de propósito general (C, C++, C#, Java, etc.), o lenguajes de etiquetas/marcado para un dominio específico como por ejemplo HTML, XML o XAML. Adicionalmente, podemos pensar en un texto redactado en lengua castellana como otra representación de datos de forma textual, si bien, esta representación en lenguaje natural sigue unas reglas gramaticales algo menos estrictas que los lenguajes de programación y de marcado, así como una estructura textual (párrafos, signos de puntuación, etc) bastante más flexible que en los lenguajes citados con anterioridad.

Considerando todos estos lenguajes, el elemento diferenciador entre cada uno de ellos no es ni más ni menos que el conjunto de reglas que nos permiten expresar una serie de información en dicho lenguaje y también estructurar dichas ideas de forma más o menos “mecánica”. Esta forma mecánica de representación de información textual se lleva al extremo en un lenguaje como XML, el cual sigue una sintaxis muy estricta que lo convierte además en un lenguaje complejo de entender para una persona.

No obstante, todos ellos comparten una característica común, bastante obvia, pero conviene tenerla siempre presente: todos estos lenguajes nos permiten representar información en formato de texto.

Si pensamos en la relación entre texto y datos, el lenguaje M vive en dicha intersección. Por una parte, nos permite representar información en una serie de lenguajes proporcionados “de serie” y, por otra parte, nos permite crear fácilmente nuestras propias reglas gramaticales para transformar un conjunto de información textual poco estructurada (por ejemplo, un texto en castellano) en otro conjunto de información textual organizada de la forma que a nosotros nos resulte más cómoda: traducida a scripts T-SQL como en el caso de MSchema, a una representación en forma de grafo acíclico que conocemos con el nombre de AST y que constituye el “dialecto” MGraph, o a cualquier otra representación que definamos nosotros mismos mediante nuestras gramáticas creadas con MGrammar.

Una vez tengamos la información en un formato optimizado para su procesamiento, disponemos de diversas opciones para consumir dicha información desde nuestros entornos de ejecución y aplicaciones. En esta ocasión, nos vamos a centrar en la implementación de LINQ to M (MGraph) creada por Teleriks.

A continuación podemos ver un fragmento válido de información representada en formato MGraph, en la cual estamos describiendo un conjunto de vuelos e información sobre cada uno de ellos (código de vuelo, operador del vuelo, origen y destino).

{
      {Id=1,Origen=""Alicante"",Destino=""Madrid"",Operador=""Iberia""},
      {Id=2,Origen=""Oslo"",Destino=""Barcelona"",Operador=""SAS""},
      {Id=3,Origen=""Seattle"",Destino=""New York"",Operador=""Delta""},
      {Id=4,Origen=""Paris"",Destino=""Amsterdam"",Operador=""Air France""},
      {Id=5,Origen=""Londres"",Destino=""Vancouver"",Operador=""British Airways""},
      {Id=6,Origen=""Tokyo"",Destino=""Shanghai"",Operador=""Air China""},
      {Id=7,Origen=""Alicante"",Destino=""Madrid"",Operador=""Vueling""},
      {Id=8,Origen=""Alicante"",Destino=""Madrid"",Operador=""Spanair""}
}

Para este ejemplo, en el cual vamos a consumir la información directamente en tiempo de ejecución desde nuestro código C#, lo que vamos a hacer es almacenar este fragmento de código M en un const string.

Además, deberemos agregar en nuestro proyecto una referencia a Telerik.M.Core.dll y añadir una sentencia using Telerik.M.Core; en nuestro código, a fin de poder emplear estas funcionalidades. (esta dll forma parte de la descarga de LINQ to M).

Para consumir nuestro código M en forma de sentencias LINQ, deberemos en primer lugar cargar nuestro origen de datos, mediante el uso del objeto QueryContext, tal cual se muestra a continuación.

image

Con esto simplemente ya podríamos hacer uso de nuestra variable vueloM como origen de datos, por ejemplo para asignarlo a dicha propiedad DataSource en un objeto de tipo Grid, y visualizar nuestros registros de vuelos.

No obstante, si deseamos obtener Intellisense, coloreado de sintaxis, y demás servicios adicionales del lenguaje, deberemos crear una clase en C# que tenga la misma estructura que la información definida en M, para lo cual realizaremos algo parecido al siguiente código.

image

Gracias a esta definición, ya podemos hacer uso de características avanzadas del IDE, como por ejemplo Intellisense. En la siguiente captura podemos observar cómo realizar consultas LINQ sobre nuestra colección de datos en M, obteniendo información contextual en VS. (click sobre la imagen para una vista ampliada).

image

Terminaremos la consulta para visualizar los vuelos Alicante – Madrid ordenados de forma ascendente por nombre de Operador, y mostraremos dicha información en nuestra consola…

image

image

Para más información, podéis acceder al blog de Stephen Forte, CEO de Telerik, quien nos describe otra aplicación similar al ejemplo que os he mostrado aquí, y también nos cuenta sus experiencias con la SDK de Oslo durante los últimos meses.

También puedes descargar la implementación de LINQ to M en este enlace. Y el código completo de mi ejemplo aquí.

Saludos,

M.

Posted: 13/7/2009 8:03 por Miguel LLopis | con no comments |
Archivado en: ,,
Materiales de la presentación sobre Oslo en MS Iberica

Tal cual comentaba hace unos días en una entrada previa, este martes tuve la oportunidad de realizar un workshop sobre Oslo en las oficinas de MS Iberica en Madrid. En la siguiente carpeta de skydrive os dejo los materiales de la misma, presentación y archivos de código M empleados durante la demo.

Gracias a todos aquellos que asistieron a la sesión por el interés mostrado y especialmente a César De la Torre, por su colaboración y organización del evento, así como al resto de compañeros de Madrid por su gran acogida, "as always".

Saludos @Madrid    :)

M.

Posted: 2/7/2009 12:35 por Miguel LLopis | con 2 comment(s)
Archivado en: ,,
Small Basic v0.5: Ahora con localización en Español... y más!!

Hoy se ha liberado una nueva versión del lenguaje Small Basic. Entre las novedades más destacadas está que ahora está localizado para Español, además de Inglés. Además, las siguientes características han sido añadidas al lenguaje, en base al feedback recibido por la comunidad:

  • Mejoras en el IDE: Función "Buscar", indicador de línea y columna, botón para "Guardar como...", etc.
  • Mejoras en el lenguaje: Al margen del nuevo soporte para Español, quizá la más destacada sea el soporte de arrays... multidimensionales! :)

Para aquellos que no hayan escuchado hablar de Small Basic todavía, comentar que se trata de un lenguaje bastante simple (apenas 15 keywords), cuyas ideas base derivan de Visual Basic, pero su propósito es eminentemente pedagógico. Podéis encontrar un excelente vídeo en Channel 9, de la serie Expert-to-Expert en la que su creador, Vijaye Raji y Chris Anderson (compañeros en el equipo de Oslo), nos explican en detalle las características del lenguaje junto al gran Erik Meijer.

También dispone de una página en MSDN y  un grupo en Facebook a través del cual se anuncian las novedades en torno a este proyecto.

Keep up the great work, Vijaye!

M.

Posted: 18/6/2009 10:06 por Miguel LLopis | con 2 comment(s) |
Archivado en:
[Workshop en Madrid] Introducción a “Oslo”: El Futuro en el Modelado de Aplicaciones

El verano siempre es una buena época para visitar Alicante durante unos días. Como Madrid está de paso, aprovecharemos para hablar un rato sobre Oslo. Aquí están los detalles del evento:

En este Workshop revisaremos los conceptos de MDD (Model Driven Development) y derivados (Model Driven SOA, etc.) y presentaremos la propuesta de futuro de Microsoft: "Oslo" (codename, actualmente en estado Beta), recorriendo las diferentes tecnologías que nos ofrecerá (lenguaje de modelado textual M, herramienta visual Quadrant y repositorio relacional de modelos). Al terminar la sesión, los asistentes serán capaces de responder a las siguientes dos preguntas: ¿Qué es Oslo? Y… ¿Por qué debería prestarle atención de ahora en adelante?.

FECHA: 30 de Junio

LUGAR: Oficinas Microsoft Madrid – Sala Marie Curie.


AGENDA
9:00 - 9:30 - Registro
9:30-10:45 - Model Driven Application, MDD y la propuesta de futuro de Microsoft: "Oslo". (César De La Torre, Architect Evangelist, MS Iberica)
10:45-11:15 - Cafe
11:15-14:00 - "Oslo" en detalle, Lenguaje M, Quadrant, Repositorio. (Miguel Llopis, SDET Team Oslo, MS Corp)

Link de registro: http://msevents.microsoft.com/CUI/EventDetail.aspx?culture=en-US&EventID=1032417769&%3bCulture=es-ES

Esperamos veros por allí,   :)

M.

Posted: 12/6/2009 3:16 por Miguel LLopis | con 1 comment(s) |
Archivado en: ,,
Más artículos Página siguiente >