Re: some questions re. Ada/GNAT from a C++/GCC user

[adaworks@netcom.com (AdaWorks)]

Robert A Duff (bobduff@world.std.com) wrote:
: In article <adaworksDp5Ct8.1wt@netcom.com>,
: AdaWorks <adaworks@netcom.com> wrote:
: >  Surely you inadvertantly omitted your smiley for the phrase, "for no
: >  good reason."

: No, I'm absolutely serious.  No joke.  I really do think the extra
: verbosity damages readability, and there's "no good reason" for it.

  HmmmmMMMMMMMMmmmm.  I thought in improved readability in large programs.
  Maybe it is just a matter of what one gets used to reading.

: Don't get me wrong -- I don't think is really a big deal.

  Agreed, if we are talking only about readability. Furthermore, I
  would guess that this is a non-problem in small programs in any
  language.  I used to find it quite useful to declare in-line variables
  in BASIC programs back in the old time-sharing days.  This programming
  style fits quite well with the pre-OO model.

: Another point: The extra verbosity also encourages people to declare
: things up at the top of the procedure, rather than at the innermost
: statement list in which they're used.  

  Yes, this is usually my preference. In fact, I am not a big advocate
  of declare blocks, whether explicitly denoted (as in Ada) or implicitly
  as in C++.  My reasons are primarily related to the difficulties in
  maintaining large-scale programs.  

  What I see happening with locally declared variables is the practice
  of nesting yet another declare block inside one that already exits
  during maintenance.  After while, the nested declare blocks begin to
  take over the design.  It really annoys me when I pick up someone's
  program and find nested declare blocks several pages long.  Imagine 
  what this would like in C++. 

  This is not to say that such declarations are never useful. They are, 
  especially when they contain only a small set of declarations and
  well-bounded behavior.  One of my favorite uses of declare blocks is
  for local renaming of deeply nested record components.  

: For example, I believe I saw a
: post from Norman Cohen a while back, saying that (in some particular
: example), the extra verbosity of declare/begin/end just isn't worth it.

  The word "verbosity" feels slightly pejorative in this discussion. 
  I sometimes like the brevity of C and C++ contructs, just as I continue
  to appreciate the simplicity of BASIC. However, for large-scale systems 
  that must be maintained over a long time-span, the more explicit wording
  required by Ada seems more appropriate. 

: So here's a case where trying to FORCE people to write good code
: backfires.  Norm Cohen is not some evil doer who revels in terse, arcane
: notations!
  
  Whew! Am I ever glad to hear that.  

  Richard Riehle
  adaworks@netcom.com

-- 

richard@adaworks.com
AdaWorks Software Engineering
Suite 27
2555 Park Boulevard
Palo Alto, CA 94306
(415) 328-1815
FAX  328-1112