An Essay on the Evolution of Programming Languages.

Disclaimers:

A while back I saw something, I’ve forgotten where, that essay comes from the root ‘to explore.’ That is the sense I’m using it in; don’t quote me as an authority on any of this, I’m making most of it up.

Virtually all of the ‘facts’ referenced here come from a programming language lineage chart by Eric Levenez (http://www.levenez.com/) and I have not independently verified them.)

A while back, (I think from lambda_ultimate) I read an article by Paul Graham suggesting that the computer languages of the future would probably be based on the historically most fruitful lines of ancestry. So, remembering the aforementioned lineage chart, which I had downloaded several months earlier, I printed it out, taped it to the wall, and pulled out the colored pencils. This what that exercise suggests:

The vast majority of active programming languages have, somewhere in their ancestry, one or both of Lisp or Fortran. Interestingly, both of these come from mathematics (Fortran comes from FORmula TRANslation; Lisp is partially based on the lambda abstraction, and comes from a theoretical exercise by McCarthy)

Fortran is the grand-daddy of the procedural style of programming. It was originally a thin shell on top of assembly language designed to make writing formulas easier. It has been blamed for the distinction between expressions and statements in most modern programming languages.

Lisp, it must be disclaimed, is the baby of Paul Graham, the author of the article that incised my essay. He cites a number of good reasons; features that have tended to leak into other languages along with proclamations of powerful new capabilities. (And a few that haven’t leaked into very many languages yet.)

Yet, according to the lineage map, Fortran is more successful. Almost every modern language trances it’s history back to Fortran somewhere. Fortran, C/C++, Delphi, Python, Perl, and PHP can be traced back, on the chart, to Fortran, but not to Lisp.

Lisp, while it has co-influenced a lot of languages (C#, Java, Objective-C, Ruby, Self, Scheme, Haskell) only has one active ‘pure’ descendant: Common Lisp itself. And most of the influence comes from two of Lisp’s descendants, Smalltalk and Scheme, both of which ‘corrupted’ it with Fortran influence.

There are a few other isolated lineage lines (Rexx, Forth, Cobol, Snobol, Basic, ML, to name a few) but it is fairly interesting how much of the graph one can color with just two pencils. I guess the conclusion is that while Lisp does have some good features, people really want to translate formulas.

Posted Saturday, April 26th, 2003 under Essay.

Tags:

Comments are closed.