The End of Moore’s Law

For the last few years (since 2009), I’ve been pitching the idea to my peers that language speed & concurrency/parallel capabilities will become more important as CPU clock speeds plateau and manufacturers add more CPU cores instead of advancing clock rates. My 2+ year old Macbook Pro has 4 cores and 8 hyperthreads.

I, and many of my peers, program primarily in Ruby which is one of the slowest languages, but is also one of the most productive. Even though Ruby is often on the critical path (as opposed to the database, network, ec.), with caching provided by Rails, more server resources, client side processing with JavaScript, etc., the productivity of Ruby has thus far outweighed the slowness disadvantage (enter mantra “hardware is cheaper than developers”), so I haven’t received much (any?) buy in from the programmers I hang with.

Programmer productivity will continue to be important, but the question that I’ve been considering has been, “What if a language provides the same productivity as Ruby, but much better resource efficiency?”

The minimum bar for efficiency is fuzzy & variable, but I’ve nonetheless discounted any language below that bar. Except for R which would be a special purpose language for me, I’m not considering any language below the Racket/Clojure level of efficiency for the future, and ideally the language has a good concurrency/parallelism story.

Clojure

“A Lisp for Functional Programming symbiotic with an established Platform designed for Concurrency.”

Reasons for interest:

• A lisp
• Macros
• Functional programming
• Concurrency
• Efficiency
• Concision
• Clojurescript
• Community

Common Lisp

“Common Lisp is a general-purpose, multi-paradigm programming language. It supports a combination of procedural, functional, and object-oriented programming paradigms. As a dynamic programming language, it facilitates evolutionary and incremental software development, with iterative compilation into efficient run-time programs.”

Reasons for interest:

• A lisp
• Macros
• Multi-paradigm
• Efficiency
• Huge standard library

Go

“Go is an open source programming environment that makes it easy to build simple, reliable, and efficient software.”

Reasons for interest:

• C replacement
• Efficiency
• Concurrency
• Systems programming
• Concision

Haskell

“Haskell is an advanced purely-functional programming language. An open-source product of more than twenty years of cutting-edge research, it allows rapid development of robust, concise, correct software. With strong support for integration with other languages, built-in concurrency and parallelism, debuggers, profilers, rich libraries and an active community, Haskell makes it easier to produce flexible, maintainable, high-quality software.”

Reasons for interest:

• Functional programming
• Concision
• Purity
• Advanced type system
• Parallelism & concurrency
• Efficiency
• Monads
• Community

J

“J is a modern, high-level, general-purpose, high-performance programming language. J is particularly strong in the mathematical, statistical, and logical analysis of data.”

Reasons for interest:

• APL-like power with a normal keyboard
• Array language
• Concision
• Big data

JavaScript

The language of the web.

Reasons for interest:

• Only game in town for browsers
• Compilation target for browsers

Prolog

“Prolog is a high-level programming language based on formal logic. Unlike traditional programming languages that are based on performing sequences of commands, Prolog is based on defining and then solving logical formulas. Prolog is sometimes called a declarative language or a rule-based language because its programs consist of a list of facts and rules. Prolog is used widely for artificial intelligence applications, particularly expert systems.”

Reasons for interest:

• Logic language
• A new paradigm
• AI

R

“R is a language and environment for statistical computing and graphics. It is a GNU project which is similar to the S language and environment which was developed at Bell Laboratories (formerly AT&T, now Lucent Technologies) by John Chambers and colleagues. R can be considered as a different implementation of S. There are some important differences, but much code written for S runs unaltered under R.”

Reasons for interest:

• Statistics
• Big data
• Extensive statistical/numerical library

Racket

“Racket (formerly named PLT Scheme) is a general purpose, multi-paradigm programming language in the Lisp/Scheme family. One of its design goals is to serve as a platform for language creation, design, and implementation. The language is used in a variety of contexts such as scripting, general-purpose programming, computer science education, and research.”

Reasons for interest:

• A lisp
• Functional programming
• Continuations
• Hygienic macros
• Concurrency
• Efficiency
• Built-in web server
• Concision
• Can be small & clean
• pg used it to implement Arc

Ruby

“Ruby is a language of careful balance. Its creator, Yukihiro “Matz” Matsumoto, blended parts of his favorite languages (Perl, Smalltalk, Eiffel, Ada, and Lisp) to form a new language that balanced functional programming with imperative programming.”

Reasons for interest:

• Joy to program
• Concision
• Rails
• Community
• Primary revenue generating language currently
• Dead slow, but lovable

Summary

I hope to decide on which of the three lisps I want to pursue, determine if J can supplant R, and see if Go can be replaced with one of the others, so that would leave six.

• Haskell
• J
• JavaScript
• A lisp
• Prolog
• Ruby

I’ve briefly researched Erlang, Factor, Lua, OCaml, Scala, Smalltalk & Standard ML. At the moment, I don’t feel they should replace any of the languages on the above list for subjective, practical and/or technical reasons, but if you’re excited about those languages, or others, comments are welcome.

Standard ML came close to bumping Haskell from the list, but despite the nicety of SML and the advocacy of Robert Harper, I felt the platforms (compilers, runtimes, libraries, etc.) were antiquated and dividing/conquering themselves, so I couldn’t trust them to advance quickly enough – particularly in the area of parallelism & concurrency.

Update 1/17/2014:

For a lower level language, I think the D language is a candidate to replace Go. For numerical & statistical computing, I think Julia is a candidate to replace R. Lastly, I think other Scheme languages that are candidates to replace Racket include Gambit, Bigloo and Chicken.

Update 5/27/2014:

My final list of languages to spend time in, in order of priority is:

1. Haskell, Racket & Common Lisp (concurrently)
2. Julia
3. J
4. Prolog

Notably absent are Clojure (replaced by Racket and Common Lisp), Go (other languages on the list are efficient enough), R (replaced by Julia), JavaScript & Ruby (I currently use them in my work).

Update 11/23/2020:

After an exhaustive search, Racket became my primary programming language in 2018.