Programming Languages This page is more abstract and wide-ranging than other pages of this site. For one thing, it's about languages, not products. Granted, in most cases, using a language means acquiring some development software, but I'm trying to treat that as a secondary question here, to put the languages themselves under the spotlight.
These are all "living languages", ranging in age from several decades to several months. I've tried to group them by their family similarities, but that's easier said than done. The order is arbitrary, and isn't intended to imply that Language A is "better" than Language B, because what's good for one situation may not be good for another. I try to describe each language in terms of its major characteristics, availability, and typical uses. (My glossary links may come in handy for understanding these comments.) The origin of each language's name is listed in [brackets].
This list is by no means complete; there are more languages missing than included. I've tried to focus on the more general-purpose languages, rather than those tied to a specific use. (Languages used as a web-scripting technology have their own page.) And of course there are many "dead" or rarely-used languages, that I've left out - however noteworthy - because they're only of historical interest. Also, I don't claim to be an expert in languages; I find them fascinating, and I've used a dozen or two over the course of my education and career, but due to time constraints I'm really just a dabbler in this field. I'm indebted to the many genuine experts who've given me tips and corrections for this page. This page is also still under construction, and I apologise for the blank spots.
Machine Language refers to the "ones and zeroes" that digital processors use as instructions. Give it one pattern of bits (such as 11001001) and it will add two numbers, give it a different pattern (11001010) and it will instead subtract one from the other. In as little as a billionth of second. The instruction sets within a CPU family are usually compatible, but not between product lines. For example, Intel's x86/Pentium language and Motorola's PPC/Gx language are completely incompatible. Machine Language is painfully difficult to work with, and almost never worth the effort anymore. Instead programmers use the higher-level languages below, which are either compiled or interpretted into machine language by the computer itself.
Assembly Language is as close as you can come to writing in machine language, but has the advantage that it's also human-readable... using a small vocabulary of words with one syllable. Each written instruction (such as MOV A,B) typically corresponds to a single machine-language instruction (such as 11001001). An assembler makes the translation before the program is executed. Back when CPU speed was measured in kiloHertz and storage space was measured in kiloBytes, Assembly was the most cost-efficient way to implement a program. It's used less often now (with all those kilo's replaced by mega's or giga's, and even tera's on the horizon, it seems no one cares anymore about efficiency), but if you need speed and/or compactness above all else, Assembly is the solution.
C [successor to the language "B"] offers an elegant compromise between the efficiency of coding in assembly language and the convenience and portability of writing in a structured, high-level language. By keeping many of its commands and syntax analagous to those of common machine languages, and with several generations of optimising compilers behind it, C makes it easy to write fast code without necessarily sacrificing readability. But it still tempts you write code that only a machine can follow, which can be a problem when it comes time to debug it or make changes. Free and commercial tools (most of which now also support C++) are available from various sources for just about every operating system.
C++ ["C" with the C instruction to "increment"] is probably the most widely-supported language today, and most commercial software is written in C++. The name reflects why: when it was introduced it took all the benefits of the then-reigning development language (C) and incrementally added the next set of features programmers were looking for (object oriented programming). So programmers didn't have to throw anything out and re-do it... but they could add those techniques to their repertoire as needed. OO purists hate the results, but it's difficult to argue with that success. Free and commercial tools are available from various sources for just about every operating system. (Objective-C is an alternate approach to adding OO characteristics to C (borrowing directly from SmallTalk), which hasn't attracted as large a community of users.)
C# ["C++" with the plus signs overlapping, pronounced "C sharp", equivalent to D] is actually Microsoft's answer to Java. They originally tried to release "Java" development tools that would produce apps that weren't truly portable; you could only use them on Windows. But this violated their licensing agreement with Sun (creators of Java), who successfully put a stop to that. So Microsoft turned around and produced a language with similar features that effectively is tied to Windows. Although they are submitting the language to a standard-setting body, for all practical purposes it's just a proprietary variant of C++ whose specs they'll dictate, available only from Microsoft, and practical only for Windows.
Java [slang for "coffee"] is kind of a streamlined version of C++, designed for portability. Its key advantage is that Java programs can be run on any operating system for which a Java "virtual environment" is available. (Programs in most other languages have to be modified and recompiled to go from one OS to another.) The language is defined by Sun and widely licenced to other companies, making it possible to run Java apps in web browsers, portable phones, desktop computers, web servers, etc. It isn't as fast as applications written in a compiled language like C++, however. Free and commercial tools are available from various sources for most current operating systems. Although Microsoft is removing support for Java from the default setup of new versions of Windows, it can easily be added back in.
Pascal [mathematician/philosopher Blaise Pascal] was designed primarily as a tool for teaching good programming skills, but - thanks largely to the availability of Borland's inexpensive Pascal compiler for the early IBM PC - it has become popular outside of the classroom. Unlike many languages, Pascal requires a fairly structured approach, which prevents the kinds of indecipherable "spaghetti code" and easily-overlooked mistakes that plague programmers using languages such as Fortran or C. Free and commercial tools are available from various sources for DOS, Windows, Mac, OS/2, AmigaOS, and Unix-like systems. The web site editor BBEdit is written in Pascal.
Delphi [home of the Greek oracle Pythia] is a non-standard, object-oriented version of Pascal developed by Borland for their rapid application development tool of the same name. The Delphi environment was designed to compete with Microsoft's Visual Basic tools, freeing the programmer from having to write all the code for the user interface by letting her drag and drop objects and attach functions to various buttons and other on-screen elements. Its ability to manipulate databases is another strength. Commercial tools are available from Borland for Windows and Linux.
Oberon [a moon of Uranus] is a later sibling of Pascal and Modula (sharing a parent, creator Niklaus Wirth). The name also refers to the operating environment in which the language was designed to be used.
Turing [computer scientist Alan Turing]
BASIC ["Beginner's All-purpose Symbolic Instruction Code"] is the first language that most early microcomputer users learned. The BASIC interpreters on those machines weren't very sophisticated or fast, largely due to the memory and speed limitations of the hardware, and the language encouraged sloppy coding. As an unknown pundit put it: "BASIC is to computer languages what Roman numerals are to arithmetic" Modern versions of BASIC are more structured and often include compilers for greater speed. Free and commercial tools are available from various sources for DOS, Windows, Mac, and Unix-like systems.
Visual Basic [a version of "BASIC" for graphical environments] is Microsoft's Jack of all Trades language. It's a cross between BASIC, the various macro languages of Microsoft Office, and some rapid application development tools. The idea was to get people started writing macros using VBA (Visual Basic for Applications), then sell them the whole VB programming tool when they run into the limits of that approach. Unfortunately VB apps are impossible to port to other environments, and you're at the mercy of Microsoft's changing specs for the language. (Programs written in VB6 or earlier will not run properly in VB.NET!) Available only from Microsoft, only for Windows.
Euphoria ["a state of bliss"] is described by its creator as "simple, flexible, and easy-to-learn", and its supportive community of users agree. Although powerful, it's not prone to allowing "dangerous" mistakes. It's an interpreted language, but quicker than most, and it can be converted into C code, which can then be compiled using an optimising compiler. The interpreter and C converter (for both Windows/DOS and Linux/FreeBSD) are available free, or with some bonus features when registered for a modest fee.
Ada [proto-programmer Lady Ada Byron] Based largely on Pascal, it was commissioned by the U.S. Dept. of Defense to create a standard language to replace the polyglot they had amassed over the decades. It's commonly accused of being typical of government committee work, but has many strengths, including its error-handling and the ease of maintaining and modifying programs. Furthermore, government studies :) indicate that it's more cost-effective than C++, Pascal, or Fortran. The current version includes object-oriented features.
Icon [perhaps from "iconoclastic", pre-dating the current use of the term in graphical interfaces] is a high-level, imperative, procedural language. Text-handling is one of its strengths. Storage is allocated dynamically. Full versions exist for Unix-like systems, Windows, and Java envronments; older versions exist for pre-OS-X Macs and other operating systems.
Smalltalk ["easy conversation"] The object-oriented, graphical Smalltalk development environment is what inspired Steve Jobs and later Bill Gates to "invent" the Mac OS and Windows interfaces. Focusing on the superficial aspects of it (windows and mice) they missed the real gem: the language.
Squeak [the sound a mouse makes] is a variant of SmallTalk, created by alumni of the Xerox PARC (where SmallTalk and the computer mouse were invented) and of Apple, who are now working at Disney (home of a famous mouse). It's a deliberately open system, with even the Squeak interpreter itself written in Squeak. This makes it highly portable (it's available for Mac OS, Windows (95 and later), WinCE, Unix-like systems, BeOS, OS/2, and RISC OS), and makes it possible for a programmer to modify the language itself. The interpreter, optional compiler, and everything else are free.
Eiffel [engineer Gustave Eiffel] is an object-oriented language available for Windows, Unix-like systems, and VMS.
Ruby [the birthstone for July (following "perl" for June)] combines some of the best features of several other languages, leaving behind many of their shortcomings. It's a pure object-oriented language like Smalltalk, but with clearer syntax (inspired by Eiffel). It has powerful text-handling like Perl, but is better structured and more consistent. It borrows ideas (but not the parentheses) from Lisp. Those who've tried it seem to love it, and rarely switch back to their previous languages. A free interpreter is available for Windows, Unix-like, Mac, OS/2, and BeOS systems.
Python [comedy troupe Monty Python] is an open-source, interpreted object-oriented language developed for Unix and now available for everything from DOS to Mac OS to OS/2 to Windows to Unix-like systems. It shares many positive attributes with Ruby, and adds the ability to run it on any machine that supports Java. It's often criticised, however, for not being as purely object-oriented as other languages.
M / MUMPS ["Massachusetts (General Hospital) Utility Multi-Programming System"] is a procedural, interpreted language, originally used for medical records (hence the cutsy acronym that many of its users are trying to get away from) and widely used where multiple users access the same databases simultaneously. It's inherently portable, as it stores all data in text format; text handling is one of its strengths. Its much-loved concision (commands can be a single letter) can make the code difficult for humans to read, however. Available in free and commercial versions for Windows, Unix-like systems, VMS, Mac OS, and others.
Macromedia Director and Flash are the de facto tools of choice for developing web sites featuring dynamic media. They're not really "languages", though both include a bit of their own scripting. Instead they're GUI development environments for producing "source code" modules containing both data and instructions, which can in turn be "compiled" into executable programs. As tools for creating snazzy graphical user interfaces, they are top-notch, but they require some separate back-end programming for anything that will require processing or manipulating data.
Similarly, Apple's HyperCard is a primarily visual tool, so different from regular development methods that "real" programmers have never taken it seriously, and even Apple has never figured out how how to market it (currently associating it with their QuickTime video technology). It's remarkably powerful, especially when used with the many extensions available for it. For example, it was good enough for the creators of Myst, one of the best-selling (and arguably best) computer games ever.
Rexx ["REstructured eXtended eXecutor language"] aims to control everything... or at least it offers to.
Perl ["Practical Extraction and Report Language"] is often treated as synonymous with "CGI scripting". In fact, Perl is even older than the Web itself; it got its nose into the Web-scripting tent and thrived due to its strong text-processing abilities, incredible flexibility (its creator likens it to duct tape), portability (it's available for nearly every modern operating system), and price (free). The Internet Movie Database and Yahoo both run on it.
TCL ["Tool Command Language", pronounced "tickle"] can interact well with text-based tools like the powerful editors, compilers, etc. found on Unix-like systems, and its TK extension gives it access to graphical interfaces like Windows, Mac OS, and X-windows, acting as "glue" to tie together standard components to accomplish complex tasks. This modular approach is the conceptual foundation on which Unix itself was based.
Pike [after... a fish] is yet another open-source, free language, invented through personal necessity, and now developed by Roxen Internet Software of Sweden. It's has strong data handling and object-oriented tools. Its syntax is similar to C, and can be extended to take advantage of compiled C libraries and modules to improve performance, available for most Unix-like systems.
Dylan ["DYnamic LANguage"] is "an advanced, object-oriented, dynamic language which supports the rapid development of programs."
Lisp ["LISt Processing"] is "a programmable programming language", built on the concept of recursion and highly adaptable to vague specifications. Avoid it if you find parentheses unappealing (its syntax tends toward a proliferation of nested parentheses), but its ability to handle problems that other languages cannot is one of the reasons this 40+-year-old language is still in use. There's an entire cross-platform web server written in it.
Scheme ["an organised plan"]
Logo is an educational language. It isn't just used to teach programming, but to teach. Full stop. The learning curve is shallow enough for even small children to get started quickly (giving instructions to the "turtle"), but it's powerful enough for an experienced user to do a great deal with it. It's derived from Lisp, but with a much simpler syntax. It is interactive and interpreted, which is part of what makes it such a good learning tool: immediate feedback allowing immediate adaptation. Various implementations are available for most modern (and not-so-modern) computers.
ToonTalk is a highly-visual environment designed to teach children the principles of programming. Rather than typing instructions, the programmer manipulates various objects (LEGO-looking toy items that come to life when used) to define how the system is supposed to work. Unlike "educational" puzzle-solving computer games, ToonTalk encourages its users to create their own puzzles. Experienced C++ programmers will hate it, but then, most 4th-graders wouldn't care for C++. :-) It's available for Windows only.
Other languages claim to be visual, but Prograph ["PROGRAmming GRAPHically"] is a truly visual programming language, in which the diagrams and flowcharts that describe what the program does are the program.
Prolog ["PROgramming in LOGic"] As an independent study project in college, I wrote a Prolog application which evaluated and proved (if possible) arguments in propositional logic (e.g. "A implies B, and A is true, therefor B is true") a task which would have been much more difficult using a procedural language.
Mercury [messenger god of the Greek pantheon]
Haskell [mathematician/logician Haskell Brooks Curry] is a functional language, meaning that it is used to describe what should be computed, not how to compute it. (Spreadsheets use a similar approach.)
O'Caml ["Objective Categorical Abstract Machine Language"]
COBOL ["COmmon Business-Oriented Language"] is the language modern programmers love to hate and ridicule. Although it is nearly as old as commercial computing itself, improperly blamed for Y2K issues, and its imminent extinction is frequently predicted, it is still in widespread use due to its usefulness for traditional business uses of processing data and producing reports. A version with object-oriented tools has even been created, with an inexpensive integrated development environment for Linux and Windows available. It is very verbose, designed so that its commands would describe in English exactly what it was doing. e.g. ADD SHIPPING-CHARGE TO INVOICE-SUBTOTAL
Fortran ["FORmula TRANslation"] is the oldest language still in general use, dating back to 1957, the year the Space Age began. It excels at the first task computers were called on for: number-crunching. This is the language that literally put a man on the moon, and some of the features it developed in the process of that project (and other less glamorous ones) have yet to be duplicated in other, more "modern" languages.
Erlang [mathematician Agner Erlang; also "ERicsson LANGuage"] was originally developed for use by telecom firm Ericsson, but has been released to the public as open source software. It's a low-level language in the sense that it allows the programmer to control things that are often left to the operating system, like memory management, concurrent processing, loading changes to the program while it's running, etc... all of which can be useful in programming small devices (like the ones Ericsson makes). compiled
REBOL ["Relative Expression-Based Object Language"]
Clarion
dBASE ["DataBASE"] (renamed "Xbase" to avoid trademark issues) was the command language for Ashton-Tate's ground-breaking database management program (the first such tool for microcomputers). As the program grew, so did the language, until it became an application development tool in its own right. At its zenith, various competing implementations and compilers were available and the language became standardised. Xbase didn't make the transition to Windows very well, but it's still being used and supported (kind of the COBOL of the microcomputer age).
Finally, there is one dead language that I feel deserves special recognition:
Plankalkül [German for "plan calculation"] is an under-recognised "first" of computing history: a high-level general-purpose programming language. It was formulated by German inventor Konrad Zuse to run on the "Z3" computer he'd designed (his third). This was during and immediately after World War II, more than a decade before FORTRAN came along, working alone without funding or academic support, and he got the system to play chess, no less. Much of his work was lost in Allied bombings, and with history being written by the victors... computing history has generally ignored him.
For a more extensive and detailed comparitive overview of programming languages, I recommend An Introduction to Programming Languages by Andrew Cooke. He's also written a "book review" that provides an introduction to the craft of programming written for a non-programmer audience.
More Options
Comments? Suggestions of other alternatives to include? Send them in, to "contact me at todd verbeek.com" (without the spaces)
All logos and product names are trademarks of their respective developers or distributors.
This site is in no way affiliated with Microsoft Corporation
© 1999-2006, Todd VerBeek.
______________________________________
Programming Languages
Alan Perlis once said: "A language that doesn't affect the way you think about programming, is not worth knowing".
Here are some opinions and facts about a selection of programming languages by Dr Mark Utting (a lecturer in the Department of Computer Science at The University of Waikato).
Topics within this page Object-Oriented Languages Documentation Generator Tools
Functional Languages Free Implementations
Logic Programming Languages Language Design Issues/Mistakes
Text Formatting Languages (TeX,HTML) XML-related Languages (XSLT etc.)
The Open Directory Project has lots of programming language information.
For examples of programming in 200+ different languages, check out Tim Robinson's 99 Bottles of Beer page. The Dylan version is nice, but make sure you check out all the C++ versions too! The template version is amazing!
More programming language comparisons, including employer demand, are available at http://www.pixeldate.com/dev /comparison/
Object-Oriented Languages
The Cetus Team maintains a large collection of links about most object-oriented languages.
Let us start with some lesser-known, but more novel, object-oriented languages, then work down to the well-known mainstream ones.
One of my favourite object-oriented languages is Cecil, by Craig Chambers. It is a multiple-dispatch language that supports both exploratory untyped programming and large-scale statically-typed programming. It includes some new and very expressive ideas (see the paper "Predicate Dispatching: A Unified Theory of Dispatch" by Michael Ernst, Craig Kaplan and Craig Chambers). Cecil is quite similar to the theoretical language that I developed in my PhD thesis.
An equally nice language is Dylan. Like Cecil, Dylan is a safe, strongly-typed, pure object-oriented language that supports multiple dispatch, modules, first-class functions etc. Dylan was originally designed by Andrew Shalit at Apple. There is a commercial implementation of it for Windows 95/NT platforms available from Functional Objects Inc., with a personal version available via free download. Free versions of Dylan for various UNIX machines are available from the Gywdion group. Other useful Dylan sites include:
the Introduction of Shalit's book, `The Dylan Reference Manual', gives an overview and rationale for Dylan;
Eric Kidd's 'Getting Started With Dylan' tutorial is the best online tutorial;
an A First Look at Dylan: Classes, Functions, and Modules an introductory article about Dylan from Apple (Steve Strassman);
Gwydion's 12 short example Dylan programs.
Paul Haahr's Procedural Programming in Dylan compares Pascal and Dylan versions of several simple functions. Section 3 introduces Dylan's support for higher-order functions in a gentle way. (His site also has a YACC grammar for Dylan, and an alternative multiple-inheritance linearization;
A small Dylan FAQ (Frequently Asked Questions).
The open directory project has lots of dylan links.
The Dylan Language Standard group is managing changes to the Dylan language.
The draft Dylan Reference Manual is available in PDF format (2Mb). A final version of this was published by Apple (via Addison-Wesley) in 1996, and is available at a special price from Functional Objects. There is also a nice browsable html version of it.
the Gywdion implementation of Dylan, started by the CMU Gwydion Group and being continued by volunteers (here is their mailing list archives). It is available for various machines
The Open Directory Project's Dylan page.
the Dylan Code Repository for reusable Dylan code.
Chris Double has written several example programs including one that displays .bmp files in a window.
Peter Norvig's slide presentation on Design Patterns in Dynamic Languages includes examples of patterns in Dylan, LISP, C++, Smalltalk and Sather.
A Dr. Dobbs Journal article on Dylan (by Tamme D. Bowen and Kelly M. Hall) which defines the semantics of the main Dylan features in Haskell!
This 1995 MacTech Magazine article (Vol 11, No. 8). includes a brief description and some screenshots of the original Apple Dylan Development Environment.
Miscellaneous old Dylan documents at the CMU AI repository.
Python is another favourite. Interpreted, and ideal for knocking up quick prototypes, but with a nice module system, lots of handy libraries, and almost purely object-oriented.
Apart from Simula-67, Smalltalk started the OO craze. Implementations are becoming more easily available now. (See also ObjectShare's non-commercial VisualWorks Smalltalk, available for Linux and Windows) Squeak is an open source Smalltalk that is becoming very popular. A lot of Smalltalk-related information and projects are accessible from the Panasoft Smalltalk Links. Here is a nice Smalltalk tutorial from IBM.
Some other clean OOLs are:
Scala is a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages. All Java classes can be imported and used within Scala programs.
Blue, a clean OOL especially designed for teaching first-year students.
Eiffel was the first object-oriented language to give good support for software engineering concepts like design by contract.
Modula-3
Oberon, from Nicolas Wirth, the designer of Pascal.
Sather
Component Pascal is an object oriented programming language most closely related to Oberon-2. Compared to Oberon-2 it adds a number of annotations which are intended to enhance the type-safety of component oriented programs. QUT offers an open source compiler which generates Java bytecodes or Microsoft.NET output. Alternatively, Oberon Microsystems have made their 'BlackBox Component Builder' compiler/environment for Component Pascal open source now.
TOM is a new object-oriented programming language that advocates unplanned reuse of code (classes can be extended in very flexible ways, even without source code for them).
Suneido is a free, open-source, pure-OO language whose syntax is similar to C++ or Java, but simpler. It is a safe, dynamic language like Smalltalk, enabling rapid development. It supports automatic garbage collection, exception handling and has builtin client-server relational database, user interface and reporting frameworks. Available for all Windows platforms, but a Linux version is planned.
D from Digital Mars is intended to be a clean successor to C++. It has good support for design-by-contract programming, like Eiffel.
How about a simple OO Forth? It takes less than one screenful of Forth to define objects, classes and single inheritance.
Then we have the less clean C extensions: Objective-C seems less widely used now, but is supported by gcc.
C++ is the most widely used object-oriented language. See: Readings, FAQS, ANSI Standard or here
A recommended book on the design of C++ is
"The Design and Evolution of C++", by Bjarne Stroustrup, Addison-Wesley, 1995.
I quite like the standard template library (STL) of C++ (local docs here). It allows higher-order programming to a certain extent and comes with about 10 generic data structures and 70 simple algorithms over them. See Mumit's STL Newbie guide for some handy STL hints. Other STL-like libraries include: the Graph Template Library (GTL).
There seem to be two major contenders for the "best GUI toolkit" title at the moment. GTK+ (the GIMP toolkit) is more C oriented, but does slots and signals without a preprocessor, whereas Qt uses a preprocessor (MOC) but has the dis/advantage of being a complete solution for porting to Windows 95/NT. The GTK+ toolkit has bindings for several languages, including a C++ wrapper for GTK+ called gtk-- (or FTP).
D is another object-oriented extension of C, designed for systems programming, but with garbage collection, runtime type identification and templates.
Of course, there is also Java which was designed to be safer and cleaner than C++ (see the Java white paper, a Java tutorial, Java Games and Java Puzzles).
[TODO: update this section, now that I've used Java for a few years.]
The two most attractive aspects of Java are that it can be a safe language (all errors are caught by the compiler or bytecode checker or cause runtime exceptions), and its portability (especially its wide range of standard libraries).
Some problems with Java that I've heard about include: hard to format a floating point number, integers etc. are not objects so cannot be subtyped or subranged, non-portable thread semantics, text I/O difficult for beginners. The lack of generics was a real pain in Java (lots of type casting), but now Java 5.0 has fixed this at last.
Here are several interesting extensions/variants of Java:
The Java Modelling Language, is Java extended with specification facilities (class invariants, preconditions, postconditions etc.); These can be added within comments, so that existing Java tools are unaffected, but the JML tools can perform deeper analysis of the program to detect more errors.
Jbed is a commercial real-time subset of Java that supports deadline-driven scheduling.
There are also quite a few other languages being implemented on top of the Java Virtual Machine, see here, here and here.
Objects have also been added onto Perl (Perl 4 was my least-liked language!) and Ada. In fact, Ada was actually the first ISO standardized OO language (Ada95)! A new ISO version of Ada, currently known as Ada200Y, will include Java-like interfaces and a larger predefined library etc.
Rational Software Corporation have done an interesting comparison between development in C and Ada.
Rational Software Corporation also sell Purify (a heap-memory checker) and are responsible for the OO Unified Modelling Language, which is now the industry standard for specifying the structure of OO systems.
Finally, CLU is an old but influential language that introduced important ideas for iterating through collection objects, for exception handling and a carefully-designed theory of object invariants, pre/post conditions etc.
The book Abstraction and Specification in Program Development, by Barbara Liskov and John Guttag, MIT Press, 1986. Here are some of my notes on the book.
A 1978 paper: A Critique of the Programming Language CLU by James Peterson. This also gives a brief overview of the language.
Here are some Software Engineering methods/tools for object-oriented programming:
Project Technology: Shlaer-Mellor methodology
ObjectTime: Real-Time Object-Oriented Modeling (ROOM)
Rational: Unified Method & Jacobson
See John Yeager's S/W Engineering resources for more information.
Functional Programming Languages
Haskell is the most popular functional programming language and is the one that I've used a lot (for example, my Z animator, Jaza). It is an elegant lazy high-level language, with fast compiled implementations plus a interpreter (HUGS) that is good for development. It also comes with a large collection of amazing libraries for writing parsers, pretty-printers, MIDI composition programmes (Haskore) etc., plus the ability to interface to arbitrary C procedures in a functionally clean way.
One of the advantages of Haskell is that expert programmers can extend the language by defining their own operators and 'monads', to get a very concise application-specific language. The disadvantage of this power is that if you overuse it, it becomes difficult for other people to read your programs!
Other popular functional programming languages include the eager (non-lazy) ML family of languages, such as Standard ML and Objective CAML. Here is an introductory book Objective CAML for Scientists.
Logic Programming Languages
There is a WWW virtual library for logic programming. Michael Ley has a database/logic programming bibliography The ALP (Association of Logic Programming) newsletter.
I am part of the Starlog research group, which is designing and implementing a new pure logic-programming language that is especially suited to reactive and real-time programming. Recently, I've implemented a version of Starlog for controlling Lego Robots!
Prolog is the most commonly known logic programming language, albeit impure. A few well-known implementations are: Quintus Prolog, SICStus Prolog, Eclipse Prolog, SWI Prolog (free!). Qu-Prolog is Prolog customised for formal methods (it handles quantifiers, object-variables and substitutions as primitives).
The Prolog at VIP is free for non-commercial use. Another free one is TRINC-Prolog. Michael D. Kersey recommends Amzi! Logic Explorer and the "Adventures in Prolog" (with a "very nice and complete tutorial"). See here for other free Prologs. [mindgap@my-dejanews.com, Alexander.Apostolovski@worldonline.be, and mkersey@metricom.com; comp.lang.prolog, 12Mar99.]
Roman Bartak's Interactive Prolog Guide includes FAQs, program samples, implementations, and references.
The BURKS project provides documentation and free Prolog implementations for DOS, Windows etc.
LPA Prolog for Windows -- with an IDE and single-step debugger -- offers a free 30-day trial. [Nov98]
Amzi! Logic Explorer is free for personal use. It comes with a full tutorial and sample programs, plus a GUI development environment. Amzi! inc. also offers a Prolog compiler and embeddable libraries (for C/C++, Java, Delphi, VB, etc) for a 90-day trial. [Dec98]
Mercury is an elegant, pure, logic programming language from Melbourne University. The fastest logic programming language around...
The Cetus Links OO Prolog page has links to object-oriented logic programming languages. Curry is an extension of Haskell that adds logic-programming features like logical variables, constraint solving and concurrent and distributed programming.
Here are some useful online sites for constraint logic programming:
The constraints archive;
Bartak's online constraint programming tutorial;
Tsang's 1993 book, Foundations of Constraint Satisfaction is out of print, but available from him via online order.
CLPGUI is an open-source Graphical User Interface for Constraint Logic Programming.
Not really CLP, but here is a useful site on good algorithms for solving numerical problems (numerical analysis books etc.).
The quarterly Logic Programming Newsletter is now online.
The textbook Logic, Programming and Prolog (2ed) by Ulf Nilsson and Jan Maluszynski is now available online. It covers theoretical aspects of logic programming as well as practical programming in Prolog, and extensions logic programming such as equational logic programming, constraint logic programming and query answering in deductive databases.
Text Formatting Languages
LaTeX is the defacto text formatting system for academic papers containing mathematics. There is lots of online reference material for it. See also the Comprehensive TeX Archive Network (CTAN). More documentation is here.
Basser Lout is another text formatting language that produces Postscript/PDF directly and has a more elegant (and functional!) programming/macro language than TeX.
For HTML (the web markup language):
The NCSA Beginner's Guide to HTML.
Ian Graham's guide to HTML.
An online quick reference card.
Tips on writing HTML files to reduce net load.
Peter Flynn's "How to write HTML".
Nelson Minar's html-helper-mode is an excellent macro package for writing writing HTML pages in Emacs. I use it with the table extensions by Joe Hildebrand.
Mag's HTML Resources Page.
Computist's Weekly (CW 10.07) recommends: ML Goodies, the HTML Web Board, the Really Big site, Index DOT HTML, Web Reference, HTML Guides Index and More HTML Guides.
XML-related Languages
The World Wide Web Consortium (W3C) is the official source for XML-related documents, and has lots of tools links.
ZVON.org has lots of XML-related tutorials and reference manuals, including an XML glossary, unicode character references a good reference for XSLT
Documentation Generators
There are lots of programs available for generating HTML and/or LaTeX documentation from C++ source files etc. For example:
Perceps is a Perl program that uses template files to generate very pretty looking HTML pages.
Doxygen generates crosslinked HTML pages in a style similar to the Qt documentation. It also handles the Signal/Slot declarations of Qt.
Free Implementations
A Catalog of Free Compilers and Interpreters.
Poplog is an open source, extendable, portable, multilanguage software development environment providing incremental compilers for several interactive programming languages: Pop-11, Prolog, Common Lisp, and Standard ML. It comes with documentation, libraries, and teaching materials for AI and Computer science (and more general programming).
Language Design Issues and Mistakes
Here are a few interesting papers about language design:
Go To Statement Considered Harmful (a classic, by Dijkstra)
Arrays and Pointers Considered Harmful, [Ince 92] D.C.INCE, ACM SigPlan Notices, January 1992.
Primitive Types Considered Harmful (why Java should be a pure OO language).
Interface Pointers Considered Harmful (About COM and C++, in The C++ Report, Sep 1995)
COM Smart Pointers Even More Harmful (A follow-up article in The C++ Report, Feb 1996)
An interesting comparison of language abstraction levels which showed that an almost functional language, CAML, was the best language for a large complex numerical simulation task.
Garbage collection is an important aspect of modern programming languages. Richard Jones's Garbage Collection Pages and Ravenbrook's Memory Management Reference are good resources for everyone interested in memory management and garbage collection.
Source Code
Sourcebank is a search engine for finding reusable source code, postscript papers about software, and articles in online programming journals.