CLU (programming language)

CLU is a programming language created at the Massachusetts Institute of Technology (MIT) by Barbara Liskov and her students between 1974 and 1975. While it did not find extensive use, it introduced many features that are used widely now, and is seen as a step in the development of object-oriented programming (OOP).

CLU
Paradigmmulti-paradigm: object-oriented, procedural
Designed byBarbara Liskov and her students
DeveloperMassachusetts Institute of Technology
First appeared1975 (1975)
Stable release
Native CLU 1.5 (SPARC, VAX) / May 26, 1989 (1989-05-26)[1]

Portable CLU / November 6, 2009 (2009-11-06)[2]

Typing disciplinestrong
Websitewww.pmg.lcs.mit.edu/CLU.html
Major implementations
Native CLU,[1] Portable CLU,[2] clu2c[3]
Influenced by
ALGOL 60, Lisp, Simula
Influenced
Ada, Argus, C++, Lua, Python,[4] Ruby, Sather, Swift[5]

Key contributions include abstract data types,[6] call-by-sharing, iterators, multiple return values (a form of parallel assignment), type-safe parameterized types, and type-safe variant types. It is also notable for its use of classes with constructors and methods, but without inheritance.

Clusters

The syntax of CLU was based on ALGOL, then the starting point for most new language designs. The key addition was the concept of a cluster, CLU's type extension system and the root of the language's name (CLUster).[7] Clusters correspond generally to the concept of a "class" in an OO language. For instance, here is the CLU syntax for a cluster that implements complex numbers:

    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;

A cluster is a module that encapsulates all of its components except for those explicitly named in the "is" clause. These correspond to the public components of a class in recent OO languages. A cluster also defines a type that can be named outside the cluster (in this case, "complex_number"), but its representation type (rep) is hidden from external clients.

Cluster names are global, and no namespace mechanism was provided to group clusters or allow them to be created "locally" inside other clusters.

CLU does not perform implicit type conversions. In a cluster, the explicit type conversions up and down change between the abstract type and the representation. There is a universal type any, and a procedure force[] to check that an object is a certain type. Objects may be mutable or immutable, the latter being base types such as integers, booleans, characters and strings.[7]

Other features

Another key feature of the CLU type system are iterators, which return objects from a collection serially, one after another.[7] Iterators offer an identical application programming interface (API) no matter what data they are being used with. Thus the iterator for a collection of complex_numbers can be used interchangeably with that for an array of integers. A distinctive feature of CLU iterators is that they are implemented as coroutines, with each value being provided to the caller via a yield statement. Iterators like those in CLU are now a common feature of many modern languages, such as C#, Ruby, and Python, though recently they are often referred to as generators.

CLU also includes exception handling, based on various attempts in other languages; exceptions are raised using signal and handled with except. Unlike most other languages with exception handling, exceptions are not implicitly resignaled up the calling chain. Also unlike most other languages that provide exception handling, exceptions in CLU are considered part of ordinary execution flow and are considered a "normal" and efficient typesafe way to break out of loops or return from functions; this allows for direct assignment of return values "except when" other conditions apply. Exceptions that are neither caught nor resignaled explicitly are immediately converted into a special failure exception that typically terminates the program.

CLU is often credited as being the first language with type-safe variant types, called oneofs, before the language ML had them.

A final distinctive feature in CLU is parallel assignment (multiple assignment), where more than one variable can appear on the left hand side of an assignment operator. For instance, writing x,y := y,x would exchange values of x and y. In the same way, functions could return several values, like x,y,z := f(t). Parallel assignment (though not multiple return values) predates CLU, appearing in CPL (1963), named simultaneous assignment,[8] but CLU popularized it and is often credited as the direct influence leading to parallel assignment in later languages.

All objects in a CLU program live in the heap, and memory management is automatic.

CLU supports type parameterized user-defined data abstractions. It was the first language to offer type-safe bounded parameterized types, using structure where clauses to express constraints on actual type arguments.

Influence on other programming languages

CLU has influenced many other languages in many ways. In approximate chronological order, these include:

CLU and Ada were major inspirations for C++ templates.

CLU's exception handling mechanisms influenced later languages like C++ and Java.

Sather, Python, and C# include iterators, which first appeared in CLU.

Perl and Lua took multiple assignment and multiple returns from function calls from CLU.[9]

Python and Ruby borrowed several concepts from CLU, such as call by sharing, the yield statement,[10] and multiple assignment[11]

gollark: Tetrahedra forever!
gollark: ALL HAIL THE d4!
gollark: Neural networks: Wizardry nobody understands except people who understand them.
gollark: Pigeonhole principle.
gollark: You can't reduce space taken up by every input.

References
  1. Curtis, Dorothy (2009-11-06). "CLU home page". Programming Methodology Group, Computer Science and Artificial Intelligence Laboratory. Massachusetts Institute of Technology. Retrieved 2016-05-26.
  2. Curtis, Dorothy (2009-11-06). "Index of /pub/pclu". Programming Methodology Group, Computer Science and Artificial Intelligence Laboratory. Massachusetts Institute of Technology. Retrieved 2016-05-26.
  3. Ushijima, Tetsu. "clu2c". clu2c. woodsheep.jp. Retrieved 2016-05-26.
  4. Lundh, Fredrik. "Call By Object". effbot.org. Retrieved 21 November 2017. replace "CLU" with "Python", "record" with "instance", and "procedure" with "function or method", and you get a pretty accurate description of Python's object model.
  5. Lattner, Chris (2014-06-03). "Chris Lattner's Homepage". Chris Lattner. Retrieved 2014-06-03. The Swift language is the product of tireless effort from a team of language experts, documentation gurus, compiler optimization ninjas, and an incredibly important internal dogfooding group who provided feedback to help refine and battle-test ideas. Of course, it also greatly benefited from the experiences hard-won by many other languages in the field, drawing ideas from Objective-C, Rust, Haskell, Ruby, Python, C#, CLU, and far too many others to list.
  6. Liskov, Barbara; Zilles, Stephen (1974). "Programming with abstract data types". Proceedings of the ACM SIGPLAN symposium on Very high level languages. pp. 50–59. CiteSeerX 10.1.1.136.3043. doi:10.1145/800233.807045.CS1 maint: ref=harv (link)
  7. Liskov, B.; Snyder, A.; Atkinson, R.; Schaffert, C. (August 1977). "Abstraction mechanisms in CLU". Communications of the ACM. 20 (8): 564–576. CiteSeerX 10.1.1.112.656. doi:10.1145/359763.359789.
  8. Barron, D. W.; Buxton, J. N.; Hartley, D. F.; Nixon, E.; Strachey, C. (1963). "The main features of CPL". Computer Journal. 6 (2): 134–143. doi:10.1093/comjnl/6.2.134.
  9. Ierusalimschy, R.; De Figueiredo, L. H.; Celes, W. (2007). "The evolution of Lua". Proceedings of the third ACM SIGPLAN conference on History of programming languages – HOPL III (PDF). pp. 2-1–2-26. doi:10.1145/1238844.1238846. ISBN 978-1-59593-766-7.
  10. "Ruby's Roots and Matz's Leadership". Appfolio Engineering. 2019-11-08. Retrieved 2019-11-15. Matz feels that blocks are the greatest invention of Ruby (I agree.) He got the idea from a 1970s language called CLU from MIT, which called them 'iterators'...
  11. "Functional Programming HOWTO — Python 3.8.3 documentation". docs.python.org. Retrieved 2020-05-25.
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.