Noticias desde la normalización de lenguajes de programación

Hoy ha terminado la asamblea plenaria anual del subcomité ISO/IEC JTC1/SC22. Los se. En el mundo de la normalización se utilizan acrónimos insoportables. Probablemente resultará más inteligible si lo reformulo: Hoy a terminado la asamblea plenaria anual de subcomité de normalización de lenguajes de programación, sus entornos e interfaces de sistema.

Hay una larga lista de resoluciones tomadas por el subcomité. Algunas son meramente burocráticas y me las saltaré. Vayamos a la que pueden tener cierrto interés.

• Se va a iniciar el estudio de una posible propuesta para normalizar la firma digital de código fuente.
• Se ha disuelto el grupo de trabajo WG11 (binding techniques). Este grupo ha sido responsable de trabajos en especificación de aritmética independiente del lenguaje. No obstante, el interés directo de la industria en las actividades del grupo parece bajo y no se consigue tener una masa crítica en el grupo de trabajo. Este grupo de trabajo no desaparecerá realmente, sino que sus actividades se transfieren a otro subcomité (gestión e intercambio de datos / metadatos).
• Se ha disuelto el grupo de trabajo WG16 (lenguaje Lisp). Este grupo ha dejado de tener actividad y no parece que haya sufiente interés industrial en el lenguaje.
• Se ha aprobado la posibilidad de que la especificación del lenguaje ECMAScript (norma ISO/IEC 16262:2011) se pueda obtener gratuitamente a través de ISO. Esta norma ya se puede obtener de forma gratuita a través de ECMA.
• Se ha confirmado la confirmación de las siguientes normas:
• ISO/IEC/IEEE 9945:2009 Portable Operating Systems Interface (POSIX) Issue 7.
• ISO/IEC/IEEE 11404:2007 General Purpose Datatypes.
• ISO/IEC TR 19768:2007 Technical Report on C++ Library Extensions.
• ISO/IEC 24716:2007 Native COBOL Syntax for XML support.
• ISO/IEC 24731:2007 Extensions to the C Library - Part 1: Bounds checking interfaces.
• Se ha decidido pasar a estado estabilizado (lo que hace hace que las normas dejen de estar activas) las siguientes normas:
• ISO/IEC 13568:2002 Z formal specification notation - Syntax, type system and semantics.
• ISO/IEC 15145:1997 Programming Languages - FORTH.
• ISO/IEC 20970:2002 JEFF File Format.

Además, se ha revisado el estado en el que se encuentra la normalización del lenguaje Ruby que ya es una norma nacional en Japón y que previsiblemente se convertirá pronto en una norma internacional.

Tras esto, merece la pena fijarse en cual es el panorama en la normalización de lenguajes de programación en los distintos foros internacionales.

La estructura de grupos de trabajo de normalización dentro del ISO/IEC JTC1/SC22 queda de la siguiente forma:

• WG4: COBOL.
• WG5: Fortran.
• WG9: Ada.
• WG14: C.
• WG17: Prolog.
• WG19: Lenguajes de especificación formal.
• WG23: Vulnerabilidades de los lenguajes de programación.

Otra organización internacional que trabaja en la normalización de lenguajes de programación es ECMA que mantiene los siguientes grupos de trabajo:

• TC49-TG2: C#.
• TC49-TG3: CLI.
• TC49-TG4: Eiffel.
• TC49-TG5: C++ para CLI.
• TC39: ECMAScript.

Por último, en Japón, IPA mantiene la normalización del estándar sobre el lenguaje Ruby.

Tanto Ruby, como las normas desarrolladas por ECMA pueden pasar por un proceso especial para convertirse en normas ISO. De hecho esto constituye una práctica habitual de la que Ruby y ECMAScript son dos ejemplos actuales.

Y ¿adonde nos lleva esto? Pues a una lista bastante pequeña de lenguajes. Es lo que yo llamaría los lenguajes portables de interés. ¿Qué quiero decir con esto?

Veamos para estar en mi lista un lenguaje de programación debe tener una especificación mediante una norma internacional, porque esto garantiza que:

1. Existe un interés por parte de varios actores de la industria del software en que exista una norma internacional sobre el lenguaje.
2. Existe una norma internacional que especifica claramente el lenguaje y su entorno de forma que distintos fabricantes compitan ofreciendo productos que cumplen con la norma.
3. El software desarrollado usando un lenguaje normalizado puede portarse con cierta facilidad de una plataforma a otra.

Como veréis mi lista no es muy larga. Por orden alfabético: Ada, C, C++, C#, COBOL, ECMAScript, Eiffel, Fortran, Prolog. A esta lista podremos añadir en breve Ruby.

