Re: Is strong typing worth the cost?

[Darren New <dnew@san.rr.com>]

Wes Groleau wrote:
> 
> > But take, just as a simple example, the "once and only once" rule, which
> > says that everything should be stated in exactly one place. Ada fails
> > this miserably, on purpose. Ada always has at least *two* declarations
> > for every type, and usually a great deal more.
> 
> ?!?!? WHAT in the world are you talking about?

type age is integer range 0..50; -- that's one

x : age; -- that's two

procedure y(yy : age) is -- That's three
  z : age -- That's four
begin
  z := blah(yy);
  zilch(z);
end y;

Now, if I change X to be a date instead of an age, how many places to I
need to change it? I need to change it two places in Y's body and one
place in Y's header, and Y doesn't even care whether its argument is an
age or a date, since it doesn't do anything with it except pass it to
other functions. Imagine that blah and zilch each pass it to a couple
other modules before something interesting actually happens with it. How
many places do you have to touch? It's exactly the same sort of
wide-spread changing that OO is supposed to reduce.

Contrast this with a similar function for Y in smalltalk:

y: yy
  | z |
  z <- yy blah { this is like z := blah(yy) }
  z zilch      { this is like zilch(z) }

If YY changes from an integer to a disk-based database, you don't have
to touch this function, because the type information is irrelevant to
the y routine.  (Actually, the syntax isn't quite right for the
smalltalk, and I don't remember the comment character for smalltalk, but
you get the idea.)


> > The inability to compile a program that makes reference to functions you
> 
> Ada does not require a subprogram to be written to compile
> a call to it.  It does require it to be written (or a "stub"
> for it) to execute the call.

It requires the subprogram to be declared to compile a call to it, and
it requires the subprogram to be implemented to link. (The difference
between being able to compile and being able to link is kind of academic
when the goal is to do both at least five times an hour, so I wasn't
really distinguishing all the steps between "finish writing" and "being
able to run".) In addition, it requires that you declare all the types
you use before you write the code that uses them. For example, you can't
compile (let alone link and run) the test that checks that the day
before tomorrow is today without declaring your date type, the
"tomorrow" routine, the "day before" routine, comparison of dates, and
etc. 

Basically, you can't run a program that makes a call on an undeclared
subprogram. Which means you can't write a unit test that fails without
touching the the production code. Before you can run a test, you have to
already have started to implement the functionality that makes the test
pass. This is a no-no.

In Smalltalk, for example, the program will run until it gets to the
unimplemented call, and pop up a debugger. At that point, you can
implement the function called, and then tell the debugger to resume from
where it was interrupted.  I haven't seen any Ada system that will let
you come close to the ease of debugging that Smalltalk allows.

> Apparently you are as familiar with Ada
> as I am with XP.

Err, no. Apparently, you don't understand enough about XP to even have
an idea of why Ada is poorly suited to it. 

-- 
Darren New 
San Diego, CA, USA (PST). Cryptokeys on demand.
   The 90/10 rule of toothpaste: the last 10% of 
         the tube lasts as long as the first 90%.