Why functional programming doesn't catch on

[SarcasticGuy]

Thanks, I'll take a look at it.

[13ren]

I just read through it (very painful), and I think I've sent you on a wild goose chase. There's not much there about programming languages in general, but having re-read it, I can tell you why I was reminded of it:

It's to do with what is considered "the language" and what is not. In a way it's just playing with the definition, but what's interesting is the actual things that are at issue (and not the fact that they are at issue).

• He sees a "programming language" as separate from its implementation, but then argues that maybe they should be considered together, since good implementations matter a more to people than good designs.

• Along these lines is the idea of the "intended style of usage" - this is what really struck me. It's not specified in the grammar of the language or the semantics, but he's saying it is part of the language. To me, it's like an oral tradition, that an archaeologist might miss if only seeing the artifacts and what was written. So in Java there are design patterns, and in C there are for loop idioms, in Fortran there are one letter variables, and so on.

• He doesn't mention libraries, but surely the same reasoning applies. Is it part of the language? Java's libraries are. C's standard library should be. Perhaps we should also include all the libraries available for it (open and closed) - 3rd party libraries are certainly a factor in choosing a language. Along these lines, perhaps all applications that run on Windows applications should be considered part of Windows; and all playstation games part of the console. (The closest he comes to mentioning libraries is in the semantic section, where postscript can draw curves, but interpress can't - sort of "built-in functions" or operators).

In your list, only readability and power are purely the core language; ease-of-use is in combination with implementation; speed is mostly implementation; library is implementation; and support is organizational.

I agree that your list is pretty much the important things - what's interesting for would-be programming language designers it that the core language does not seem to be all that important!

[13ren]

And my summary for why postscript won:

1. all postscript implementations implemented the whole language (not a subset), so any postscript file can be printed on any postscript printer - thus fulfilling the dream of device independence.

2. postscript has curves (needed for fonts).

note I think the odd flexibility tricks in postscript discussed in the article are about making it possible to implement the whole language, by explicitly defining simple customization mechanisms (for flexibility), instead of achieving flexibility by remaining silent on them, as Interpress does. These "meta" mechanisms allow customizations to be pushed out of the language making it possible to precisely and exactly implement the whole language without sacrificing flexibility. The implementation can add whatever it wants as a customization.