CLU

**CLU** é un linguaxe de programación creada polo instituto de tecnoloxía de Massachusetts (MIT) por Barbara Liskov e os seus estudantes entre 1974 e 1975. Usaba construtores para os tipos de datos abstractos que se incluíron no código, un paso adiante na programación orientada a obxectos (POO). No entanto habían moitas outras das características de POO que faltaban desenvolver ou estaban incompletas. Por outra banda a linguaxe obstaculízase por unha sintaxe ás veces un pouco dificultosa. CLU e Alphard parecen ser ambos, linguaxes orientadas a obxectos completos sen selo realmente.

## CLUsters 
A sintaxe de CLU esta baseada en ALGOL, un punto de partida para o deseño da maioría de novas linguaxes. A incorporación máis importante é o concepto de *cluster*, ''CLU's type extension system and the root of the language's name* (CLUster), que vén significar, "tipo de extensión do sistema do CLU e da raíz dos nomes das linguaxes". Os clusters corresponden xeralmente ao concepto de obxecto "" nunha linguaxe orientada a obxectos, e teñen unha sintaxe moi similar. Por exemplo, a continuación vemos a sintaxe de CLU para un cluster que implementa números complexos:

`
    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;
`

Mentres que os clusters ofreceron un sistema entón-avanzado para os programas de estructuración, CLU non ofreceu ningunha clase de estrutura para os clusters. Os nomes dos clusters son globais, e non se proporcionou ningún mecanismo aos clusters para agrupalos ou permitir que sexan creados "localmente" dentro doutros clusters. Este problema non se dá só en CLU, xa que sorprendentemente moitas linguaxes careceron desta característica - o problema atópase centralizado en ALGOL, de dar alcance ás variables. Parece ser, que dar alcance aos nomes do cluster/obxecto sería unha expansión obvia.

CLU non realiza conversiones de tipo implícito. Nun cluster, as conversiones tipo explícito "up" e "down" cambian entre o tipo abstracto e a representación. Hai un tipo universal "any", e un procedemento force[] para comprobar que un obxecto é dun tipo correcto. Os obxectos poden ser mutable ou inmutables, este último "tipos basee" por exemplo números enteiros.

## Outras características 
Outra característica importante do tipo sistema de CLU son os *iteradores* (patróns de deseño), que devolven obxectos dun conxunto, un detrás doutro. Os iteradores son como "caixas negras" que ofrecen unha *interface de programación de aplicacións* API onde non importaba o tipo de datos que estivesen usando. Así, o iterador para un conxunto de números complexos sería idéntico que para un array de números enteiros. Os iteradores son agora unha característica común da maioría das linguaxes modernas.

Unha característica distintiva final en CLU é a asignación múltiple, onde pode aparecer máis dunha variable no lado esquerdo dun operador de asignación. Por exemplo, escribindo `x, e = e, x` os valores de intercambio de code <>x e de code <>E. Da mesma forma, as funcións poderían retornar varios valores, como `x, e, z = f (t)`.

Todos os obxectos nun programa de CLU decláranse ao principio, sendo así, a reserva de memoria automática.

## Exemplo de código en CLU 
 
      % Driver and function to compute factorials
      % from the PCLU distribution.
       start_up = proc ()
          pi: stream := stream()
          po: stream := stream()
          while true do
              stream(po, "Enter an integer (or RETURN to exit): ")
              s: string := stream(pi)
              if string(s) then break end
              n: int := int(s)
                 except when bad_format:
                             stream(po, "Illegal integer")
                        end
              stream(po, int(n) || "! = " || int(factorial(n)))
                 except when negative:
                             stream(po, "Integer must be positive")
                        when overflow:
                             stream(po, "Overflow")
                        end
              end
          end start_up
      
       factorial = proc (n: int) returns (int) signals (negative, overflow)
          if n 

## Influencia noutras linguaxes de programación 
* Python e Ruby tomaron prestados varios conceptos de CLU (por exemplo, a declaración da produción e a asignación múltiple).
* CLU, xunto con Ada eran inspiracións importantes para os persoais de C++.
* Os mecanismos de dirección de excepción de CLU tamén influenciaron novas linguaxes como Xava e C++.
* Todos os obxectos nun programa de CLU decláranse ao principio, e a administración da memoria é automática. Xava directamente influenciado.
* Python e C# inclúen generators (iterators en C#), que primeiro apareceron en CLU como *iterators''.

## Ligazóns externas 
* Páxina principal de CLU
* Historia de CLU (pdf)
* clu2c: programa para compilar código de CLU a C
* Dicionario de linguaxes de programación