**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 < 0 then signal negative end
         if n = 0 then return(1) end
         return(n*factorial(n-1))
            resignal overflow
      end factorial
````

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[*Ligazón morta*]: programa para compilar código de CLU a C
* Dicionario de linguaxes de programación

| * v
* c
* e
Linguaxes de programación |
| --- |
| Baixo nivel | 

|  |  |
| --- | --- |
| Primeira xeración | Código máquina |
| Segunda xeración | Assembly |

 |
| Alto nivel | 

|  |  |
| --- | --- |
| Terceira xeración | 
* A+
* ABC
* Algol
* B
* BASIC
* C
* C++
* C#
* COBOL
* CPL
* D
* E
* Fortran
* Go
* Java
* JavaScript
* Lisp
* Objective-C
* PL/1
* Pascal
* Smalltalk
* Visual Basic .NET

 |
| Cuarta xeración | 
* Clarion
* Clipper
* Clojure
* Common Lisp
* Erlang
* GNU Octave
* Haskell
* Lisp
* Lua
* Julia
* Perl
* PHP
* Prolog
* Python
* R
* Ruby
* Rust
* S
* Scilab
* Stata
* SQL

 |
| Quinta xeración | 
* Mercury
* OPS5
* Prolog

 |

 |
| 
* Ambiente de desenvolvemento
* Metaprogramación
* Programación a nivel funcional
* Programación estruturada
* Programación non estruturada
* Programación imperativa
* Programación modular
* Programación multidimensional
* Orientación a obxectos

 |

|  |  |
| --- | --- |
| Control de autoridades | 
* Wd: Q775159
* LCCN: sh85027223

 |