As you can see, these fit into a surprisingly small time window, which I’ll call the Golden Age.** I wanted to make it a round decade, but had to include Common Lisp.

• C++ (1983)
• Common Lisp (1984)
• Erlang (1986)
• Haskell (1987)
• Perl (1987)
• Tcl (1988)
• Fortran90 (1991)
• Python (1991)
• Lua (1993)
• Ruby (1993)
• Java (1995)
• Javascript (1995)
• PHP (1995)
• OCaml (1996)

What’s happened since 1996? Not much, besides refinement and extension. It would seem that it takes a decade or two for a language to really stabilize and see wide adoption.* But why did the innovation come to a screeching halt in 1996?

Here is a sampling of some languages that are sprouting up this decade. Maybe you’ve heard of some of them. But adopted one? Not likely.

• Scala
• Co-Array Fortran (features merging into Fortran)
• Unified Parallel C
• Fortress
• Chapel (vaporware targeted for 2010)
• X10 (secret vaporware)
• ZPL (vaporware)
• Titanium (not even in Wikipedia, just a Java dialect)

What do all these have in common? They’re trying to tackle concurrency. But none of these have significant momentum (arguably Scala has some). It’s probably at least 10 years before any of these get major traction. Will any of these take off the way the languages of the Golden Age have? Or will we just keep extending mostly imperative languages (OpenMP, Threading Building Blocks, vendor-specific compiler directives, etc). Where does FP fit into all this? Will the functional languages see a resurgence based on their natural fitness for concurrency? That’s my bet.

Which of the Golden Age languages have the cleanest concurrency models? I’ll be exploring that question in future posts.

Why do I care about this? I simply want to use the best language for the job (another future post). But most jobs these days are needing to scale to multiple cores/machines (the “free lunch is over” horse is dead; I won’t belabor that here). Everyone is talking about this unaddressed barrier to writing parallel apps effectively, but most programmers have no solution in mind. A language with clean concurrency support is essential so that applications will scale well, with little effort, and be easy to write, quickly and correctly. Let’s discover some and let everybody know.

Notes: Some of these dates were hard to locate and may be inaccurate. You may disagree with my unspecified definition of interesting. Scheme and Smalltalk are worthy of mention, but they make the window too big. I’ve omitted any language from Microsoft: they generally don’t last; those that do (VB, C#) are an uninteresting commercial niche; and they are always brown cows. I won’t try to prove the “decade for adoption” theory, but you can go search for data on when Java started to supplant C++; and Python/Ruby might be starting to do the same to Java (even though Java is the younger).

Related articles:

• Some programming language history
• Language history graph
• Some concurrent programming languages
• Do we need another parallel programming language?
• Cray, IBM, Sun weigh in on language
• Joe Armstrong on Software for a Concurrent World (video)