Welcome to the Dictionary of Programming Languages, a compendium of computer coding methods assembled to provide information and aid your appreciation for computer science history.

Browse the dictionary by clicking on a section:
       A  B  C  D  E  F  G  H  I  JK  L  M  N  O  P  QR  S  T  UV  WXYZ+ 

Get a full dump of the dictionary:
       List of Names      Short Form      Full Form

CLU

See:

Algol   

Language type:

S - block-structured

Description:

CLU is a compiled imperative language with extensive features for defining and employing abstract data types. It was intended for general application development, and also as a research vehicle in computer language design.
As was a descendant of Algol, CLU offered syntax that was similar to Algol60 in many respects, but it added data type abstraction, exception handling, and other advanced features. The name "CLU" is short for "CLUster", this was chosen because a CLU program normally consists of procedures, clusters, and interators.
CLU supported a number of advanced features for structured languages for its day, including garbage collection, a form of inheritance, iterators, strong typing, generics, and exception handling.
The research operating system SWIFT was written in CLU, as were other tools and utilities.
A free CLU compiler named 'PCLU' is available from MIT. There is also a CLU->C translator named clu2c available from Tokyo Tech. Some information about CLU is available on the web, but not much.

Origin:

B. Liskov et al, 1974-77.

See Also:

Pascal    Ada    Modula-2    Lisp    Simula    C++   

Remarks:

CLU was mostly a research vehicle for experimenting with data abstraction and other language design issues. Some of its ideas, especially in the area of exception handling, have been adopted in newer languages like Ada and Java.
The ideas for CLU were derived from a programming methodology, also defined by Barbara Liskov and her colleagues, that emphasized abstract data types and modularity.
While CLU is syntactically similar to Algol, its data storage semantics are more like those of mainstream Lisp (and, much later, Java). All objects in a CLU program live in the heap, and memory management is automatic. This sort of a approach does eliminate much of the semantic complexity associated with multiple forms of programmer-managed object storage observed in C++.

Links:

ftp://ftp.lcs.mit.edu/pub/pclu/

Date:

Last updated 2/28/98

Sample code:

% 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

Descriptions in this dictionary are ©1997-99 Neal Ziring. Some examples copyright of their respective authors. Some technologies and languages are trademarked. Permission to copy descriptions is granted as long as authorship credit is preserved.

Comments on this dictionary, corrections and suggestions, are all welcome. Please use email, the address is ziring@home.com