De todas formas, debemos tener cuidado con las interpretaciones de mi lista. Esto no quiere decir que estos lenguajes sean los mejores, ni los más usados, ni nada por el estilo. No trato de generar una versión n+1 de la gran batalla de los lenguajes de programación.

Si un lenguaje está fuera de mi lista es porque:

a) No hay suficiente interés en la industria en el uso del lenguaje o en la existencia de una norma independiente.

b) El lenguaje está sujeto a algún tipo de propiedad intelectual que impide la competición entre distintos fabricantes o la existencia del mismo en determinado tipo de plataformas.

Sin embargo no me gustaría que este post empiece a generar comentarios masivos de fanáticos de ningún lenguaje.

decltype: ¿De qué tipo es esa expresión?

En mi anterior post sobre C++11 vimos que el uso de auto permite deducir el tipo de una variable, siempre que ésta se vaya a iniciar en el momento en que se define. Esto cubre un cierto número de casos, pero no todos.

hora obten_hora_actual() ;
coordenada obten_posicion_actual() ;

std::map<hora , coordenada> m;
m[obten_hora_actual()] = obten_posicion_actual();
//...

Bien. Parece que no habrá problemas. Bueno, realmente no habrá problemas mientras no se modifique el tipo de retorno de las funciones obten_hora_actual() y obten_fecha_actual. Lo que realmente me gustaría expresar es que m es un mapa que usa como tipo para la clave el tipo de retorno de la primera función y como tipo para el valor el tipo de retorno de la segunda función.

Aquí aparece en nuestra ayuda el operador decltype. Este operador, permite obtener el tipo de una expresión y se puede usar en cualquier contexto en el que se pueda usar un tipo.

hora obten_hora_actual();
coordenada obten_posicion_actual();

std::map<decltype(obten_hora_actual()),
 decltype(obten_posicion_actual())> m;
m[obten_hora_actual()] = obten_posicion_actual();
//...

Originalmente, algunos fabricantes habían implementado una extensión con un operador parecido: typeof. Sin embargo, la semántica de este operador era distinta, y el comité de ISO C++ decidió optar por una palabra reservada distinta. La elección de decltype puede parecerte poco afortunada, pero era la opción que menos afectaba al código ya existente.

Reglas para la evaluación de decltype

La expresión decltype(expr) se puede utilizar en cualquier tipo donde se pueda usar un especificador de tipo. De esta manera, se puede escribir el siguiente código:

int x;
long y;
decltype(x+y) z; // z es long

En este caso la expresión decltype(x+z) equivale al tipo long, puesto que el resultado de sumar un int y un long es un long.

En el caso de que la expresión pasada a decltype sea una variable, la regla es ligeramente distinta y el resultado es el tipo con el que se declaró la variable:

int x;

int & rx = x;

decltype(x) y = x; // int y

decltype(rx) ry = x; // int & y

Esta regla, hace que en este caso la deducción de tipos no funcione exactamente igual con auto que con decltype:

int x;

int & rx = x;

auto y1 = rx; // int y1. y1 es una copia de x

decltype(rx) y2 = rx; // int & y2 = rx. y2 es una referencia a x

Esto también es aplicable a los parámetros de una función:

template <typename T> class X { /*...*/};
void f(int x1, int & x2, const int & x3) {
  X<decltype(x1)> z1; // X<int> z1;
  X<decltype(x2)> z2; // X<int&> z2;
  X<decltype font="" int&>="" x>
  /*...*/
}

También se puede utilizar decltype sobre una invocación a una llamada a función. Es importante tener en cuenta que una invocación a función dentro de decltype no realiza una llamada a la función. Su único objetivo es determinar el tipo de retorno de la función.

string obten_valor(const string & clave, int indice);

void imprime() {

  list<decltype(obten_valor("usuario",0))> l;
  for (int i=0;i

    l.push_back(obten_valor("usuario",i));

  }

}

Una diferencia bastante relevante ocurre en el caso de que decltype se aplique a una variable que se encuentre entre paréntesis. En este caso el tipo determinado por decltype es siempre una referencia.

int x;

decltype((x)) y = x; // int & y = x

De forma general, esto ocurre con cualquier expresión que no sea exactamente un nombre de variable y que pueda actuar como un l-valor.

template <class C>
void f(C & c) {
  decltype(c[0]) t; // Error t es referencia sin iniciador
  // ...
}
//...
vector<string> v = { "uno", "dos", "res" };
f(v);

