This page is hasn't been actively maintained for years. Most "updates" are links fixed or added to the TODO list. Note that since the programming language scene doesn't evolve very fast, this page might still be useful.
An interesting place for those interested in programming languages is Lambda, the Ultimate weblog.
Resource management is a central topic, and any language implementor should know about Garbage Collection (GC) techniques.
Existing languages
This classification is stupid, approximative,
and should be re-done completely,
with perhaps an array of "features",
to serve as a guide...
Of course, the only way to know for sure about the
language is to see how it really is...
Also, many things here are out of date. Updates welcome...
Writing the formal semantics of C++ is left as an exercise to the reader.
Actually, C and C++ are not high-level languages, and just worth throwing to nearest garbage can (poor garbage can), unless you're stuck to it, which you are on existing systems (themselves worth as much, but again, you're stuck to them until Tunes comes out).
The development of the language did not stop, and research in Lisp and particularly Common Lisp flourished. In 1985 DARPA announced that they wanted to standardise Common Lisp. The standardisation and development of Common Lisp explored many options; joining forces with Scheme, an object system, meta-object protocols, etc. Common Lisp got it's ANSI standard in 1994 and was the first Object-Oriented Language to get an ANSI standard. However, the Scheme and Common Lisp communities are still separate, and the meta-object protocol (MOP) was never finished in time for ANSI. However, Common Lisp got the Common Lisp Object System (CLOS) finished for the ANSI standard and it is in most respects the most powerful and well-thought-out object-oriented language today (Nov 1999). The MOP is however by most Common Lispers viewed as extremely powerful and an important part of any serious Common Lisper's toolbox.
The advantages of programming in Common Lisp are many and it's a pity that so few programmers know the language. Ironically, Greenspun's Tenth Rule of Programming states that "any sufficiently complicated C or Fortran program contains an ad hoc informally-specified bug-ridden slow implementation of half of Common Lisp". In other words, Common Lisp has a lot of the functionality you need when writing a complicated program, where C/C++/Java/etc just don't scale good enough and you end up building the needed mechanisms yourself.
LISP and Common Lisp in particular was hit hard by the AI Winter at the end of the 80s, and other languages have grown much faster in the 90s. Many small signs do however indicate that it is spring in the Common Lisp land, and that Common Lisp is the right horse to make a bet on.
The following two are proprietary software, not free software, but have trial binaries available free of charge for non-commercial purpose, so you may get the gist of them:
LISP is a self-extending higher-order dynamically typed strict (but with lazy data structures often implemented) non-pure functional language.
It is the second oldest programming language still in use, but also one with the nicest semantics. It's a good experimental platform for just any kind of computing; it has got very good support, including free portable development environments, integrated structured editors, and efficient "optimizing" compilers.
More myths about LISP may be found here.
The basic data structure, the SEXP, is hence a recursive list, and provides a trivial syntax for writing programs: atomic symbols each denote a value, and a list being interpreted as a function call; the head element of the list is computed as a function, the tail of the list is computed as parameters given to it, and the result is what applying the function to the parameters return. (Of course, SEXP need not be interpreted this way, and indeed, good implementations will compile them insteadfor better performance).
Knowledgeable computists will see that SEXPs are a actually only a trivial syntax for abstract syntax trees. While programmers and language implementers of other languages spend so much time and effort mastering or developing wierd fancy syntaxes, that they spend years debugging, parsing, etc, Lisp programmers and implementers instead trivialize those tasks, and can focus on semantics. At the same time, S-exp give an canonical embedding of source code as data, which is foremost for development of meta-programs and reflective features.
SEXP syntax is unobvious at first; not only is it unfamiliar for someone having received a standard education; it also lacks these kinds of redundancy that make it so easy to read simple things in many other languages at first when read in a linear way, while imposing a systematic repetitive constraint that is tedious to follow, all the less without good editing tools (such as EMACS), and a treelike indentation of code (which is some different useful redundancy), of which most programmers are unaware.
For these reasons, SEXP has gained a bad reputation among illiterate programmers, who don't see beyond the syntax, and LISP has been surnamed such things as "Lots of Insipid and Stubborn Parentheses".
On the other hand, SEXP also avoids the ambiguities and limitations that make it so easy to write gross mistakes in many other languages, and to tedious (when even possible) the elaboration of complex programs. After a short training, SEXP appear as the representation for abstract syntax trees that they are, and they become as familiar to LISP programmers as the infix syntaxes considered as "normal" by other people (which after all is a matter of conventions and education); only SEXP have lots of additional advantages, as already described. There actually used to be another more conventional syntax for LISP, the M-exp, but it fell out of use as the S-exp were so much more practical to Lispers whereas the M-exp led to endless arguing about with way to write things was fanciest, and how to translate between code and data representations.
The advantages brought by the trivial SEXP syntax are precisely the strongest asset of the LISP family of languages, and all stem from the fact that the programmer's brain was literally liberated from the yoke of syntax. SEXP mean "drop the syntactic brainfuck, and get to the actual semantic problem". Paradoxically, the uncommon character of LISP's syntax has also been the biggest brake to its spreading widely, so that LISP's strongest asset is also one of its major marketing weaknesses.
A way by which LISP can benefit from both the reflective features of its abstract syntax, and from the ease of access of more "conventional" syntaxes, is to have first-class syntaxes, as in the GUILE system, where new fancy syntaxes can be seamlessly used, that are all canonicalized to SEXP, while SEXP can be pretty-printed to them.
Another system, Dylan, started with SEXP syntax and concepts developed by Lispers freed of syntactic concerns, and then stopped using the SEXP syntax, to provide a cutting-edge state-of-the-art language, though a language that might not benefit anymore from the same freedom of thought as LISP provided (another more modest such Scheme dialect is Pico)
About its syntax, we find that it is very all-purpose, and adapts immediately to any use; however, it doesn't allow to scale to specific uses where local constraints make it too redundant.
It could be said that Lisp is a language based on syntax trees; then, Clean, that is based on graphs, and could be a successor (see also Prolog and Lambda-Prolog for the same in logic programming).
Perl5 has all the good features of Perl4 (a few misfeatures were dropped and replaced), but it's a full-fledged all-purpose language with a most powerful OO module system.
Back to the TUNES
Review Subproject,
or to the HLL Subproject.