I suspect that most people involved in the creation of programming languages like to think of themselves as (intelligent) designers. We have the Programming Language Design and Implementation conference, programming language designers, design documents, and so on.

Yet, despite all this, programming languages look more like the products of evolution than of intelligent design. We can organize programming languages into families and trace the origins and gradual evolution of every programming language feature. Given any two programming languages, there are quite likely more similarities than differences.

Of course, this should surprise no-one. For a new language to catch on, even in a modest way, it has to leverage the familiarity its potential users have with existing languages and make sure that any new features are few, powerful and easy to learn.

On the other hand, new languages are not simply extended versions of Fortran. New programming languages also evolve by deleting features from their predecessors. Niklaus Wirth (Pascal, Modula, Oberon, etc.) famously remarked that the designer of a new programming language should spend more time deciding on what to leave out than on what to put in.

Yet, every feature found in a programming language got there because it enabled a scenario important enough to warrant the significant expenditure of effort needed to put the feature in the language. Sometimes the scenario goes away as time goes by and the language feature can quietly be dropped without anyone shedding any tears. Or, more usually, the scenario becomes relatively unimportant and the people who care about it simply stick with the old languages.

If things go really well, the new language introduces an abstraction that generalizes a number of (predecessor) features that can then be dropped from the language because they are special cases of the new feature.  Well, this seems like it ought to be true, but right now I’m hard pressed to come up with a good example of this actually happening in a successful programming language. (If a reader has such an example, I’d love to see it.)

At any rate, it is interesting to take a hard look at the features we all know (and love?) in our current successful programming languages and speculate about which of these features might not (or should not) be retained in successful new programming languages.

I coming weeks, I’ll pick some features, more or less at random and try to poke holes in them.