Re: Is strong typing worth the cost?

[Brian Rogoff <bpr@bpr.best.vwh.net>]

On Sun, 26 May 2002, Robert I. Eachus wrote:
[...snip...]
> What I guess I, and a lot of other here feel is that there is no
> question there worth asking.  Comparing the cost of developing an
> incorrect version of a program to the cost of developing a correct
> version is meaningless.  And all Ada programmers know from personal
> experience that strong typing finds bugs in our code at compile time
> that would be much more difficult to find using the debugger.

Being, with you, on the side of strong *static* typing, I find that a
more interesting question to ask is to what extent should the typing be
explicit (in Ada, it's almost all explicit) and to what extent should the
language allow implicit typing, like most modern functional languages.

Another related question I'd like language designers to think about is the
relationship between verbosity and readability. It's often insinuated in
the Ada community that verbosity and readability are directly proportional,
but I don't believe that's true. If we look at the history of mathematics,
there was a period of time when mathematicians wrote mathematics like
prose, and it was a big advance to get more succint notations. Just making
it like prose does not enhance readability, especially when the underlying
ideas are just inherently difficult, as with mathematics.

>  In fact, there is a very good clue that has been intertwined with this
> discussion...  C programmers will compile their code with debugging
> options enabled, then run it first via the debugger.  Ada programmers
> tend to compile with debug options turned off, and personally I have
> never used the debugger that comes with GNAT.  (I did use the Verdix
> debugger a few times though.)

I have the same experience with OCaml, though I admit I've used the
debugger when I didn't catch some generic exception like "Not_found"
and I get some bad data. That's just my own fault for being lazy.

Mostly, I've learned to write my programs so that as many errors as
possible are type errors. What I really wish for now is a powerful
dependently typed system, though of course at that point checking
becomes undecidable, like C++ templates before that iteration depth limit
was imposed...

-- Brian