The Woodshed

Behind here, no one can hear you scream

The Shebangs Go Marching In

A reflection on PL evolution

A little “thinking out loud” here, as I do some introductory delving into Rust, a language backed by Mozilla (still pre-1.0, but looks interesting). I’ve played around with a lot of languages at this point, new and old, and it’s always interesting to see what they bring to the table.

Of course, it’s a given that language features are ultimately of minor importance in the scheme of things. Business decisions in this regard are made on a bunch of external factors that honestly couldn’t be further from having anything to do with the language itself. (Examples include: abundance of X-programmers in the workforce, platform considerations, availability of professional tooling/support, and raw years-in-existence.) In fact, language features aren’t even generally among the secondary tier of considerations (i.e. quantity/quality of available third-party libraries, capability of bridging to language Y, interface support (web/GUI/OS scripting etc.), community/ecosystem, etc.)

But business considerations are incredibly dull to talk about, unless you’re the one making them. They are also tangential to the evolution of programming languages in general, and this is a good thing: when a “niche” language makes strides in usability, safety, etc., these things can (at least in part) be “backported” to mainstream languages (compare mainstream language support for first-class functions now vs. 10 years ago, for example).

But enough rhetoric. I wanted to jot down languages I’ve used/explored (defined as, written some amount of code in, even if the project in question went unfinished) in approximate order of “evolvedness” (defined as, informed usability improvements on previous languages in their particular vein). I’ll split them into “tiers” of 4, for no particular reason. When multiple languages share a rank, it’s not necessarily because they are similar.

Tier 1

Pure metal.

  1. Machine-specific assembly
  2. Machine-independent VM bytecode (.NET IL, LLVM, JVM)
  3. Forth
  4. C

Tier 2

Metallic and/or crazy.

  1. BASIC and friends
  2. Unix shells
  3. C++
  4. Objective-C, Ada

Tier 3

Anything goes.

  1. Delphi, Visual Basic (non .NET)
  2. JavaScript
  3. Scheme, Lua
  4. Perl, Erlang

Tier 4

Let’s redo others, but better.

  1. PHP (≈5.2; older versions would be at least a tier lower)
  2. Java, Go
  3. Python, Ruby, Factor
  4. C# (and Visual Basic.NET), D

Tier 5

Innovators or well-designed hybrids.

  1. Common Lisp
  2. Clojure, OCaml, Swift
  3. F#, Scala
  4. Haskell, Rust, Racket