En este caso, el tipo de t se obtiene evaluando la expresión decltype(v.operator[](int)) que es un l-valor (en este caso una referencia a string). Por tanto el tipo de t acaba siendo string& y la primera línea de la función f() genera un error de compilación porque se estaría declarando una variable de tipo referencia sin darle un valor inicial.

Ahora bien, la mayoría de los ejemplos empleados hasta ahora (aunque no todos) pueden parecer artificiosos y poco útiles. Probablemente, sea cierto. Sin embargo, hay contextos en los que declttype manifiesta su verdadera utilidad como la deducción automática del tipo de retorno de una función o la especificación de excepciones mediante la nueva palabra reservada noexcept.

Una nueva vida para auto en C++11

Introducción

En C++11, la palabra reservada auto ha resucitado con un nuevo significado. C++ heredó esta palabra reservada de C, donde originalmente implicaba almacenamiento automático, como contraposición al almacenamiento estático. Sin embargo, al convertirse el almacenamiento automático en el almacenamiento por defecto de las variables, se hizo innecesaria su utilización.

Cuando un lenguaje evoluciona (como es el caso de C++11) se debe poner especial atención en que las modificaciones al lenguaje no afecten al código ya existente. Esto hace que los diseñadores del lenguaje sean muy reticentes a la introducción de nuevas palabras reservadas. Por esta razón, el comité de normalización tomó la decisión de resucitar auto dotándola de nuevas semánticas.

En C++11 se puede dar dos usos a auto:

• Para indicar la deducción automática de tipos en la declaración de una variable.
• Para indicar la deducción automática de tipo de retorno en la declaración de una función.

Cada uno de estos usos presenta ventajas en la escritura de código. Hoy presentaré algunos ejemplos del primer caso y dejaré para un próximo post el caso de las funciones con deducción automática de tipo de retorno.

Deducción automática del tipo de variables

Cualquiera que haya escrito código usando la biblioteca estándar de C++ habrá visto alguna vez cosas como la siguiente:

vector<int> v = {1, 2, 3};
for (vector<int>::iterator i=v.begin(), e=v.end();i!=e;++i) {
    cout << *i << endl;
}

Claro que esto puede empeorar:

vector<list<string> > v = { { "Carlos", "Maria"}, {"Niño", "Niña"} };
for (vector<list<string> >::iterator i=v.begin(),e=v.end();i!=e;++i) {
for (list<string>::iterator j=i->begin(), e=i->end(); j!=e; ++j) {
cout << *j << " ";
}
cout << endl;
}

Para complicar las cosas un poco más, todos los contenedores ofrecen variantes de iteradores (como const_iterator) que ocasionan algunos pequeños dolores de cabeza al escribir código.

Sin embargo en los ejemplos anteriores, tener que escribir los tipos de las variables i y j. No es realmente necesario. Se puede simplificar el lenguaje siguiendo una máxima que a mí me gusta mucho: “Deja que el compilador haga todo lo que puede hacer y deja el resto para el programador”.

Antes de entrar en los detalles del uso de auto, veamos los ejemplos anteriores en C++11. Baste por ahora decir que cuando se especifica que el tipo de una variable es auto, el compilador determina su tipo a partir del valor que se usa para iniciar la variable.

Con esto nuestro primer ejemplo queda:

  vector<int> v = {1, 2, 3};
  for (auto i=v.begin(), e=v.end();i!=e;++i) {
    cout << *i << endl;
  }

Y el segundo ejemplo:

  vector<list<string> > v = { { "Carlos", "Maria"}, {"Niño", "Niña"} };
  for (auto i=v.begin(),e=v.end();i!=e;++i) {
    for (auto j=i->begin(), e=i->end(); j!=e; ++j) {
      cout << *j << " ";
    }
    cout << endl;
  }

Deducción de tipos en contextos de declaración de variable

El principal uso de la deducción automática de variables es la declaración de variables.
Probablemente el uso más simple de auto es la declaración de una variable en un bloque (dentro de una función, dentro de un bucle,…) o bien en un alcance de un espacio de nombres.

  auto x = 5; // x es int
  auto z = 2.5;  // z es double
  string s = "Daniel";
  auto lon = s.length(); // el tipo de lon coincide con el tipo de retorno de length

Otros usos equivalentes son la declaración de una variable en una sentencia de iniciación de un bucle for, en una condición de una sentencia de selección (if, switch) o de una sentencia de iteración (while, do, for).

  string s = "Daniel";
  for (auto i=s.length();i>0;--i) {
    cout << s[i-1];
  }
  cout << endl;

