or learn more

A Functional Programming Influence Graph

May 2, 2012

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.


  1. This has been my most positive Twitter experience by far. 

34 Comments, Comment or Ping

  1. A couple of missing links, according to the Haskell 98 Language Report and the History of Haskell paper,

  2. One other one, GADTs just entered OCaml, so there is a Haskell -> OCaml line (after all this time!)

  3. @dons Thank you very much. The files have been updated.

  4. 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”.

  5. What about modern APL variants (J, Q)?

  6. 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. :)

  7. @Foo The tag LISP in that graph represents a family of languages. To split into the various Lisps would overwhelm that image.

  8. @McKinney APL and its relatives are subsumed in the APL rectangle. Rectangles represent a family and therefore a different graph.

  9. @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.

  10. 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!

  11. @zerology I will enhance this graph and supporting source over time.

  12. Oz is missing, you’ll miss Oz ! Multi-paradigms done right.

    By the way, here is a much more informative graph :

    The associated article is brillant, too. And I can’t recommand CTMCP book enough. Kind of a state of the art version of SICP !

  13. Oz is there… it’s just hiding in the Planner box. ;-)

  14. there should be a line from lisp to Mathematica.

  15. 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?

  16. dear god it's hideous

    help? you need xanax.

  17. @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 —

  18. Rasm

    The only language you need is PHP.

  19. Kevembuangga

    WHAAAAAAAT? No COBOL? It’s Turing complete too, so you COULD write your own functional primitives…

  20. Tom

    Do you have plans to add Ruby to this graph? If not, why?

  21. 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:, System FC, Kernel (, combinatory logic


    p.s. @fogus, if you haven’t already, read Shutt’s PhD thesis that led to Kernel:

  22. 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

  23. @Mike This is an influence graph, not an ancestry. I do agree that a graph as you describe would be very nice.

  24. 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…

  25. slack

    maybe I’m wrong but CSP is connected with erlang.

    Shouldn’t that be Erlang-Actor?

  26. 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.

  27. Roridge


  28. maybe i am missing something but how is that clojure influences scala? Scala appeared around 2003 (wiki) and clojure apppeared around 2007 (wiki).

  29. Tony Arcieri

    Ditto on Erlang and actors… they should definitely be connected.

  30. @Arcieri Weird, I thought I had that connection. Maybe I dropped it in a revision.

  31. 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.

  32. 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.

  33. Devin Walters


    Scala 2.8 adopted Clojure’s persistent data structures.

  34. Johann Visagie

    Another programming language influence graph (not limited to fp) which was posted to reddit today:

Reply to “A Functional Programming Influence Graph”