Cool (programming language)
 |
This article includes a list of references, related reading or external links, but its sources remain unclear because it lacks inline citations. Please improve this article by introducing more precise citations. (February 2010) |
| Paradigm(s) | object oriented |
|---|---|
| Appeared in | 1996 |
| Designed by | Alexander Aiken |
| Developer | Alexander Aiken |
| Typing discipline | static, strong |
| Dialects | Cool 2004, Cool 2005, Cool 2006, Cool 2007, Cool 2008, unCool |
| Influenced by | Sather164, Java, ML, Pascal |
Cool, an acronym for Classroom Object Oriented Language, is a computer programming language designed by Alexander Aiken for use in an undergraduate compiler course project. While small enough for a one term project, Cool still has many of the features of modern programming languages, including objects, automatic memory management, strong static typing and simple reflection.
The reference Cool compiler is written in C++, built fully on public domain tools. It generates code for a MIPS simulator, SPIM. Thus, the language should port easily to other platforms. It has been used for teaching compilers at many institutions (such as the University of California at Berkeley, where it was first used) and the software is stable.
Other lecturers such as John Tang Boyland (author of the Sather164 language, precursor of Cool) and Allan Jost have developed some dialects of Cool to be used in their own classes.
This language is unrelated to the COOL language included in CLIPS.
[edit] Features
As the primary purpose of Cool is instruction, it lacks many of the features common to other, more general programming languages. For instance, the language supports less than comparisons but not greater than. The syntax is very much stripped down, and the "standard library" contains only a few basic classes. Separate compilation is not supported, though the compiler does support multiple source files as input. Every Cool program must define a class Main which must have a no-args constructor in which execution flow begins. Namespaces are not supported.
A simple Cool program for computing factorial follows:
class Main : IO is
Main() begin
out_string("Enter an integer greater-than or equal-to 0: ");
let input: Integer := in_int(); in
if input < 0 then
out_string("ERROR: Number must be greater-than or equal-to 0\n")
else
out_string("The factorial of ").out_int(input);
out_string(" is ").out_int(factorial(input))
fi
end
end;
factorial(num: Integer): Integer := if num = 0 then 1 else num * factorial(num - 1) fi;
end;
The syntax used in this sample comes out of Cool 2008, a dialect of Cool developed by John Tang Boyland. Other dialects of Cool may have markedly different syntax.
[edit] References
- Cool: A Portable Project for Teaching Compiler Construction
- CoolAid: The Cool 2008 Reference Manual
- (Un)CoolAid: The UnCool Reference Manual
[edit] External links
- Cool: The Classroom Object-Oriented Language project main page