Estos usos facilitan la vida del desarrollador permitiendo escribir código más simple. En este casi no es necesario recordar que tipo concreto devuelve la función miembro length(), basta con indicar que la variable i debe tener el mismo tipo.

Algunos pueden ver esta utilización de auto como una simple conveniencia que no mejora la calidad del código. Sin embargo, incluso en estos casos tan sencillos, la deducción automática de tipos aporta ventajas.
Por una parte, permite expresar claramente la intención del desarrollador. Es decir, la variable i debe tener el mismo tipo que el valor devuelto por la función miembro length(). Por otra parte, este estilo permite evitar errores derivados de la conversión automática de tipos. Veamos:

  string s = "Daniel";
  for (short i=s.length();i>0;--i) {
    cout << s[i-1];
  }
  cout << endl;

¿Qué ocurre si el valor devuelto por length() no cabe en un short? Ciertamente, es una situación que puede calificarse como mínimo de desagradable.

Pero cuando auto se vuelve realmente útil es en la escritura de código genérico. En C++03, se hacía necesario recurrir a código innecesariamente largo para escribir una función que imprimiese los elementos de un contenedor.

template <typename C>
void imprime(const C & c) {
  for (typename C::const_iterator i=c.begin(), e=c.end();i!=e;++i) {
    cout << *i << endl;
  }
}

Con C++11 uno no se tiene que volver a preguntar si el tipo concreto del iterador tiene que ser iterator o const_iterator y tampoco hace falta cualificar el tipo con typename para indicar al compilador de que realmente se trata de un tipo dependiente.

template <typename C>
void imprime(const C & c) {
  for (auto i=c.begin(), e=c.end();i!=e;++i) {
    cout << *i << endl;
  }
}

Más sobre la deducción de tipos

Una pregunta que conviene hacerse sobre la deducción de tipos es qué ocurre con las referencias. Es decir:

int x = 3;
int & z = x;
auto t = z;  // ¿int o int&?

Es decir, si una variable declarada como auto si inicia con otra variable de tipo referencia ¿qué tipo se deduce? La respuesta se obtiene, una vez que se observa que lo que se utiliza como iniciador (en nuestro caso z) expresión y por tanto su tipo es int.

¿Y si se desea que t sea una referencia? La solución es simple, puesto que se puede combinar auto con cualquier otro especificador de declaraciones:

int x = 3;
int & z = x;
auto&  t = z;  // int&
const auto u = x; // const int
auto *p = &x;

Otros usos de la deducción automática de tipos

Probablemente, un caso más sorprendente (aunque no debería) es la deducción automática de tipos en expresiones asociadas al operador new.

auto p = new auto(1.5); // p es un double*

Además, se puede usar la deducción automática de tipos con variables miembro estáticas que se inician dentro de la definición de una clase.

class X {
public:
  static const auto n = 3;
};

En resumen

C++11 introduce un mecanismo que permite que el compilador pueda deducir el tipo de una variable a partir de la expresión con la que ésta se inicia. Este mecanismo simplifica la escritura de código genérico. Como complemento, el mecanismo permite que evitar errores comunes de programación derivados de conversiones implícitas no deseadas.

Próximamente comentaré dos características del lenguaje que están íntimamente relacionadas con esta: la deducción automática de tipos de retorno en funciones y la obtención del tipo de un objeto.

Nuevas bibliotecas estándar para C++

Cuando digieras las 1400 páginas que tiene el nuevo estándar de C++, comprobarás que una parte bastante importante de la norma la constituye una renovada biblioteca de clases. No obstante, es probable que todavía pienses que faltan cosas.

Bien, las buenas noticias son que se abre la puerta para nuevas propuestas de bibliotecas. El comité ha decidido animar a que se presenten propuestas para una futura extensión de la biblioteca estándar.

Esta es la resolución del comité:

The C++ committee Library Working Group welcomes proposals for library extensions which will be considered starting in the February 2012 meeting. We have not yet set out an overall timeline for future library extensions, but are ready to consider new proposals at this point.

To increase the chances of your proposal being accepted by the committee, we strongly recommend that a committee member willing to champion your proposal (this could be you yourself, or a delegate) attend upcoming meetings to help shepherd your proposal through the process.

La preparación de una propuesta de biblioteca para normalizar debe considerar múltiples aspectos que van desde la utilidad general del componente hasta la implementabilidad en las diversas plataformas usadas y la capacidad de ser expresadas de forma portable.

Como comentaba en mi anterior post, ya tenemos diversas propuestas encima de la mesa, pero si tienes una propuesta interesante este es el momento.