[Haskell-cafe] Language simplicity

[sylvain]

Le mardi 12 janvier 2010 à 21:25 +0000, Andrew Coppin a écrit :

Hi Andrew,

> As you can see, this conclusively proves... something.

What, exactly?

Take Eiffel in its last version: I have identified 11 keywords that are
either used for Design By Contract or source-code documentation. These
are software engineering tasks that in the other languages you cite are
not supported at the grammar level and, if ever, fulfilled by enriching
the code using comments, annotations or compiler extensions. Removed,
this make Eiffel the less "verbose" object-oriented language of your
list, excepted Smalltalk. In any case the less verbose statically typed
compiled OO language.

One factor is how rich is the set of OO constructs supported by the
language. Visibility rule keywords may shrink or extend the list of
reserved words. Same for math or logical operators: some languages
define as keyword what belongs to libraries in another. Same for
exception mechanism.

Some languages defines the code block constructs using keywords while
other use tokens that are not considered reserved words. 
Contrast for example the following Ada code (4 keywords):
procedure Hello is
begin
...
end Hello;

against the equivalent C (1 keyword):
void HelloWorld()
{
...
}
or the equivalent Haskell (0 keywords):
helloworld = ...

Ada in its 71 reserved words features keywords for concurrent
programming that doesn't exist at the same level in the other languages
in your list, and an explicit "pragma" keyword to allow the programmer
to specify things like the alignement used in the generated binary. So a
significant factor in programming language "verbosity" is how much
control the language intends to give to the programmer on the
implementation level - or said otherwise how abstracted is the language
from its run-time environment. 

Let me order your list:
Smalltalk: 0
Lisp: 0
Tcl: 0
Haskell: 21 *
Python: 31
C: 32 *
JavaScript: 36
Ruby: 38
---
Borland Turbo Pascal: ~50
Java: 53
Eiffel: 59
C++: 62

Interestingly enough, interpreted languages tend to need less keywords,
which support my observation above. 

Let ignore C. Noticeable is Haskell, with little reserved words while
being efficiently compiled. It reflects the fact that it does not have
elaborated object-oriented constructs, that code is structured using
layout rules, that the exception and concurrency mechanisms are provided
at the library level, that there is no way to control the code
generated, and that there is no built-in support for software
engineering like the sort Eiffel provides. It reflects as well the
"expressiveness" of Haskell and how good at abstracting the description
of a computation from its run-time environment it is. But if you really
wanted to compare apples to apples you would, for instance, add GHC
pragmas and "magic" things like `par` to the mix. I wonder if the
picture would change much?

> Hmm, I wonder if there's some way to compare the size of the language 
> specification documents? :-}
Maybe comparing the grammars in a standardized form (BNF) ?

Cheers,
Sylvain