A Functional Programming Influence Graph
With the help of Twitter friends1 I developed a directed graph of traditionally functional programming languages and their influences on one another. The latest version is as follows:
View different sizes | View the Graphviz Dot source | Discuss on Hacker News
note: Ovals represent languages, hexagons are “ideas”, and blue boxes represent language families represented by an ideal implementation. This is not meant to be comprehensive at the leaves, but I would like it to be so at the inner nodes and roots.
Take a look and let me know what you think. The graph is not entirely complete, but the main connections are in place. Suggestions welcomed — including (and preferably with) references. I will update the source and graph periodically.
:F
-
This has been my most positive Twitter experience by far. ↩
34 Comments, Comment or Ping
Don Stewart
A couple of missing links, according to the Haskell 98 Language Report and the History of Haskell paper,
SASL -> Haskell
http://www.iro.umontreal.ca/~monnier/2035/history.pdf
Missing Curry
May 2nd, 2012
Don Stewart
One other one, GADTs just entered OCaml, so there is a Haskell -> OCaml line (after all this time!)
May 2nd, 2012
fogus
@dons Thank you very much. The files have been updated.
May 2nd, 2012
Foo
Lisp hasn’t been capitalized into “LISP” for over fifty years now. It’s “Lisp”. And there’s no such thing as “CommonLisp”. It’s “Common Lisp”.
May 2nd, 2012
Wes McKinney
What about modern APL variants (J, Q)?
May 2nd, 2012
solussd
Neat, but how is LISP influenced by FORTRAN? My understanding is they [LISP, FORTRAN] are the roots of the abstraction/functional vs. “efficiency* is king”/imperative dichotomy. Everything else falls somewhere in-between.
*now we know we can bake the cake, and eat it too. :)
May 2nd, 2012
fogus
@Foo The tag LISP in that graph represents a family of languages. To split into the various Lisps would overwhelm that image.
May 2nd, 2012
fogus
@McKinney APL and its relatives are subsumed in the APL rectangle. Rectangles represent a family and therefore a different graph.
May 2nd, 2012
fogus
@solussd Fortran’s influence on LISP is well documented. I suggest reading up on McCarthy’s early list experiments with Fortran and also the work of Nathaniel Rochester and Herbert Gelernter.
May 2nd, 2012
zerology
If you find time to massively enhance this graph :) – one direction to do so would be the labeling of the edges: What features, ideas or principles have been taken.
In the picture I envision, a language is the set of its features. So some languages introduce new ones, some bring in a new mix. (Most do both, of course.)
(It would even make a weight of the edges possible – how many features have been taken from a parent.)
Thanks for the pic!
May 2nd, 2012
fogus
@zerology I will enhance this graph and supporting source over time.
May 2nd, 2012
egery
Oz is missing, you’ll miss Oz ! Multi-paradigms done right.
By the way, here is a much more informative graph : http://www.info.ucl.ac.be/~pvr/paradigms.html
The associated article is brillant, too. And I can’t recommand CTMCP book enough. Kind of a state of the art version of SICP !
May 2nd, 2012
fogus
Oz is there… it’s just hiding in the Planner box. ;-)
May 2nd, 2012
Xah Lee
there should be a line from lisp to Mathematica.
May 2nd, 2012
Xah Lee
one question i wondered about is where does Mathematica’s pattern matching originated, or more generally, what are the first few lang that’s heavy pattern matching?
May 2nd, 2012
dear god it's hideous
help? you need xanax.
May 2nd, 2012
Don Stewart
@Xah Lee – In the early 70’s, Rod Burstall and John Darlington were doing program transformation in a first order functional language with function definition by pattern matching, which later Turner combined with ISWIM to yield SASL, a true pattern-matching FP language in the style of ML and Haskell today — http://www.iro.umontreal.ca/~monnier/2035/history.pdf
May 2nd, 2012
Rasm
The only language you need is PHP.
May 2nd, 2012
Kevembuangga
WHAAAAAAAT? No COBOL? It’s Turing complete too, so you COULD write your own functional primitives…
May 2nd, 2012
Tom
Do you have plans to add Ruby to this graph? If not, why?
May 2nd, 2012
strangemonad
Hmm given system F is there… would it make sense to overlay the dimension of formal systems and their calculi?
In particular, the lambda-calculus, f-exprs and McCarthy’s recursive functions + symbolic expressions: http://www-formal.stanford.edu/jmc/recursive/recursive.html, System FC, Kernel (http://web.cs.wpi.edu/~jshutt/kernel.html), combinatory logic
shawn
p.s. @fogus, if you haven’t already, read Shutt’s PhD thesis that led to Kernel:
May 2nd, 2012
Mike
Your graph gives the impression that Lisp and ALGOL are descendants of FORTRAN. That may be correct chronologically, but not in terms of founding abstractions.
FORTRAN originated as a formula translator for computing answers to engineering problems.
COBOL – which is missing – originated by abstracting business forms and business data processing
ALGOL – as far as I know – was developed for expressing algorithms. As such it included recursion and block structures as fundamental techniques. Subroutines were still expensive, but I believe they were used more prolifically than in FORTRAN.
Lisp’s fundamental abstraction is a function to the point where functions are a fundamental data type in Lisp. This is markedly different from FORTRAN, where the fundamental data types are numbers: floating point, integer, and arrays of the same.
I think redrawing the graph along the lines of where programming concepts originated would be an interesting and enlightening exercise
May 2nd, 2012
fogus
@Mike This is an influence graph, not an ancestry. I do agree that a graph as you describe would be very nice.
May 2nd, 2012
Craig
Interesting, I’m thinking a bot that scoured Wikipedia’s programming language pages for influenced and influenced by may create a more complete graph, and be more useful if it were interactive and let users note how languages actually influenced one another. Just a thought…
May 2nd, 2012
slack
maybe I’m wrong but CSP is connected with erlang.
Shouldn’t that be Erlang-Actor?
May 2nd, 2012
TerraHertz
There are many people who are unfamiliar with most of these languages, but still interested in learning. Myself included.
To make the graph more useful to non-experts, how about linking a short summary of the nature of each ‘influence’ line, to the lines? Nothing fancy, just number the lines and have an associated page of text for the entire thing. With numbered sections.
Much more work, I know. But at the moment it’s just lines. Not very meaningful.
May 2nd, 2012
Roridge
Groovy?
May 3rd, 2012
tofupup
maybe i am missing something but how is that clojure influences scala? Scala appeared around 2003 (wiki) and clojure apppeared around 2007 (wiki).
May 3rd, 2012
Tony Arcieri
Ditto on Erlang and actors… they should definitely be connected.
May 3rd, 2012
fogus
@Arcieri Weird, I thought I had that connection. Maybe I dropped it in a revision.
May 3rd, 2012
dodgy_coder
You’ve really got to take out FORTRAN from the top ‘king’ position there – that language is as much ‘functional’ as is BASIC. Definitely doesn’t belong there. Makes the whole graph look totally wrong.
May 4th, 2012
Ian McCallum
It would be interesting to see where NewtonScript falls out. I suspect it was influenced (based on it’s syntax) by SmallTalk, but also had some Lisp-like elements (first order functions), etc.
May 4th, 2012
Devin Walters
@tofupup,
Scala 2.8 adopted Clojure’s persistent data structures.
May 5th, 2012
Johann Visagie
Another programming language influence graph (not limited to fp) which was posted to reddit today:
http://griffsgraphs.com/2012/07/01/programming-languages-influences/
Jul 9th, 2012
Reply to “A Functional Programming Influence Graph”