CLU es un lenguaje de programación creado por el instituto de tecnología de Massachusetts (MIT) por Barbara Liskov y sus estudiantes entre 1974 y 1975. Usaba constructores para los tipos de datos abstractos que se incluyeron en el código, un paso adelante en la programación orientada a objetos (POO). No obstante habían muchas otras de las características de POO que faltaban desarrollar o estaban incompletas. Por otra parte el lenguaje se obstaculiza por una sintaxis a veces un poco engorrosa. CLU y Alphard parecen ser ambos, lenguajes orientados a objetos completos sin serlo realmente.

CLUsters

La sintaxis de CLU esta basada en ALGOL, un punto de partida para el diseño de la mayoría de nuevos lenguajes. La incorporación más importante es el concepto de cluster, CLU's type extension system and the root of the language's name (CLUster), que viene a significar, "tipo de extensión del sistema del CLU y de la raíz de los nombres de los lenguajes". Los clusters corresponden generalmente al concepto de "objeto" en un lenguaje orientado a objetos, y tienen una sintaxis muy similar. Por ejemplo, a continuación vemos la sintaxis de CLU para un cluster que implementa números complejos:

   complex_number = cluster is add, subtract, multiply,....
        rep = record [ real_part: real, imag_part: real ]
        add = proc... end add;
        subtract = proc... end subtract;
        multiply = proc... end multiply;
       ...
   end complex_number;

Mientras que los clusters ofrecieron un sistema entonces-avanzado para los programas de estructuración, CLU no ofreció ninguna clase de estructura para los clusters. Los nombres de los clusters son globales, y no se proporcionó ningún mecanismo a los clusters para agruparlos o permitir que sean creados "localmente" dentro de otros clusters. Este problema no se da solo en CLU, ya que sorprendentemente muchos lenguajes han carecido de esta característica - el problema se encuentra centralizado en ALGOL, de dar alcance a las variables. Parece ser, que dar alcance a los nombres del cluster/objeto sería una expansión obvia.

CLU no realiza conversiones de tipo implícito. En un cluster, las conversiones tipo explícito "up" y "down" cambian entre el tipo abstracto y la representación. Hay un tipo universal "any", y un procedimiento force[] para comprobar que un objeto es de un tipo correcto. Los objetos pueden ser mutable o inmutables, este ultimo "tipos base" por ejemplo números enteros.

Otras características

Otra característica importante del tipo sistema de CLU son los iteradores (patrones de diseño), que devuelven objetos de un conjunto, uno detrás de otro. Los iteradores son como "cajas negras" que ofrecen una interfaz de programación de aplicaciones API donde no importaba el tipo de datos que estuvieran usando. Así, el iterador para un conjunto de números complejos sería idéntico que para un array de números enteros. Los iteradores son ahora una característica común de la mayoría de los lenguajes modernos.

Una característica distintiva final en CLU es la asignación múltiple, donde puede aparecer más de una variable en el lado izquierdo de un operador de asignación. Por ejemplo, escribiendo x, y = y, x los valores de intercambio de x y de Y. De la misma forma, las funciones podrían retornar varios valores, como x, y, z = f (t).

Todos los objetos en un programa de CLU se declaran al principio, siendo así, la reserva de memoria automática.

Ejemplo de código en CLU

     % Driver and function to compute factorials
     % from the PCLU distribution.
      start_up = proc ()
         pi: stream := stream$primary_input()
         po: stream := stream$primary_output()
         while true do
             stream$puts(po, "Enter an integer (or RETURN to exit): ")
             s: string := stream$getl(pi)
             if string$empty(s) then break end
             n: int := int$parse(s)
                except when bad_format: 
                            stream$putl(po, "Illegal integer")
                       end
             stream$putl(po, int$unparse(n) || "! = " || int$unparse(factorial(n)))
                except when negative: 
                            stream$putl(po, "Integer must be positive")
                       when overflow:
                            stream$putl(po, "Overflow")
                       end
             end
         end start_up
      
      factorial = proc (n: int) returns (int) signals (negative, overflow)
         if n < 0 then signal negative end
         if n = 0 then return(1) end
         return(n*factorial(n-1))
            resignal overflow
      end factorial

Influencia en otros lenguajes de programación

• Python y Ruby tomaron prestados varios conceptos de CLU (por ejemplo, la declaración de la producción y la asignación múltiple).
• CLU, junto con Ada eran inspiraciones importantes para las plantillas de C++.
• Los mecanismos de dirección de excepción de CLU también influenciaron nuevos lenguajes como Java y C++.
• Todos los objetos en un programa de CLU se declaran al principio, y la administración de la memoria es automática. Java directamente influenciado.
• Python y C# incluyen generators (iterators en C#), que primero aparecieron en CLU como iterators.

Enlaces externos

• Página principal de CLU
• Historia de CLU (pdf)
• clu2c: programa para compilar código de CLU a C
• Diccionario de lenguajes de programación