Ada in University Computer Science

Ada in University Computer Science

[Michael Feldman]

Now that we seem to be in another round of "Ada in Universities" discussion,
I thought I'd weigh in with a little chat about my own experience here.

I warn you that this piece is a tad long, so those of you not interested in
Ada in the university computer-science curriculum can hit your delete key
now. I hope to keep the rest of you from getting bored.

At George Washington University, Ada is the language of our data structures
course, and has been for 4 years [DISCLAIMER: I wrote the book for this
course]. (There are other courses too, but let's keep it simple.)

We are located in central DC, midway between the White House and Watergate;
several subway stops from the Pentagon. I got involved with learning and
teaching Ada back about '81, at which time Ada was, of course, only a
proposal. But it appeared to beat the dickens out of any other "real"
language for teaching data structures. [ASIDE: my publisher talked me
into putting out a second version of my book, with Modula-2 as the coding
language; the conversion project make me like Ada even more for this
stuff. That's a discussion for another time.]

Many of our students are from other countries, with no hope of ever getting
a job in the U.S. DoD world. Many of our students are U.S. citizens but
don't much care to work in the DoD world, anyway. Then there are the grad
students who are in fact working in the DoD-related industry here. Teaching
Ada as the (required) design and coding language of the (required) data
structures course has gotten somewhere around 600 students to learn (some)
Ada. Often they use it in subsequent courses when they have a choice.

What I am leading up to here is a re-iteration of my long-standing view that
Ada really _should_ be seen as "just another programming language." Before
Ed Berard and Bill Wolfe jump on me too hard, let me explain this heresy.

I have no quarrel with the view that Ada can be seen as more than the
language, rather a culture. Certainly it can. Certainly it oughta be.
I have no quarrel with the view that software engineering should be taught
more resolutely and systematically in academic computer science. I agree.
(Details of why it isn't, in most schools, has nothing to with this
discussion or of Ada; let's save it for another time).

But let's get real. Lots of good software engineering gets done using
other languages as the coding tool (pick up your favorite well-done
commercial package: was it written in Ada?). Obviously Ada helps; that's
why I presume we're all interested in it. But it's not essential.

OK. If you agree with that Ada isn't _required_ for software engineering,
perhaps you will agree that software engineering isn't _required_ for Ada.
That is, given the way knowledge is chopped into little course-sized hunks
in a curriculum, why can't Ada be taught _everywhere_ in the curriculum,
just like Pascal often is (OK, the Turbo version, which sorta supports
ADTs)? Data structures with Ada; operating systems with Ada; graphics with
Ada; data processing with Ada; you get the idea.

My experience tells me that students will in general  learn what you decide
to make 'em learn. If we say Ada is the main language, they will learn it
as easily as they currently learn Pascal. More easily than C or Modula-2,
because (most of) Ada is more uniform syntactically and semantically than
either of those. My students usually come out of the data structures course
actually _liking_ Ada; the foreign students' like for Ada cannot be
dismissed as mere job-hungriness.

What we have here, I'm convinced, is a perception problem among _faculty_,
not students. Ada has a certain mystique, which we in the Ada business
have at times fostered. It's also expensive to buy (see below). And there
are undeniably those who will always see it as a DoD toy and reject it
for ideological reasons.

On the other hand, many teachers are open-minded, and this gives us all a
golden opportunity that we should grab. The time is ripe for schools to
change away from vanilla Pascal as the language of choice. In February
each year the SIGCSE (SIG on Computer Science Education) meets; this is the
only conference exclusively devoted to CS education issues. I can't go this
year, but let me tell you what I learned last year.

I participated in a panel on teaching concurrency, and organized, with
Carl Brandon, a birds-of-a-feather session on teaching Ada. Further, I
attended several sessions on freshman courses. This was my third CSE
conference, and in each one the openmindedness toward Ada increased.
Here is the gist of the "what shall we do in the freshman course"
discussion (if any of you were there, correct me if you wish).
(I'm only focusing on language-related issues here).

There's a constituency that says "stick with vanilla Pascal"; freshmen
shouldn't focus on the language details, rather on the formalisms of
algorithm development at the program level.

This group was pretty quiet. Most speakers on stage and in the audience
believed that students should have a language they can grow into as they
progress. The analogy with natural language: English doesn't change as
a kid grows, the kid just learns more of the language. Ada isn't nearly
as large as English; even still, you don't need to swallow it in one gulp.

There's a constituency that goes with Turbo Pascal. Many schools have
large labs of PCs; many schools encourage students to buy their own (I
use the term PC generically: personally I prefer Macs; obviously Macs
are included in this discussion). Turbo Pascal can carry a student
through a number of courses, with the nice development environment
and the use of units (which are sorta like packages but don't support
private types, sadly). My objection to this position is that I don't
think Philippe Kahn should unilaterally set the standard for the
content of a programming language. Turbo is a de facto standard _only_
in the DOS world; the Mac version is a (somewhat) different language,
not even fully compatible at the syntax level with the DOS one, which
only makes my point stronger.

There is a small group who've tried C with freshmen. The consensus seems
to be that freshmen have enough to worry about without falling unwittingly
into all of C's "gotcha's". C is OK for upperclass students, but wrong
for freshmen (whew! I'm glad they came to that conclusion too!).

Then there are the Modula-2 proponents, a growing number. Some of them
genuinely like M2. But syntactically it's weirder than Ada (why would a
new language be case-sensitive? why shouldn't functions be able to return
records?) and only a little bit standard (although to their great credit
the M2 compiler writers are converging on a standard even though there's
no government forcing them too, and even though Wirth apparently isn't
participating).

What made this conference different from  preceding ones is that a number
of people said they'd prefer Ada, but can't really"sell it" yet to the
committees in their departments, because the price is simply too high
right now. The development environments are, in general, tailored (and
priced) for industry, and there are _no_ textbooks suitable for freshmen.
(Putnam Texel's is pretty close, but still makes enough assumptions that a
rank beginner in programming would be confused).

The bottom line is that we've moved from an era of CSE speakers dumping
on Ada (for reasons I'm sure you can all imagine) to an era of CS faculty
- and not just a few - being ready to go for Ada when the materials are
available. And they're openminded not just because they think it'll
increase their students' marketability. I think the word is finally getting
out that Ada just might _really_ be the right language!

I'm quite optimistic about Ada compilers:   the price of compilers and
environments is coming down, to the point where we have a handful of
DOS-world systems in the $100. ballpark. The recent piece by Rich Pattis
describes some interesting experiences with acquiring site licenses for
Ada; what made it happen was a grant from Boeing, a "sugar daddy" as he
put it. And when it happened, the University of Washington switched from M2.

It seems to me that the Ada user community could well emulate Boeing. Think
about it: a university site license for the PC compilers is in the $10,000
ballpark. This is, I guess, roughly one programmer-month's worth. Or
equivalent to sending perhaps 3-4 employees out of town for a 5-day
short course. Could this kind of money be liberated to give the university
down the street a shot at getting Ada _really_ going in their curriculum?
$10000 is, believe it or not, a helluva lotta money for some schools to
come up with, and the decision to spend it is an _agonizing_ committee
process. Seems to me that if each company adopted a school or two in
their area, a little money could go a long, long way. Do you agree?

About textbooks: I don't have as ready a solution here. I speak to editors
now and then; publishers are _very_ conservative these days, and don't
seem thrilled about taking the risk of a freshman-level Ada book.
Somehow we need to convince the publishers that they'll make $$ selling
Ada books for first-year students. Do any of you have ideas about how to
get the word out to publishers? Can you get your friends in the local
universities to write to publishers and say that they'll switch to Ada
when the books are there to teach with? Are there potential authors out
there? [DISCLAIMER: I am a potential author].

I am aware of at least 3 people doing a nice job teaching Ada to freshmen
as their first and primary language: Carl Brandon (Vermont Technical College);
David Rudd (University of New Orleans); and Rich Pattis (University of
Washington at Seattle). Who else is out there that you know of?

To conclude:  I am not minimizing the problems of re-educating people
in industry by focusing on the University structure here.[DISCLAIMER: I
do a bit of re-educating myself]. But I think we should look to the
long term. In my vision of the long term, Ada will simply be the language
of choice in undergraduate computer science, not a "niche" languge suitable
only for seniors and grad students (we teach it successfully to sophomores).
We ought to work on filling the pipeline with graduates who speak Ada as
their "mother tongue," learning C, Lisp, etc., as second or third languages,
just as most students do now but with Pascal as the mother tongue.

The typical Info-Ada reader may be in a position, either in a school or in
a neighboring company or agency, to influence the speed of arrival of the
long term. How can we work together to do this? I'd love to continue the
discussion with any interested party, either in the Info-Ada forum or
by private E-mail. Hope I hear from some of you.

------------------------------------------------------------------------
Michael B. Feldman, Professor              residence address for USNail:
Dept. of Elect. Engrg. and Comp. Sci       Michael B. Feldman
The George Washington University           6218 Wagner Lane
Washington, DC  20052  U.S.A.              Bethesda, MD  20816  U.S.A.
+1-202-994-5253
MFELDMAN@GWUVM.BITNET
MFELDMAN@GWUSUN.GWU.EDU
Acknowledge-To: Michael Feldman <MFELDMAN@GWUVM>

Case insensitivity

[Bruce Anderson]

As background, I work for a company which uses C primarily but since
we do work for the government we are in the process of being forced to
switch over to Ada. I do not currently work on a project which uses Ada
but I have been somewhat interested in the language at least to the 
point of taking a class in it (unfortunately the worst technical
course I have taken in my life but that's another story). I try to 
read this group somewhat regularly to garner whatever I can from it
so basically I am a novice (at best) at the language.

Given that, one of the things which I dislike the most about the language
is its case-insensitivity and although I hadn't given it much thought
I guess I had assumed that this was likely to be a somewhat common
opinion. In a recent article however, the author made a comment which
indicated that he felt that it was stupid to have a case-sensitive 
language.

My question is, does everyone think that the case-insensitivity of
Ada is a positive feature and if so why? Personally, if I see a
variable 'aBcDe' and another one 'AbCdE' they don't immediately strike
me as being the same and is therefore confusing when they are.

Bruce Anderson - Scientific Atlanta, Government Products Division
...!sagpd1!banderso

Re: Case insensitivity

[Erland Sommarskog]

So another non-important subject to have a long debate on!

Bruce Anderson (banderso@sagpd1.UUCP) writes:
>My question is, does everyone think that the case-insensitivity of
>Ada is a positive feature and if so why? Personally, if I see a
>variable 'aBcDe' and another one 'AbCdE' they don't immediately strike
>me as being the same and is therefore confusing when they are.

I'm somewhat split in this issue. I have never worked with case-
sensentive language except for the Unix file system where it is a pain.
(Was it an uppercase or not? Never remember.) Wait, Berkley Pascal
on Unix is case sensitive. Nice when your are porting programs...

I have been bitten by the trap I've hidden an outer constant (upper case 
only) with a local variable (upper case initial) and it took me quite
a while to see what I have done, when the comparison with the constant 
didn't give the expected result. 

On the other hand, in a case-sensitive language you declare: 
   Word_length : integer;
Someone else with another coding style comes in and modifies 
the program and in an inner block and adds:
   word_length : integr;
Then a third person modifies this block, and sloppily writes
   Something := Word_length;
and don't get corrected by the compiler.

Maybe a good rule would be to require the case in the declaration
to be kept, and disallow variation. I.e. once you have declared
"Word_length" you may not write "word_length" until you declare 
that name, which then hides "Word_length".
-- 
Erland Sommarskog
ENEA Data, Stockholm              This signature is not to be quoted.
sommar@enea.se

Re: Case insensitivity

[William Thomas Wolfe,2847,]

From article <317@sagpd1.UUCP>, by banderso@sagpd1.UUCP (Bruce Anderson):
> My question is, does everyone think that the case-insensitivity of
> Ada is a positive feature and if so why? Personally, if I see a
> variable 'aBcDe' and another one 'AbCdE' they don't immediately strike
> me as being the same and is therefore confusing when they are.

    I think the basic idea is that variables of the forms described above
    are being deliberately discouraged.  Instead of User and useR, then, 
    one is forced to be more descriptive (Administrative_User, Student_User),
    thus enhancing the documentation of the program.

    A programming language does not exist only to PERMIT applications to be
    developed.  A good design must also take into account the fact that a
    language guides the way its users think and act.  By establishing certain
    possibilities as things which are necessary only for the purpose of 
    creating undesirable programs, and eliminating those potential modes of
    behavior, a language can help you to converge quickly on a high-quality 
    solution.  In this case, the quality metric is maximization of the extent 
    to which variable names are loaded with semantic information.  Two or more
    variables must either be collapsed into a single variable, or must be given
    different names, even if it's nothing more than User_1 and User_2. 

    Therefore, I see it as a positive feature, one which results in better
    programs.


    Bill Wolfe, wtwolfe@hubcap.clemson.edu

Re: Case insensitivity

[Terry Westley]

In article <317@sagpd1.UUCP> banderso@sagpd1.UUCP (Bruce Anderson) writes:
>My question is, does everyone think that the case-insensitivity of
>Ada is a positive feature and if so why? Personally, if I see a
>variable 'aBcDe' and another one 'AbCdE' they don't immediately strike
>me as being the same and is therefore confusing when they are.

Yes, I do:

1) Although natural language is case sensitive in proper usage, it is not 
   necessary for understanding.  i'm sure you know what i mean.

2) I use C just as much as Ada.  Case sensitivity is a minor
   annoyance in a language that requires human perfection.  By this I
   mean that the compiler does not catch as many typos and careless
   mistakes as an Ada compiler.  I believe that the programmer and the
   compiler have different strengths and that compilers and languages
   should be designed with that in mind.

-- 
  Terry Westley         
  Moog, Inc. (no, not the synthesizer company)
  East Aurora, NY  14052-0018
  {boulder,decvax,rocksanne,rutgers,ames}!sunybcs!moogvax!terry

Re: Ada in University Computer Science

[Frances L VanScoy]

During spring semester 1987, West Virginia University taught an experimental
CS 1 in Ada at the request of and with some support (hardware and software)
from the Software Engineering Institute.

Beginning with fall semester 1989, Ada will be the primary language 
used in our freshman and sophomore majors courses.

Frances L. Van Scoy
Associate Professor of Computer Science
Department of Statistics and Computer Science
West Virginia University
Morgantown, West Virginia  26506
304-293-3607
vanscoy@a.cs.wvu.wvnet.edu

Frances L. Van Scoy
Associate Professor of Computer Science
Department of Statistics and Computer Science
West Virginia University

Re: Case insensitivity

[Rick Farris]

In article <317@sagpd1.UUCP> banderso@sagpd1.UUCP (Bruce Anderson) writes:

> I do not currently work on a project which uses Ada but I have been
> somewhat interested in the language at least to the point of taking a
> class in it (unfortunately the worst technical course I have taken in
> my life but that's another story).

I'm curious to know what course you took.  Here in San Diego, there
are very few courses given in Ada.  I'm studying for my Master's in
Software Engineering at National University, and it is taught in Ada.
I've found the National Ada courses to be excellent.  You may want to
investigate them.

> My question is, does everyone think that the case-insensitivity of
> Ada is a positive feature and if so why? Personally, if I see a
> variable 'aBcDe' and another one 'AbCdE' they don't immediately strike
> me as being the same and is therefore confusing when they are.

The case-insensitivity bothered me also, but I've managed to overcome
my objections.  1) It *is* rather pathological to use the same
identifier with a different case, and expect it to refer to a
different object.  Yes, I've done it in C, usually to differentiate
between a typedef and an object of the type, but it isn't really very
good practice.  2) Ada doesn't prohibit you from using case to
signify differences to *you*.  For instance, if you'd like, you can
make your manifest constants in upper case, your global variables
capitalized, and your local variables in lower case.

In your example above, (aBcDe vs. AbCdE), this case should never
arise.  If you've used aBcDe, you should not use AbCdE in your
program.  I hope you don't do this in the language you're used to.
(Probably C) 


Rick Farris   RF Engineering  POB M  Del Mar, CA  92014   voice (619) 259-6793
rfarris@serene.cts.com     ...!uunet!serene!rfarris       serene.UUCP 259-7757

Re: Case insensitivity

[mcdonald]

In article <317@sagpd1.UUCP> banderso@sagpd1.UUCP (Bruce Anderson) writes:
>My question is, does everyone think that the case-insensitivity of
>Ada is a positive feature and if so why? Personally, if I see a
>variable 'aBcDe' and another one 'AbCdE' they don't immediately strike
>me as being the same and is therefore confusing when they are.

Why care? This is one of the lesser concerns about a language.