Re: Self-referential types

[Richard D Riehle <laoXhai@ix.netcom.com>]

In article <wccu2ni3weo.fsf@world.std.com>,
	Robert A Duff <bobduff@world.std.com> wrote:

in response to the following outrageous hyperbole,

>Richard D Riehle <laoXhai@ix.netcom.com> writes:
>
>> As usual, we use the kind of tools appropriate for the problem
>> space and solution space.  I am beginning to think that people who
>> make up hard and fast rules for computer programming are people who
>> no longer actually write programs.  Perhaps they never did.
>
>Hmm.  I had a hand in writing a book that's got thousands of absolutely
>hard and fast rules for programming.  It's the Ada 95 Reference Manual.
>And I still actually write programs.  ;-) ;-)

Robert,

This is not at all the same thing.  The formulation of a syntax and
semantics for a programming language is not, in my mind, the equivalent
of telling a programmer which of those language features to use or 
not use.   I realize that many programmers resent Ada because they
feel it does impose too many rules.  I would not want to return to
Assembler, even though there are fewer language rules.  Even so, I
still encounter those elitists who would rather program in Assembler
because high-order languages are too restrictive.  To them, those of
us _sissies_ who no longer program in Assembler are not really programmers.

The kind of people mentioned in my post are those who thumb through
your program and criticize you for having an exit statement in a loop,
a use or use type clause in a perfectly safe place, a goto when it is
absolutely necessary, or some other construct they read about somewhere
in some magazine.  For example, when Dijkstra published his famous CACM
letter, "Go To Considered Harmful,"  thousands of programming managers
who did not read the article adopted the title as a standard, thereby
screwing up millions of lines of COBOL code.  COBOL, at that time, was
completely inappropriate for structured methods, and attempts to produce
structured code resulted in some of the most obfuscated constructs one
could imagine.  

Taking the Ada example.  The rules of Ada are certainly strict.  That 
is not a bad thing.  It would have been a bad thing if there were no
mechanisms for relaxing those strict rules when it was appropriate. One
reason Ada is better than Java for lots of things is the ability to
relax the rules.  So, Robert, even though you were involved in writing
a language that has lots of rules, you and others engaged in this
effort had the good sense to include capabilities for suspending those
rules when the correct solution called for it.

Consequently, I would not include you and the other designers of Ada in
my outrageous hyperbole.  You wrote a language reference manual that 
said, "These are the default rules. Use them and be safe."  Then you
added, "These are the workarounds when you need them."

Richard Riehle
http://www.adaworks.com