Provenance

This page attempts to trace a bit of Elixir's intellectual history (roughly, provenance). Like most modern programming languages, Elixir is unabashedly eclectic. It borrows ideas and features from many sources, but Clojure, Erlang, Python, and Ruby are the major contributors.

Design Influences

This diagram digs a bit further into Elixir's design influences, per Wikipedia:

Contributed Features

It's interesting to consider which features were contributed (e.g., brought into a mainstream language) by each of Elixir's ancestors, e.g.:

Feature Support

This table attempts to show the level of support for specific language features in Elixir and its near ancestors.

Feature Ada AWK  C  Clo. Eif. Eli. Erl. Lisp Perl Pro. Pyt. Ruby Sed Sh Sma.
  .
  -
  +
  *
  .
  *
  * !
  .
  .
  .
  .
  +
  -
  .
  .
  .
  * !
  +
  *
  .
  *
  .
  +
  *
  .
  *
  *
  -
  .
  .
  .
  -
  +
  *
  .
  *
  *
  .
  .
  .
  .
  +
  -
  +
  .
  .
  -
  -
  +
  .
  *
  .
  .
  -
  .
  * !
  -
  -
  .
  .
  .
  +
  -
  *
  .
  *
  .
  *
  *
  .
  *
  *
  -
  -
  .
  .
  -
  +
  *
  .
  *
  *
  * !
  +
  .
  *
  +
  -
  -
  .
  .
  .
  .
  *
  *
  *
  *
  * !
  *
  .
  *
  *
  .
  .
  .
  .
  .
  -
  .
  .
  *
  .
  .
  *
  .
  *
  *
  -
  .
  .
  .
  -
  -
  * !
  .
  *
  * !
  .
  -
  .
  *
  *
  -
  .
  .
  .
  -
  -
  *
  .
  *
  .
  .
  -
  .
  *
  +
  -
  .
  .
  .
  -
  -
  +
  .
  *
  * !
  .
  -
  .
  .
  -
  -
  -
  .
  .
  -
  +
  *
  .
  *
  .
  .
  -
  .
  *
  +
  -
  .
  .
  .
  -
  -
  +
  *
  +
  .
  *
  +
  .
  *
  *
  -
  -
  * !
  .
  -
  -
  +
  .
  *
  *
  .
  +
  * !
  .
  .
  -
  .
  .
  .
  .
  .
  *
  *
  *
  *
  .
  .
  .
  .
  .
  .
  .
  .
  .
  -
  +
  *
  .
  *
  .
  .
  .
  .
  .
  -
  -
  * !
  .
  .
  -
  +
  .
  .
  *
  * !
  .
  .
  .
  -
  .
  -
  .
  .
  .
  -
  -
  *
  .
  *
  *
  * !
  +
  .
  *
  *
  -
  * !
  .
  .
  * !
  +
  *
  .
  *
  .
  *
  *
  .
  +
  *
  *
  .
  .
  .
  .
  .
  *
  .
  *
  .
  .
  *
  .
  .
  *
  .
  + !
  .
  .
  -
  -
  *
  *
  *
  .
  .
  .
  .
  .
  .
  -
  .
  .
  .
  .
  +
  *
  .
  *
  .
  .
  *
  .
  .
  *
  -
  * !
  .
  .
  -
  -
  *
  -
  *
  -
  * !
  -
  -
  -
  -
  -
  -
  -
system calls, etc.
  .
  -
  * !
  +
  .
  *
  .
  .
  *
  .
  .
  *
  -
  -
  .
  .
  .
  .
  .
  .
  *
  *
  * !
  .
  .
  .
  .
  .
  .
  .

Notes

Several feature categories are intentionally fuzzy, e.g.:

  • Clojure's static type-checking (i.e., Typed Clojure) is different than that provided by Elixir (i.e, @spec), let alone by Eiffel, etc.

  • Clojure, Elixir, and Erlang don't support lazy evaluation per se, but they have lazy data structures.

Acknowledgements: Filling in this table is too big a job for little old me. Thanks to Mike Meyer for helping out; anyone else out there wanna get their name in lights?

Legend

Abbreviations:

Clo. (Clojure), Eif. (Eiffel), Eli. (Elixir), Erl. (Erlang), Pro. (Prolog), Pyt. (Python), Sma. (Smalltalk)

Cell Values:
    -    no support
    +    weak support (e.g., incomplete, inconvenient)
    *    strong support (e.g., complete, convenient)
    !    contributed (e.g., introduced the feature)
    .    TBD (Help!)


This wiki page is maintained by Rich Morin, an independent consultant specializing in software design, development, and documentation. Please feel free to email comments, inquiries, suggestions, etc!

Topic revision: r12 - 13 Mar 2015, RichMorin
This site is powered by Foswiki Copyright © by the contributing authors. All material on this wiki is the property of the contributing authors.
Foswiki version v2.1.6, Release Foswiki-2.1.6, Plugin API version 2.4
Ideas, requests, problems regarding CFCL Wiki? Send us email