or learn more

Programming language development: the past 5 years

Oct 18, 2011

I recently compiled a list of Perlis Languages that were meant to illustrate varying paradigms not typically found in mainstream programming languages. Those languages were meant to stretch your mind and are not necessarily representative of the state of the art in language design and implementation. In this post I will provide a list of fairly new languages (let’s say 5 years with a little flex) that display1 interesting features and display higher-order thinking in the way that they tend toward an evolution of past learnings in programming language thinking. Not all of these languages enjoy active development, but the more important point is that they represent in some way “new language thinking”. Remember that this goal does not necessarily mean “innovative”.

Unlike my Perlis post, I have not fully explored all of the languages below, so caveat emptor. Please correct me if I misrepresent something. No meaning behind the ordering implied.

take the associated poll!


released: 2011, author: Dr. Mark Tarver

I included the fantastic language Qi in my Perlis Languages post, so it may seem gratuitous to include its successor Shen here. In fact Shen and Qi offer most of (all of?) the same high-level features:

  • A Lisp
  • Optional static typing
  • Pattern matching with guards
  • Macros
  • Partial application
  • Function backtracking
  • Builtin Prolog
  • Builtin compiler compiler

However, Shen is indeed the next evolutionary step after Qi. Shen builds on the ideas in Qi in various ways, but the primary motivating force is targetability. What exactly does that mean? The precursor Qi was built to target Common Lisp as its host language and did so to maximum effect. However, Qi was found to target a very small subset of Common Lisp. Therefore, Dr. Tarver devised the idea that the successor Shen should be defined in terms of a minimal kernel Lisp language called Kl which would, in theory, provide an easier port target across various runtime hosts, including, but not limited to: JavaScript, Python, Clojure, and Common Lisp. I have been thinking of “kernel Lisps” a lot and so Shen is ripe with ideas.

An example of a member function using the embedded Prolog:

(defprolog member
  X [X | _] <--;
  X [_ | Y] <-- (member X Y);)

(prolog? (member 1 [1 2 3]))
/*=> true */

Partial application is automatic (simplified below):

(* 2)
/*=> #<FUNCTION LAMBDA (x) (* 2 x)>

((* 2) 54)
/*=> 108 */

Here is a function that calculates the nth triangle number:

(define triangle
  0 -> 0
  N -> (+ N (triangle (- N 1))))

(triangle 100)
/*=> 5050 */

And a typed version of the same:

(tc +)  /* turn on type-checking */

(define triangle
  {number --> number}
  0 -> 0
  N -> (+ N (triangle (- N 1))))

(triangle 5)
/*=> 15 : number */

(triangle a)    
/* type error */

Shen is a natural evolutionary step along the long, winding path that is Lisp history. Many modern programming languages are absorbing features that Lisp innovated long ago, but still the most exciting languages are Lisps.

More resources

Agda 2

released: 2009, author: Ulf Norel

I’ve yet to truly wrap my head around Agda (any year now), but I can say a few things about it. First, Agda is a purely functional, pattern matching, dependently typed programming language that walks the thin border adjacent to proof assistants. In dependently typed languages, type expressions can contain (depend on) a program expression. Therefore, the resolution of type constraints is a function of code or predicated on values. It’s like a kick in the face. As an added bonus, the Agda type language is the same as the value language (i.e. the programming language itself). What this means is that type invariants in Agda can express a much wider spectrum of constraints than typically attributed to static type systems; for example, a list type that statically guarantees sorted order (PDF). There’s a drop-kick for you.

Here is an encoding of even and odd numbers in the Agda type system:

data Nat : Set where
  zero : Nat
  suc  : Nat -> Nat

fortyTwo : Nat
fortyTwo = 42

plus : Nat -> Nat -> Nat
plus  zero   m = m
plus (suc n) m = suc (plus n m)

  even : Nat -> Bool
  even zero    = true
  even (suc n) = odd n

  odd : Nat -> Bool
  odd zero    = false
  odd (suc n) = even n

The previous code defines two datatypes: 1) the natural numbers and 2) the even natural numbers. You can also define type functions as infix operators:

_+_ : Nat -> Nat -> Nat
zero  + m = m
suc n + m = suc (n + m)

This represents the extent of my understanding about Agda so far. While it would be nice to know more, what I’ve seen is amazing enough to warrant inclusion.

