Re: Is the Writing on the Wall for Ada?

["Robert I. Eachus" <rieachus@attbi.com>]

Russ wrote:

> The fact that you need five lines, a new scope, and a new variable to
> do what most programmers (C, C++, Java, Perl, and Python) can do in
> one simple line should tell you something. If that's what Ada
> programmers call "more readable," then I'll take the "less readable"
> code, thanks.

You are being silly.  Another common approach in Ada is to define a 
procedure to do the work.  Now I might give an example as:

procedure Inc(X: in out Integer) is
begin X := X + 1; end Inc;
pragma Inline(Inc);

And sometimes I have done just that.  But in reality, an operation like 
that is seldom on Integers, because of the almost ironclad style of for 
loops in Ada.  And when it does occur, I am going to think about whether 
overflow can occur, and if it can what should happen on overflow.

So in actual practice I have written lots of "little" Inc subroutines 
that ended up being a package exporting an encapsulated type. Where the 
  package itself was several pages long including comments.  Does this 
mean that Ada is verbose?  No.  Because I only had to define what should 
happen in all the exceptional cases associated with that type in one 
place.  For an example, if this was part of an inventory control system, 
changing the count of items in stock might trigger all sorts of actions. 
  It might be for example that increasing the number might do a check to 
see if some customer had that item on backorder, and if so generate a 
shipping order.

Similarly I have also done exactly what Matt was talking about:

declare
    N : Integer renames Item (Number).Inventory.Count;
begin
    ...
    N := N + 1;
    ...
end;

But I added the elipses to indicate that ususally when you do that, the 
complex name would appear in several other places in that code segment, 
and the declare block makes it clear that that code is operating on one 
particular record.  So the example might really become:

declare
    N : Integer renames Item (Number).Inventory;
begin
    -- some operations on N
    N.Count := N.Count + 1;
    -- more operations on N
end;

In fact, almost always when you use this idiom it is directly inside a loop:

for Number in Item'Range loop
    declare
       N : Integer renames Item (Number).Inventory;
    begin
       -- some operations on N
       N.Count := N.Count + 1;
       -- more operations on N
    end;
end loop;

-- 
                                          Robert I. Eachus

"As far as I'm concerned, war always means failure." -- Jacques Chirac, 
President of France
"As far as France is concerned, you're right." -- Rush Limbaugh