Re: Ada self-referential operators

[dweller@Starbase.NeoSoft.COM (David Weller)]

This has all been a very interesting discussion (as well as the
Subtract C, Add Ada thread).  One thing we seem to leave out is how
we _read_.  The issue isn't whether we can resolve a symbol, but
whether our minds can successfully integrate the symbol into
something meaningful as we read.  That's part of the reason why Ada
shuns clever stuff like in C (the ever present while(*p++=*q++) comes
to mind).  It's not that we can understand what's going on -- the
above example is obvious to anybody who has a half-assed knowledge of
C -- the issue is, what's the chance of us skipping or
misinterpreting a symbol?  The more closely aligned a computer
language is to our natural language, the higher the chance of
"complete" comprehension.  Mind you, I"m not equating "complete"
comprehension with verification of logical paths (which is another
matter entirely).

Ada, because it typically avoids symbols, has a higher "readability"
level than C (not to mention the fact that Ada is case insensitive, a
another critical "readability" issue).  This doesn't imply that Ada
is automatically _more_ readable than a C (or C++) program, merely
that it _can_ be (and typically is) more readable.  Modula is another
language that leans in this direction.

Ah, well, enough cognitive philosophy for one day.

-- 
      Frustrated with C, C++, Pascal, Fortran?  Ada95 _might_ be for you!
	  For all sorts of interesting Ada95 tidbits, run the command:
"finger dweller@starbase.neosoft.com | more" (or e-mail with "finger" as subj.)