More resources


released: 2008, author: Ola Bini

Ola Bini’s Ioke is based on a simple question: what kind of language can you build if you completely disregard performance and instead focus on expressivity?2 As it turns out you gain incredible expressiveness as shown in Bini’s presentation series (links below). One of the more interesting aspects of Ioke is that it is a homoiconic language providing macros.

myfor = dsyntax(
"takes a name, an enumerable, and a transforming expr
and returns the result of transforming each entry in 
expression, with the current value of the enumerable
bound to the name given as the first argument",

  [argName, enumerable, argCode]

  ''(`enumerable map(`argName, `argCode))

myfor(x, 1..5, x*2) 
;=> [2,4,6,8,10]

Another advantage in studying Ioke is my own personal first axiom:

When brilliant people create things, study them.

As programmers the onus is on us to push our skills to the point of uncomfortableness. Studying the works of great minds is a highly effective way to do this.

More resources


released: 2008, author: Albert Gräf

Pure is a functional language built around term rewriting. Term rewriting is very similar to what we did in high-school algebra using the FOIL method:

(x1 + y1) * (x2 + y2) = 
  (x1 * x2) +            // First
  (x1 * y2) +            // Outer 
  (y1 * x2) +            // Inner 
  (y1 * y2);             // Last

The code above defines the steps needles to transform the multiplication of two binomials into the FOIL steps. Testing this rewrite rule yields:

(x + 3) * (x + 5);
//=> x*x+x*5+3*x+15

Now you might expect that the answer would be x^2 + 8*x + 15, but there are missing reductions in the definition:

x*x = x^2;

(x + 3) * (x + 5);
//=> x^2+x*5+3*x+15

That is close enough for me. :-)

A more complex example would be a function to reduce a number to its prime factors:

factor n = factor 2 n with
  factor k n = k : factor k (n div k) if n mod k == 0;
         = if n>1 then [n] else [] if k*k>n;
         = factor (k+1) n if k==2;
         = factor (k+2) n otherwise;

factor 138;
//=> [2,3,23]

Of the languages listed in this post, I am most blown away lately by Pure.

More resources


released: 2009, authors: Robert Griesemer, Rob Pike, and Ken Thompson

I have gone back and forth on including Go into the mix because I have had a strong negative reaction against it so far. However, people seem to be excited about the possibilities of a new systems-level programming language, so I felt that it was a shame to exclude it because of my own prejudices.

Here is an example of run-length encoding in Go:

package main

import (

var order = 4
var grain = "*"

func main() {
    t := []string{grain + strings.Repeat(" ", len([]int(grain)))}
    for ; order > 0; order-- {
        sp := strings.Repeat(" ", len([]int(t[0]))/2)
        top := make([]string, len(t))
        for i, s := range t {
            top[i] = sp + s + sp
            t[i] += s
        t = append(top, t...)
    for _, r := range t {

The world needs more options for system-level programming and it’s virtuous on its own that Go targets that space.

More resources


released: 2008, authors: Paul Graham and Robert Morris

It’s hard to believe that Arc is only 3 years old (by release date). I suppose its “oldness” is a function of the countless hours that I spent reading Graham’s posts about it. The world was excited about Arc before its release and unfortunately many opinions on it range from disappointed to outright angry. I too really wanted to like it, but feel far short of the feelings of vitriol that some have maintained. I imagine that if Clojure, Racket, and Qi had not been invented then I probably would have willingly taken the Arc plunge. I will say that its core tenet “succinctness is power” really resonates with me. More than the language itself (which succeeds in this maxim only partially), it’s the core philosophy that stands strong. The world was introduced to Arc through Paul Graham’s “Arc challenge”, partially quoted as:

Write a program that causes the url said (e.g. http://localhost:port/said) to produce a page with an input field and a submit button. When the submit button is pressed, that should produce a second page with a single link saying “click here.” When that is clicked it should lead to a third page that says “you said: …” where … is whatever the user typed in the original input field.

And Arc’s solution was/is thus:

(defop said req
  (aform [w/link (pr "you said: " (arg _ "foo"))
           (pr "click here")]
    (input "foo") 

A side effect of studying Arc is that one can explore the fantastic Racket language. This is my way to cheat and get a shout out to Racket3 in this post.

More resources


released: 2009, author: Jeremy Ashkenas

I find Jeremy Ashkenas to be an extremely bright programmer with some philosophies that align with my own. As an added bonus, CoffeeScript is one of the few languages on this list that I’ve used in my professional life. The syntax is fairly clean and unceremonious, but its greatest strength (and some might say weakness) is that it’s a very thin skin on top of JavaScript. CoffeeScript is indeed Crockford’s “The Good Parts” manifest, with much better syntax.

One of the interesting features of CoffeeScript is that it provides a very light weight JSON syntax:

jsn = 
  foo: 'a'
  bar: 'b'
#=> 'b'

That in turn facilitates a lightweight object syntax:

sanders = 
  speed: 8
  juke: 10
  report: -> "#{@speed} and #{@juke}";
#=> '8 and 10'

There are also list comprehensions:

transpose = (matrix) ->
    (t[i] for t in matrix) for i of matrix[0]

transpose [[1,2,3],[4,5,6]]

//=> [[1,4],[2,5],[3,6]]

For better or worse4 CoffeeScript provides class-based modeling:

class Animal
  constructor: (voice) ->
    @voice = voice

  speak: =>

class Dog extends Animal
  constructor: ->

d = new Dog
#=> 'ruff!!'

CoffeeScript is in no way the first language targeting JavaScript, but it has provided the perfect storm of adoption, support, and excitement proving its approach as viable to a much larger population. Equally important is that CoffeeScript is blazing the trail in how a symbiotic language can interoperate with existing JavaScript libraries and frameworks.

More resources


released: 2009, author: _why the Lucky Stiff

There was a guy named _why the Lucky Stiff who set the Ruby world on fire. While an enigmatic bloke, his thoughts on Ruby and programming in general were held in high regard by the Ruby community and in some cases the larger programming world. An epic open source contributor was _why and one of his many open source projects was an attempt at a tiny, yet powerful, programming language called Potion. Potion is very much in the Io, Lua, OCaml, and Ruby genre:

Person = class: /name, /age, /sex.
Policeman = Person class (rank): /rank = rank.
Policeman print = ():
  ("My name is ", /name, " and I'm a ", /rank, ".") 
  join print.

Policeman ("Constable") print
# My name is nil and I'm a Constable.

In addition, it has the notion of a separation of the data language and the expression language that I find compelling. While not terribly innovative I must say that what it lacks in innovation it makes up for in clarity of implementation. The whole language weighs in around 10K LOC so an enterprising young programmer (or an old one like me) can absorb the whole language in a few weeks. Code reading is a good exercise. Good code reading is a great exercise.

More resources


released: 2008, author: Charles Nutter

JRuby is a fantastic JVM language but it, like every other language, suffers from the runtime problem. That is, to provide a powerful and performant development and execution experience, symbiotic programming languages often include a library of core functionality that must accompany any runtime deployment. While this is typically not an issue in practice, this runtime environment is inhibiting for lightweight target environments. Enter Mirah. Mirah’s goal, and it is a worthy goal indeed, is to provide a language with no added runtime footprint while maintaining an experience that is statically typed with the feel of a dynamic language.

def reverse(s:string)

puts reverse('reversed')

At first glance Mirah looks like JRuby if JRuby allowed type annotations. If I didn’t like JRuby so much I might secretly hope that Charles Nutter would spend all his days working on Mirah.5

More resources


released: 2007, author: Mitchel Resnick

While watching my 5-year old son effortlessly program some Lego Mindstorms it struck me that the world could use a general purpose language built around the graphical IDE available therein. Imagine my surprise when I found Scratch, a graphical language based off of the same principles, and by the same group at MIT as the Lego offerings.

Here is the ubiquitous “Hello World” in Scratch:

Scratch is a close cousin to Smalltalk, but its presentation and M.O. is geared toward building necessary math and programming skills in children through “playful experimentation” — an idea that I endorse fully. Scratch is in the same vein as Microsoft’s Kodu, but gets my vote because of my previous Lego experience.

More resources


released: 2011, author: Rich Hickey

ClojureScript is a programming language taking most of the semantics of Clojure and compiling down to JavaScript. I work on ClojureScript, so I am certainly biased badly toward it. Maybe the video below by Brenton Ashworth can speak to how cool it is:

ClojureScript browser-connected REPL from Brenton Ashworth on Vimeo.

It made my jaw drop in any case.

More resources


released: 2007, author: Rich Hickey

Again, I am incredibly biased in favor of Clojure, so I will leave this short. I will say this:

Immutability is a game changer.

Otherwise here is a beautiful implementation of Conway’s Game of Life by Christophe Grand:

(defn neighbours [[x y]]
  (for [dx [-1 0 1] dy (if (zero? dx) [-1 1] [-1 0 1])]
    [(+ dx x) (+ dy y)]))

(defn step [cells]
  (set (for [[loc n] (frequencies (mapcat neighbours cells))
             :when (or (= n 3) (and (= n 2) (cells loc)))]

(def board #{[2 1] [2 2] [2 3]})

(defn print-board [board w h]
  (doseq [x (range (inc w)) y (range (inc h))]
    (if (= y 0) (print "\n")) 
    (print (if (board [x y]) "[X]" " . "))))

(defn display-grids [grids w h]
  (doseq [board grids]
    (print-board board w h)
    (print "\n")))

Furthermore, I wrote a book about Clojure.

More resources


released: 2009 (?), author: Alessandro Warth

The buzz surrounding domain-specific languages has grown louder in the recent years and much mindshare is being devoted to the topic. However, as someone who has extensive work (and play) experience in DSL design and implementation, there is much left wanting in the current state of the art. The problem lies in that it’s often difficult to implement a powerful, robust, and robust DSL using general purpose programming languages. There are many reasons for this, but the main problem is that even in languages with incredible syntactic flexibility, it’s nearly impossible to implement DSLs without the ugliness of the host implementation bleeding through. Of course, it can be done. However, as you move toward the ideal DSL for any given domain you inch closer and closer to a full-fledged language parser and runtime. This is less than ideal in many cases. I could write a whole series of posts about this, but that remains for another day. Really, what the DSL-creating world needs is a language and set of tools specifically geared toward building both stand-alone DSLs and those of the embedded variant. Enter OMeta.

Example Ometa code on Github

While something like JetBrains’ Meta Programming System likely provides a more comprehensive experience and more powerful tools, OMeta is striking in its stark simplicity. That is, OMeta is built on the principle of Parser Expression Grammars (PEG) extended to support generalized data structures.

More resources


Fortress pushes the boundaries of the age limit in this post since it was internal to Sun years before its public release. The elephant in the room regarding Fortress is the fact that Guy Steele is involved in the project. Despite that fact, Fortress is interesting on its own thanks to its focus on parallelism, syntax inspired by mathematical notation, an object-functional paradigm, comprehensions, traits, contracts, static resolution of units of measure, and distributed data-structures.

for i←seq(1:m) do
  for j←seq(1:n) do
    print a[i,j]

The simple nested for loop above exhibits an interesting property in Fortress. That is, the components of the loop execute in parallel. Fortress takes a hard-line stance on parallelism by not viewing it as a language feature, but instead as a language default. Besides implicit parallelism, Fortress also provides explicit parallelism by way of futures.

More resources

What’s next?

There have been even more recent developments in programming language design and development, but in most cases I’ve only tweet-sized impressions to offer.

  • Dart
    • Remember the first axiom
    • Seems poised for maximal adoption
  • Rust
    • Seems in the vein of D
    • Remember the first axiom
  • Ceylon
    • Not sure what this provides for a Java team with solid conventions
  • Kotlin
    • Built from the IDE down
  • Newspeak
    • smalltalk plus: FloatD epsilon.
  • Perl6
    • Since I’m not a Perl programmer I don’t mind waiting
  • Magpie
    • Best langdev “blog” ever
    • Sadly have not had a chance to explore the source
    • By one of the Dart devs
    • thanks to Tracy Harms for the reminder

Lesser knowns

These languages were recommended to me by others, so I know very little to nothing about them:

  • Felix in the ML family
  • Wheeler Seems truly unique. Looking forward to exploring.
  • Opa next-gen web language
  • Frege a language in the Haskell family
  • Cobra had me at contracts
  • Clay another systems language. looks clean to my eyes.

One surprising discovery on my part is that there seems to be no easily accessible information on the advances in array programming6 in the past 5 years. However, in that regard I suspect that there is much proprietary innovation. As time marches on the general feeling is that programming languages are becoming more derivative and evolutionary rather than made from whole-cloth and revolutionary. This is not necessarily a bad thing as there are many many ideas yet to be plumbed from the depths of the history of computing.

What have I missed?


  1. As with any post, there should always be an implicit “to me” and “in my opinion” attached to any statement. Welcome to blogging! 

  2. Really the goal is probably extreme expressiveness, but I like the way the speed angle sounds — it’s more “in your face”. 

  3. I am constantly amazed at the endless well of amazing libraries available for Racket. 

  4. If you know me, then you know which I might say. ;-) 

  5. Mirah is an example of an idea that I like to call “programming language restoration”. While not exactly emblematic of the ideal, it’s right in spirit. I will write a blog post about this one day. 

  6. Technically J has been around for a long time, but has only recently been open sourced. It is a very interesting language that I hope to explore sooner rather than later. Additionally, the Q/KDB pair is considered to be the state of the art in the array programming space, but they fall outside of the limits of this post. 

61 Comments, Comment or Ping

  1. What do you mean exactly by “array programming” as such? Would you count parallel variants of Fortran, or nested data parallel languages such as NESL and Data Parallel Haskell?

  2. @FranklinChen

    I’m not familiar with them. By array languages I mean the APL/J/K/Q/Kona family.

  3. Linan

    Happy to know I am not the only one hate Go!

  4. Actually I just realized you were just talking about languages created in the last 5 year. Factor might not apply here.

  5. Perhaps you should also include ATS ( It is very distinctive and provides a novel paradigm of programming combined with theorem proving.

  6. brad

    Go seems more focused on advancing the “working” language. i don’t think its fair to put it side by side with something like Agda, which clearly intended as a platform for language research.

  7. @brad I’m not sure what fairness has to do with it. It is an interesting language released within the past 5 years. It’s perfect for this post.

  8. I’m not really familiar with D but I thought D was in the superset of C family along with Obj C and C++. Rust seems to be more about state lockdown in an imperative/systems language family:

  9. Brandon

    Here’s a little continuation of the Agda example.

    One way to get a type of even numbers from your evenness test is a definition like this. T is from Data.Bool.

    data EvenNat : Set where Even : (n : Nat) → {even-proof : T (even n)} → EvenNat

    If even n is true, T (even n) reduces to the single-element unit type, and Agda fills in the even-proof argument automatically (as requested by the braces around even-proof)

    fourEven : EvenNat fourEven = Even 4

    If even n is false, T (even n) turns into the empty type, and there’s no possible value for the even-proof argument. This is a type error:

    fiveOdd : EvenNat fiveOdd = Even 5

  10. iskandar

    Hope you cover Lush sometime:


  11. Whiley is a programming language which permits have pre- and post-conditions on functions, and invariants on data types. The aim is that these will be checked at compile-time, and a prototype version does this.

    The language also employs a flow-sensitive structural type system. This makes it look very much like a dynamically typed language, when it in fact is statically typed.

  12. shang

    Disciple is one that I’ve been following with a lot of interest lately:

  13. Please include Falcon It includes Tables as first class objects. It is a multi-paradigm language

  14. Vagif Verdi

    You should check new haskell like language on JVM: Frege

  15. Daniel Peebles

    Don’t forget Idris, by the author of the whitespace esolang. And the any-day-now Epigram 2!

  16. mostly untied

    mythryl is a nice and heroic effort to posixfy sml/nj and give the whole thing a c-syntax. beginning to be workable and the maintainer comes across as a true hyper-nerdy entertaining erudite:

  17. John

    Fogus, I agree with you that Dart seems poised for maximal adoption. It seems to have all the ingredients (familiar, fairly simple, fixes a problem a lot of people want fixed, support by a big company).

    Re. Perl 6 you mention that you “don’t mind waiting”. What’s your impression of the language so far?

  18. I think you’re also missing Opa (, which offers novel approach to developing web apps.

  19. If countless LISP dialects are interesting, maybe also a new Haskell dialect called “Frege” is worth mentioning.

    Frege is a non-strict, pure functional programming language in the spirit of Haskell. It enjoys a strong static type system with type inference. Higher rank types are supported, though type annotations are required for that.

    Frege programs are compiled to Java and run in a JVM. Existing Java Classes and Methods can be used seamlessly from Frege.

  20. zerology

    “While watching my 5-year old son effortlessly program some Lego Mindstorms”

    I would be highly pleased if you could write about this once too.

    Btw.: Can you son read already?

    Kind regards & thank you for the post.


  21. webreac

    Why scala is not there ? I feel it is the language to learn now.

  22. AKX

    Great post – will have to take a look at some of these.

    I’d also like to point you to Coco, a more avant-garde dialect of CoffeeScript. Here’s the “additions over CoffeeScript” page for it:

  23. Emmanouil

    Why did you avoid to learn Factor ? My favorite feature is the ability to reload changed source files from disk into a running environment, and have changes take effect immediately in whatever application or library I’m developing now.

    Adding and removing slots in classes Changing superclasses of classes Adding and removing methods Changing any function Changing a macro definition and have all expanders re-expand Changing a function into a macro and vice versa

    Changing the number of input parameters or the number of return values of a function and have the system tell me if I forgot to update any callers

    Changing online documentation

    Also an added bonus is if the system keeps track of what source files have changed and offers a command which reloads all the changed files in the right order, without me having to keep track of this.

    For extra credit, make sure that despite all of the above, the dynamic compiler can inline aggressively and boil layers of polymorphic dispatch and object allocation down to nothing, all while keeping track of every optimization decision it makes, ready to deoptimize, roll back and recompile at a moment’s notice if the structure of the program changes. I don’t want a tradeoff between interactivity and high optimization, I want the compiler to always optimize as aggressively as possible without impacting development. As far as I know, Factor is the only language that can do all of this. Prove me wrong!

    In Haskell, ghci is uselessly crippled and won’t let you even define new data types.

    In Ruby, removing a method from a source file and reloading the source file won’t remove the method from the in-memory dictionary. Changing the superclass of a class and reloading is not allowed at all. There’s no static checking of any sort, a mistyped method name is a runtime error, and so is passing the wrong number of arguments.

    In Java, most of these things don’t work. HotSwap won’t let you add or remove instance variables, or change a method’s signature. The JVM does go to great lengths to make sure that the current set of loaded classes is consistent though, and the verifier will raise an error if there is an interface mismatch between caller and callee.

    In SBCL, redefining a macro or an inline function won’t recompile callers in other compilation units, and with a high speed declaration, redefinition isn’t guaranteed to do anything at all. Changing CLOS class structure is allowed, but only because the compiler doesn’t attempt to inline across method boundaries at all.

  24. @Ingo Yes, Frege is a good addition. Thank you for the reminder.

  25. @Koprowski Thank you. I will add Opa.

  26. Stephen Colebourne

    Fantom is another comprehensive newish language that ought to be on the list, especially if Kotlin and Ceylon are. Its targetted at JVM and Javascript runtimes.

  27. akuhn seems like something you might want to add to this list. It’s ability to extend syntax and semantics at runtime is pretty neat.

  28. yachris

    You might want to look at Fantom, It compiles to either the JVM, Javascript or Microsoft’s CLR.

    It implements a lot of current ideas (type inference, functional programming parts) with a really clean, minimal set of existing classes.

    Interestingly, the developers have built their company around applications built in Fantom, so it really has to work :-)

  29. You have missed RDXPL RDXPL is dynamic, interpreted programming language… The basic idea of RDXPL (Rapid Development eXperience Programming Language) is to write VERY SMALL code to do the job, through a great expressiveness.

  30. Jim Theriot

    IMHO the J programming language [] deserves to be on this list; think ‘APL reloaded’ …

  31. Hi Michael!

    Can I also recommend you take a look at I think you’ll get a kick out of it. :-)

  32. Sam Tobin-Hochstadt

    I would not-so-humbly suggest including Racket and Typed Racket. The former isn’t new, but has seen significant growth in the last 5 years, the latter is almost exactly 5 years old now.

  33. otoburb

    The Red language is a new entrant, announced March 2011.

    Aims to be an open-source and is heavily inspired by REBOL.

  34. angel

    booooo!! you don’t include boo…

  35. leek

    SKETCH is a new but relatively domain-specific language:

    It generates code based on a template, filling in user-specified “holes”, which are unknown numbers or unknown user-defined operators, such that the resulting code matches a specification.

    Think of the programming tricks in the book “Hacker’s Delight”. Imagine inputting into SKETCH the slow, full specification of one of the algorithms, as well as a sketch of all permitted operations (e.g. only integer shift and add). SKETCH finds the secret formula which matches the specification.

  36. @KentPalmer

    Potion also has tables as first class objects.

  37. I think you should definitely include Cobra in this list. It is currently 5 years old, so it should still fit in this collection.

  38. Randy Hudson

    For completeness, here’s a Kotlin link:

    Kotlin looks roughly like Scala: The Good Parts.

  39. Robert H.

    Nitpick, if you care. In Carver’s shen above:

    “Therefore, Dr. Tarver devised the idea that the predecessor Shen should…”

    Thanks for the review. Enjoyed it.

  40. @Danilo Thank you. Cobra has been added.

  41. Nice post as always! :-) Even for a language nerd like me you still managed to include two new ones (Ometa and Fortress).

    Here are my 2 suggestions:

    ANI – experimental, high-performance, implicitly parallel, deadlock-free general-purpose dataflow programming language

    ooc is a programming language with objects, first-class functions, and pink unicorns.

    It’s written for developing an operating system called oos (

    This also reminds me that I wanted to look more into Potion, I never had time to continue my research after fixing that one bug ages ago :-(

  42. Jaen

    Clay: A systems language that takes metaprogramming way beyond C++, D etc.:

  43. Laurie Cheers

    My language Swym would also qualify.

    (It’s still in development – I expect to release a new version next year.)

  44. André van Delft

    I am extending Scala with constructs from Process Algebra. The result, Subscript, is meant for parallelism, GUI’s, simulations, parsing and maybe more. A preliminary version is currently being implemented as a Scala DSL. This DSL and some working examples are available at

  45. Plumenator

    Indeed, Clay’s very interesting too!

  46. Don Park

    Elixir is a functional language on top of Erlang that was inspired by ruby’s syntax.

  47. samwyse

    Speaking as an old APL programmer who never really adopted any of its successors, Numeric Python is pretty much Python with APL merged in. Let’s face it, if you’re getting rid of the APL character set, why not go all the way and adopt a “normal” syntax?

  48. Mark Wong-VanHaren

    Yeti: Minimalist ML on the JVM.

  49. Andreas


    you should also have a look at Pi:

    Pi ( is a language that is based on pattern matching and allows to extend the language with ease.

    Greetings, Andreas

  50. I have big problems with the bizarre way syntax is designed in many of these newfangled functional languages. It’s as if we’re measuring expressiveness by number of keystrokes only. Many of the important language-level operators are being expressed with punctuation rather than keywords, and sometimes that punctuation is pretty ugly; like Ioke, really, using ” and ` as two different operators?

    It rather reminds me of perl, providing language-level global variables like $_ and $’… Why not require a few extra keystrokes in favor of increased readability?

    To some extent this might be related to how the sample code was written, and not the language itself.

  51. I would mention Nemerle, which does an interesting work on hygienic macro systems. F# is interesting too, but less innovative, I think.

  52. You really make it appear so easy with your presentation however I in finding this matter to be actually one thing which I feel I would never understand. It seems too complex and extremely wide for me. I am having a look ahead for your next post, I’ll attempt to get the cling of it!

  53. Our Website

    I seldom drop remarks, however I glanced through a few comments here fogus: Programming language development: the past 5 years. I do have 2 questions for you if you do not mind. Could it be just me or does it seem like a few of the remarks appear like they are left by brain dead individuals? :-P And, if you are writing on additional social sites, I would like to keep up with you.

    Could you make a list of every one of your social sites like your twitter feed, Facebook page or linkedin profile?

  54. Buying A Synthesizer

    I’m really enjoying the design and layout of your site. It’s a very easy on the eyes which makes it much more pleasant for me to come here and visit more often. Did you hire out a developer to create your theme? Excellent work!

  55. A Curious Observer

    A functional counter part to Dart as a web programming language is Elm. It has immutability and type inference and complete interoperability with JavaScript and HTML and CSS.

    import Text (..)

    main : Element main = asText “Hello World”

    ^ elm “hello world”

  56. You need to try Felix a bit more. Despite being generally an OO-advocate/anti-functional/OCaml-dislike person, I’ve grown very fond of Felix.

Reply to “Programming language development: the past 5 years”