What is Expressiveness in a Computer Language

[Raffael Cavallaro]

On 2006-06-16 05:22:08 -0400, Joachim Durchholz <jo at durchholz.org> said:

> And this is a typical dynamic type advocate's response when told that 
static typing has different needs:
> "*I* don't see the usefulness of static typing so *you* shouldn't 
want it, either."

But I haven't made this sort of argument. I never said you shouldn't 
use static typing if you want to. There are indeed types of software 
where one wants the guarantees provided by static type checks. For 
example, software that controls irreplaceable or very expensive 
equipment such as space craft, or software that can kill people if it 
fails such as software for aircraft or medical devices. The problem for 
static typing advocates is that most software is not of this type.

There is a very large class of software where user inputs are 
unpredictable and/or where input data comes from an untrusted source. 
In these cases run-time checks are going to be needed anyway so the 
advantages of static type checking are greatly reduced - you end up 
doing run-time checks anyway, precisely the thing you were trying to 
avoid by doing static analysis. In software like this it isn't worth 
satisfying a static type checker because you don't get much of the 
benefit anyway and it means forgoing such advantages of dynamic typing 
as being able to run and test portions of a program before other parts 
are written (forward references to as yet nonexistent functions).

Ideally one wants a language with switchable typing - static where 
possible and necessary, dynamic elsewhere. To a certain extent this is 
what common lisp does but it requires programmer declarations. Some 
implementations try to move beyond this by doing type inference and 
alerting the programmer to potential static guarantees that the 
programmer could make that would allow the compiler to do a better job.

In effect the argument comes down to which kind of typing one thinks 
should be the default. Dynamic typing advocates think that static 
typing is the wrong default. The notion that static typing can prove 
program correctness is flawed - it can only prove that type constraints 
are not violated but not necessarily that program logic is correct. It 
seems to me that if we set aside that class of software where safety is 
paramount - mostly embedded software such as aircraft and medical 
devices - we are left mostly with efficiency concerns. The 80-20 rule 
suggests that most code doesn't really need the efficiency provided by 
static guarantees. So static typing should be invoked for that small 
portion of a program where efficiency is really needed and that dynamic 
typing should be the default elswhere. This is how common lisp works - 
dynamic typing by default with static guarantees available where one 
needs them.