domingo 23 de noviembre de 2008

PDC 2008: The Future of C#4.0 (1/3)

Pointed by Ricky Tags: ,

Hace aproximadamente un mes se celebró la Professional Developers Conference 2008, conferencias dedicadas principalmente a desarrolladores Windows. En esta edición se han presentado múltiples novedades, como el SDK de Microsoft Surface (la pena es que me parece que para conseguirlo hay que comprarse también el aparatito, que no es precisamente barato), han presentado novedades sobre Windows 7, y muchas otra cosas más. Podéis hacer una búsqueda para intentar encontrar una conferencia que contenga un tema que os interese. Las vídeos de las conferencias pueden verse por streaming -siempre que tengas instalado Silverlight- pero también están disponibles para descarga en múltiples formatos; y lo mismo se aplica a las presentaciones utilizadas.

Después del párrafo patrocinado por Microsoft :) vamos a realizar una pequeña serie de posts comentando la presentación que da título a esta entrada y que hasta hoy mismo no he podido mirar: The future of C#, presentada por Anders Hejlsberg, arquitecto jefe del desarrollo del lenguaje C#.

Anders comienza reseñando que las nuevas "tendencias" en programación apuntan a lenguajes de programación declarativos, dinámicos y con soporte para concurrencia, indicando que C# se mueve hacia dichas tendencias:

  • Programación declarativa: LINQ nos permite especificar los datos que queremos y cómo los queremos, pero la forma última de acceder a ellos y tratarlos no es de nuestra competencia. La ventaja que esto puede tener es que el compilador JIT podría realizar optimizaciones según el tipo de dato al que accedemos.
  • Lenguajes dinámicos: aunque defensor de los lenguajes y del tipado estático, reconoce muchas virtudes de utilizar un lenguaje dinámico en muchas situaciones. Además, una de las ventajas que tienen los lenguajes dinámicos es la capacidad de metaprogramación. Estos dos aspectos se intentarán mejorar en el lenguaje mediante la palabra clave dynamic y la presentación del compilador de C# como servicio (en próximas entradas :) .
  • Concurrencia: Aquí ya no hay otro truco que el diseñar la aplicación como un grupo de trabajos independientes y paralelizables. Sin embargo hay ya una extensión al lenguaje llamada .NET Parallel Extensions de la que ya hay disponible una CPT para su descarga.



Pasemos entonces a comentar el primero los añadidos más interesantes de C# presentados:

Programación dinámica: palabra clave dynamic

La ejecución de código dinámico no es algo nuevo en .NET, ya hay un esfuerzo para definir un entorno de ejecución dinámico común en todo .NET: el DLR, que estandariza el sistema de tipos, de enlace dinámico y de generación dinámica de código, de forma que sea accesible para cualquier lenguaje y además permita que las diferentes implementaciones interactúen entre sí de forma más cómoda. Por ejemplo, tanto IronRuby como IronPython, utilizan el DLR. Vamos, que es algo así como el CLR pero en dinámico.

DLR

El propósito de la palabra clave dynamic es "comunicarse con cosas que no son una clase .net con tipado estático". Esto se realiza por medio de binders a dichos lenguajes, y  como se ve en la figura, entre esas cosas se incluyen propio código .NET enlazado dinámicamente, java script, Python, Ruby, o bien objetos COM. De hecho esta palabra clave está llamada a dejar obsoleta mi librería LateBindingHelper. Por ejemplo Fusilando este código de la presentación, supongamos un objeto Calculator que permite realizar operaciones aritméticas: 

Calculator calc = GetCalculator();
int sum = calc.Add(10, 20);
Si queremos utilizarlo usando LateBinding: 
object calc = GetCalculator();
Type calcType = calc.GetType();
object res = calcType.InvokeMember("Add",BindingFlags.InvokeMethod, null,new object[] { 10, 20 });
int sum = Convert.ToInt32(res);
Aprovechando para hacer publicidad ^_^ con librería LateBindingHelper se simplificaría a 
IOperationInvoker calc = BindingFactory.CreateObjectBinding(GetCalculator());
int sum = calc.Method("Add").AddParameter(10).AddParameter(20).Invoke<int>();
Sin embargo utilizando la palabra clave dynamic, todo quedaría: 
dynamic calc = GetCalculator();
int sum = calc.Add(10, 20);
Sin embargo, si cogemos este pequeño código vemos que se están realizando muchas cosas. En la primera línea, la palabra dynamic define una variable con un tipado fuerte. Es decir, una variable declarada con dinamic es de tipo dinámico, que viene a ser una especie de object al poder asignarle cualquier valor. Sin embargo no podemos hacer castings implícitos: 
dynamic x = 1;
int i = x; //NO!

En la segunda estamos invocando el método Add de forma dinámica, esto es: el enlace al método se realiza en tiempo de ejecución, y esto ocurre para cualquier operación en la que esté involucrada una variable dynamic. Además, el resultado de la operación se convierte también de forma dinámica al tipo que asignamos, int en este caso.

Es indudable que la nueva keyword dynamic muy útil en muchos casos. Aunque en algunos sitios ya ponen el grito en el cielo diciendo que podría sobreutilizarse y derivar en diseños pobres. Yo digo que 'como todo'. Prácticamente cualquier cosa de un lenguaje la puedes utilizar de una manera incorrecta manera y acabar creando un diseño pobre.

Suscribirse a: Enviar comentarios (Atom)