Re: ADA Popularity Discussion Request

[jayessay <nospam@foo.com>]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:

> On 08 Sep 2004 10:52:05 +0200, Ole-Hjalmar Kristensen wrote:
> 
> >>>>>> "LD" == Lionel Draghi <Lionel.nospam.Draghi@Ada-France.org> writes:
> > 
> >     LD> jayessay wrote:
> >     LD> ...
> >  >> Exactly.  Actually this sort of development will save you much more
> >  >> time and money than you could ever hope for from typical static typing.
> > 
> >     LD> How could this be?
> >     LD> With powerful typing you write code.
> >     LD> Without, you write as much code and much more tests.
> > 
> > You are missing the point. He is not arguing against strong typing,
> > but against *static* typing.

You, Ole, are on target.

Dmitry, you need some misconceptions cleared up.


> Apparently, but when consistently pursued that kind of argumentation
> inevitable leads to arguing against any typing, especially against
> ADT. 

No, it does not.  This is simply and clearly incorrect.


> The philosophy behind is that types are random artifacts of the
> program,

No, this is also incorrect.  The real difference is that with dynamic
typing _values_ have types _not_ variables.  Since _variables_ don't
even exist at runtime, your type information is largely gone at
runtime in static systems.  In dynamically typed system you can never
have something like Unchecked_Conversion, because the type information
is actually with the value at all times.  You can convert, but this
always creates a _new_ value.


> rather than the basis of software design. When the program
> is not thought in terms of types, there is nothing to check, either
> statically or dynamically.

This is wrong on two counts:

First, types are indeed part of program design in dynamic languages.
In some respects they are even more important than in static languages
as they exist at _all_ times: compile load (link) and run.  They are
_always_ checked _all_ the time.  If you want to say "Ooo!  this has a
performance hit", fine, but with current systems any such checks are
basically in the noise.  OTOH, you can annotate a dynamic program with
static type information and/or use type inference to remove this issue
from most cases.

Second, types are _not_ the only thing to check in a program.  There
are many aspects that are not and even cannot be described by types.
This should be obvious or else you would never have the need to ever
write any functions/procedures.  Checking the correctness of
algorithms is every bit as important as type consistency.  I'm pretty
sure that you (anyone) will agree with this once brought to your
attention.


I read this newsgroup mostly as a lurker these days.  I used to be a
static typist, advocated it and thought Ada was a pretty good informal
type system.

I'm not arguing that anyone here should stop using Ada (or C++ or
Haskell or whatever static language floats your boat).  I'm simply
trying to correct a lot of misinformation here about (Common) Lisp,
"extreme/agile/incremental" development, and dynamically typed
languages in general.


/Jon

-- 
'j' - a n t h o n y at romeo/charley/november com