Re: Q: access to subprogram

[rogoff@sccm.Stanford.EDU (Brian Rogoff)]

Magnus.Kempe@di.epfl.ch (Magnus Kempe) writes:
   rogoff@sccm.Stanford.EDU (Brian Rogoff) writes:
   : Magnus, do you have a list of issues such as this one in which you
   : feel that orthogonality and usability were traded for the comfort of a
   : few implementors?

   A list?  No.  For the most part, Ada 95 is great.  I'll submit comments
   when it is time for Ada 0Y (and/or I'll experiment with the source code
   of GNAT :-).

I agree that Ada 95 is great for the most part, which is why I read this 
newsgroup. However, it is not as good as it could be, for a number of 
important reasons, some of which are more "economic" than technical, like
backwards compatibility. Now, backwards compatibility is very important, 
so I wouldn't suggest just starting from scratch. However, at some point 
in Ada's evolution there will have to be an incompatible shift, as that 
"ratchet effect" that Robert Dewar mentioned will just keep making the 
language larger.

   An interesting research project for academic people would be to add
   downward closure to GNAT and measure the impact on the compiler and
   generated code; then do the same on another compiler to compare static
   vs display effects.  Brian, maybe you know someone who would do that? :-)
   Now that the source code of an Ada compiler is available, where are
   the academic experiments?

I'm temporarily out of academia, though I use the account :-). But your 
question gets to the heart of one part of the discussion. Are displays 
faster? If so, by how much? On what types of programs? On the other hand, 
if there were a compiler which supported downward closures, how much would 
they be used? How often are they used in languages that support them, like 
Pascal? Lots of questions like this have to be considered, and I don't envy 
the designers! I went from being a strong supporter of downward closures to 
being not so sure after I followed Norman's paper trail. The arguments about 
complicating a shared implementation for generics worried me, though I haven't 
thought through it carefully enough (I am not a compiler writer) I do 
appreciate arguments about implementability. 

From where I was sitting, Stanford, Ada has a long way to go. The languages 
used in the CS curricula are for the most part

(1) C and C++ (by far the most popular)
(2) ML among the theoretical CS types
(3) Fortran and MATLAB among numerical analysts unlike me and engineers

and now Java seems to be gaining popularity. GNAT is nowhere to be seen. 
How are things in Lausanne? Much better I take it :-).

However, this is not a reason for despair. The academic research will come 
when the language is more widely accepted in industry. Just look at all 
of the academic work on C++, and now Java. I think it is good that Windows 
is slowly becoming the primary GNAT environment, as this will hasten that 
acceptance.

   I think some improvements that were seen as too expensive or risky this
   time around would have brought Ada closer to the power of functional
   languages.  In a few years the OO movement will be followed by another
   one, and it will be interesting to see if Ada can gracefully adapt a
   second time.

It also remains to be seen whether the problems solved by the powerful 
features are that important. In his excellent paper "Hints for Computer 
System Design", Butler Lampson says a lot about this, and recommends 
simple, fast operations are usually "the right thing". 

So what do you think will follow OO? Functional Constraint Logic 
Programming? :-) 

   In the meantime, our best path is to learn how to use the full power of
   the language--in order to create many usable, reliable, maintainable,
   and profitable applications.

Yes!

-- Brian