Re: Interface/Implementation (was Re: Design by Contract)

[dewar@merv.cs.nyu.edu (Robert Dewar)]

Patrick Doyle says

<<Also, remember that on average, saving the programmer from scanning
below saves only 1/2 the work.  Not an order of magnitude, by any
means.  Perhaps you'll argue that 1/2 is important enough?  Well,>>

Not at all, since we can't keep a whole big object in our heads, if we
have to scan ahead to find information, we may easily have to do an
exponential amount of scanning. On the way forward in a linear pass,
we catalog and abstract and remember what needs to be remembered. When
we scan forward, we are looking for a particular piece of information,
and in general we don't know enough to catalog and abstract, even if
we could keep this kind of non-linear scanning straight.

Consider, in an Algol-68 program you see:

	int q = a * b;

Contrast this to the Ada statement (Pascal, C, ... would be the same)

        Q : constant Integer := A * B;

Now in the Ada case, you know you have seen A and B already, and hopefully
the (more descriptive) names that are present will trigger the reference to
your abstracted catalog gained by reading the text prior to this point and
you will remember what you are looking for. If not, a simple search in
reverse order from the point of reading will find the reference for you.

But in Algol-68, you have to do a rather careful scan forward, paying careful
attention to scope marks, to see if there are declarations of A and B in
the same scope and this is a forward reference. You have to do this even
if A and B are already declared, because normal block structure rules
say that you get the innermost one.

It is this kind of forward reference that the Ada design strenuously tries
to avoid, since it greatly complicates the reading of a program. Worse,
since people generally write linearly anyway, you get in the habit of 
reading linearly. When you see in an Algol-68 program

   int A;
   ...
   begin
      int B := A * 2;
      ...

You will almost always just assume that the A is a backward reference to
the declaration that preceded this. In the rare case where in fact there
is another A ahead of you, you will risk making a significant mistake in
understanding.

Linear comprehension is a very important capability. All text books have
indexes, which are of course functionally similar to hypretext links, but
we do not say "never mind about presenting things in a logical order, 
building on what you have already presented, if you reference something
ahead, people can just look it up in the index". Instead we expend a lot
of effort to present things in a linear order (and indeed software for
computing partial orderings of topics to create appropriate linear orderings
is a standard part of the toolset for educators).

I notice these days that people often create Hypertext documents that
blatantly disregad this principle, and they are a huge pain to read. Sure
this kind of organization is OK for reference or help material, but it is
NOT the way to present a coherent body of knowledge that you expect people
to acquire in a comprehensive manner. A lot of people complain that they
get totally lost zooming around following links in a Hypertext document,
and vey often they are actually not complaining about the paradigm at all,
but rather its misuse to try to patch up poor document organization.

Robert Dewar
Ada Core Technologies