These are the languages that I consider interesting* today. I’ve included their approximate year of first release. Also, a look at the importance of support for concurrency.
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)
Tags: functional, languages, optimization, parallel
How about Arc? The 100 year language.
http://arclanguage.org/
Processing looks really neat to me:
http://processing.org/
http://en.wikipedia.org/wiki/P....._language)
Actionscript, widly adopted language.
http://en.wikipedia.org/wiki/Actionscript
F# is Microsoft’s new .net functional language.
I’m not sure about these language’s attempt to tackle concurrency. I think most were designed for a specefic area. Like processing was made for quick visualization and was targeted towards students, artists, and designers.
This is a very common fallacy. Naive reasoning makes it seem that rate of invention of pretty much any kind is slowing down or even stopping completely.
It seems so because there is a long lag between time when something is invented and time when it becomes widely adopted, let’s say 10 years on average. And you’re trying to say nothing good was invented in the last 10 years by pointing that nothing invented in the last 10 years was adopted.
But by the way things are, languages invented 10-20 years ago were going to be adopted 0-10 years ago, and languages invented 0-10 years ago will be adopted in the next 10 years.
@taw — I certainly put a slant on this post, and ignored some details, to try and make some simple points:
1) ’83-96 was a remarkable window for starting/burgeoning of languages, many of which we have great affections for today. That’s what really prompted the post — I was thinking about the roots of Python, perl, and Erlang; and started to discover that every other interesting language in my own arsenal today is from this timeframe.
2) Like you say, it *usually* takes a while for a language to “grow up”. But I actually don’t see much promise from most of what’s sprouted since ’96 (though I should give some of them a chance).
So I waved my hands on the 10-year adoption point. In hindsight, it’s somewhat meaningless. To that point, in so many words I was trying to say that I don’t see any of the post-Golden Age languages catching on in this decade (though I see there is now a Scala book out that looks promising, and maybe a community forming).
Java especially blows my point. But it is the one exception I can think of that got immediate adoption; thanks to a marketing machine combined with academic adoption, it was widespread a mere year after inception. My alma mater (UofO) became a “Java School” back in 1996, IIRC.
The interesting question to me is still: how are we going to tackle concurrency, and it seems FP languages from the Golden Age might have a shot.
BTW, thanks for the comments, and for all the interesting content I’ve enjoyed on your blog over the years. (I like cats, too.)
@tim — I’m aware of Arc, and I have a lot of hope for anything PG is involved with, but last I checked it was still vaporware. As soon as I can say “apt-get install arc” I’ll be using it.
Actionscript probably deserves mention. I guess I was just considering it a Javascript evolution. Next decade when I do another post like this, I’m sure it will warrant mention as part of today’s generation.
F# I’ve heard a bit about. I just don’t really care about what is cooking inside M$. They’re always in “fast follower” mode, for very slow values of fast. AFAIAC, investing effort in any corporate language is always a waste of energy and money. Following their history, I’ve done well to avoid their proprietary clone-what’s-vogue MO: VJ++, Jscript, VB, C#, and countless others I’m sure. Another bad smell from Redmond is that you can’t pronounce anything they come up with; they’re all short on vowels (http://groups.google.com/group.....01ada194f2). If anything, I’m sure F# will be good for getting more people to discover the merits of Haskell, CL, OCaml, Erlang, etc, so in that regard I’m excited about it.
Thanks for pointing these out. They’re worthy of mention; I just didn’t dig real deep on current trends. Mostly just reminiscing on yesteryear.
Ahh, no commet on processing
I recommend checking it out. I think it has an interesting implementation, easy to use, and pretty instant feedback on getting neat deliverables.
I won’t question the accuracy of your dates, but you do seem to pick convenient ones: “first release” for defining your decade, and then “adopted” for excluding more recent languages.
For example, Python 0.9 was public in 1991, but it really wasn’t worth much at that point (and I say this as a Python programmer!). Scala today is much bigger than Python in 1991 was.
Also, I don’t see Common Lisp as terribly interesting (and I say this as a Common Lisp programmer!). It brought together east (Maclisp) and west (Interlisp), but was more politics than technical.
I agree with Spolsky (and others) that good software takes 10 years, so I don’t find it surprising you don’t see any hot new languages since 1996. Some of my friends rave about Io (2002) and Factor (2003), but they’re 10 years behind Ruby or Python.
Anyway, it’s neat to see what other people find interesting. If I had to pick a Golden Decade (plus a couple) of Programming Languages, I’d pick 1962-1972, which gave us Lisp 1.5 (1962), APL (1964), Algol 68 (1968), Smalltalk (b.1969), Prolog (1972), Forth (early 1970′s), and ML (1973).
I posit that _adoption_ has slowed down, due to the corporatization of the software development industry (and the network effects of scale). For the last ten years the state of language research has been so far ahead of adopted practise that further research has seemed pointless. Witness the recent effort that’s been diverted into migration attempts trying to make bite-sized features of 20-year-old languages available to developers still stuck in environments dependent on 30-year-old languages and practices.
@anonymous — Great point about adoption versus first release. The focus on first release, while hand-waving adoption, is what really enabled the small “window”. That would be a pretty interesting exercise to try and define the “tipping point” for each language. I wonder what Python’s was? 2001-ish with 2.2? Without referring to $20 IEEE papers on the subject, e.g., An empirical study of programming language trends (excludes Python and Ruby), I’ll conjecture that this decade was (or is becoming) the tipping point for Python and Ruby, whereas Java and Perl tipped a decade ago.
Thanks for mentioning lo and factor. On the former I couldn’t find much, but factor looks interesting — I’ll have to explore that a bit. Looks like it should release this year.
Your golden decade goes back a ways! Those appear to be the roots for everything we know today about FP. Good insight.
@greg — You bring up an important problem with your corporatization insight. The innovators don’t have the attention span to wait 20 years for their ideas to be propagated into mainstream. I’ve witnessed first-hand the pouring of money and creativity into shoe-horning concurrency into imperative languages: TBB, OpenMP, and lots of now-dead wasted pursuits. I’ve been talking to some people about how to widen that corporate scope to include more progressive languages.
It’s important to note that most of the languages you have listed are not now the same languages as they were at the dates which you provide. Every single one of them has evolved in one way or another.
While we are still inventing new languages, they are mostly rehashes of features from older. At the same time, as all of the languages you listed mature, they all seem to be converging on the same set of features. How long will it be before we end up with two or three groups of languages which are exactly the same but syntactically slightly different? What we really need is new innovation in programming language and IDE features.
I disagree with the usefulness of the corporate/non-corporate language distinction. Avoiding languages with corporate ties just because of that is fairly arbitrary. And if Java isn’t in the corporate category, then I wonder what the definition of “corporate” is. For that matter, even non-corporate languages have corporate support. Y’know who pays Guido, right? I acknowledge that avoiding lock-in and dependence on vendor tools, etc., are good reasons to go non-corporate. (I know that .Net compilers and runtimes are free, but the more useful editions of Visual Studio are emphatically not.)
By the way, current C# isn’t really an also-ran or clone now, if it ever was. Actually, Java keeps adding in C# features…
@Rickasaurus — Yes, always things being rehashed. @Anonymous above pointed out that his golden age was ’62-72, and that makes a lot of sense. I thought someone had said something like: “Every language eventually evolves to Lisp”. But I coulnd’t find it. It does seem to be a trend though. It seems status quo these days to try and mention something about itertools in any Python conversation. Here are some classic quotes I did find:
“I suppose I should learn Lisp, but it seems so foreign.” – Paul Graham, Nov 1983
Greenspun’s 10th Rule: “Any sufficiently complicated C or Fortran program contains an ad-hoc, informally-specified bug-ridden slow implementation of half of Common Lisp.”
REPLs in my mind are one of the greatest innovations of modern lanuages. I think that’s agreeing with your IDE point.
@art — The corporate distinction is still valid IMO. It’s what brings the whole discussion of CATB. It is a little hard to draw a fine line, of course. Java finally seems to be open source now, but much has been said already about that saga. Sure, Google/Sun/Ericsson and many more have poured resources into languages, but they’ve done it in a way so that proper open communities can thrive. I understand *lots* of people swim in the seas that are Microsoft programming languages, but a huge mass of developers will always avoid that opaque and discolored water (which I won’t get into right now, but maybe I’ll express my personal reasons in a future post).
There is also the matter of “controlling body”, which further muddies the distinction. With a BDFL (e.g., Guido, Mats, Joe Armstrong?), there is not the same corporate pressure in shaping the language. Design by committee has plagued Sun-Java for years, and corporate design MS maybe to a worse extent.
I really don’t consider the MS languages alsorans; more like just uninteresting. I don’t even know the magnitude of their following, though it’s obviously massive. It seems what they’ve created have been wildly successful in “the enterprise”, but that’s just not very interesting to me.
So there doesn’t appear to be a clear concensus that a corporately controlled language will evolve toward either extinction or openness, but it would seem that a BDFL arrangement has a lot of merit. I’m talking over my head now, so I’ll have to look into this a bit more.
Nice blog, BTW.
If you’re interested in new languages that are cool try Nemerle. I find it delivering what OCaml merely promised – good object-oriented/functional hybrid language. Or Arc. Or RLisp. Or e7.
If you’re interested in new languages that are widely adopted there’s obviously C#.
If you want both at the same time, well there were few such languages ever.
I would say the Golden Age was the 70′s with:
Pascal (1970)
Forth (1970)
C (1972)
Smalltalk (1972)
Prolog (1972)
ML (1973)
Scheme (1975)
SQL (1978)
VISICALC (1978)
While these languages aren’t so ‘cool’ today, collectively they still shape almost all current programming language trends.
The languages listed in the above article are, for the most part, refinements and convenient repackagings of the breakthroughs introduced by the 70′s languages.
P.S. You could almost hone it down to the 1972 – 1975 period with C, Smalltalk, Prolog, ML, and Scheme.
Thanks for your addition, David. I agree, that’s a pretty important period. I love the graphical tree here for visualizing the clusters.
Despite it being in the cluster, I notice you left ANSI COBOL out of your group
I’m inclined to date COBOL at the first implementation in 1960.
There is one language that’s seen widespread adoption that was first codified in this decade: C# (2001).
Actually, the true "Golden Age of Programming Languages" may have been the first five years starting with FORTRAN I in 1957. That gets you FORTRAN II and almost FORTRAN IV, Algol 58 and Algol 60, Lisp 1 and 1.5, RPG I and II and COBOL 60. I think SNOBOL IV is also in there, but it may be later.
If you extend the period to ten years, you pick up FORTRAN IV, which was probably the first "mature" FORTRAN, SNOBOL IV for sure, SIMULA, PL/I and APL.