Newsgroups: comp.edu,comp.lang.ada,comp.lang.c++,comp.lang.modula2,comp.lang.scheme
Path: cantaloupe.srv.cs.cmu.edu!rochester!udel!gatech!howland.reston.ans.net!ix.netcom.com!netcom.com!adaworks
From: adaworks@netcom.com (AdaWorks)
Subject: Re: Comparison of languages for CS1 and CS2
Message-ID: <adaworksDC0xG7.70B@netcom.com>
Followup-To: comp.edu,comp.lang.ada,comp.lang.c++,comp.lang.modula2,comp.lang.scheme
Organization: NETCOM On-line Communication Services (408 261-4700 guest)
X-Newsreader: TIN [version 1.2 PL1]
References: <DBEwuo.8L@world.std.com> <bob-1107951224410001@comp_ctr245.sonoma.edu> <3tus9g$7tr@Starbase.NeoSoft.COM> <fjm.104.000FF1E0@ti.com> <DBzEC8.9LH@murdoch.acc.Virginia.EDU> <dewar.806203710@gnat>
Date: Thu, 20 Jul 1995 16:50:31 GMT
Lines: 49
Sender: adaworks@netcom2.netcom.com
Xref: glinda.oz.cs.cmu.edu comp.edu:13448 comp.lang.ada:32964 comp.lang.c++:139640 comp.lang.modula2:12152 comp.lang.scheme:13288

There are some wrongheaded ideas about Ada published here:

: of the appraisal of Ada being a big, complicated language is from

Several commentators, including some Ada gurus have been too quick to
accept the proposition that Ada is big, complicated, unwieldy, or
even, "of the kitchen-sink variety."  I disagree.

There are some simple underlying ideas in the Ada 83 standard which have
been carried forward into Ada 95. At the risk of oversimplifying, I believe
that, aside from tasking, students can understand the overall design of 
Ada in terms of two main issues.

      Typing Model:

      This is fundamental to Ada.  It is not complicated, per se,
      but it does say "If you have a bolt with 32 threads per inch,
      you must use a nut of 32 threads per inch."  The implications of
      this are fairly easy to understand, not so.

      Scope and Visiblity:

      This is least understood part of the language. It causes more
      trouble than typing, though it is closely related to typing. The
      idea here is that, at any part of a design, any element of that
      design should be as explicitly identifiable as possible. If it is
      not in scope, it cannot be not visible.  If it is not explicitly 
      visible it cannot be referenced. We can hide visibility when it
      seems appropriate. 

      These two ideas, plus considerable attention to internal 
      consistency of the language are the foundation for everything
      from packages to limited types. There are a lot of structural,
      semantic and syntactic features to support these propositions,
      but, in my mind, I keep returning to them to keep clear about
      what this language is all about.     
      
      I realize that someone can raise the issues of generics, model
      numbers, tasking, exception handling, etc., but as a teaching
      language we do not need to dwell on those issues anymore than
      we need to discuss numerical integration when teaching first
      year algebra.

      Richard Riehle
      adaworks@netcom.com


-- 
                                             adaworks@netcom.com
