Re: Student views on Ada

Re: Student views on Ada

[Robert Dewar]

Marin, front panel lights are for sissies! The first time I programmed
an Incoterm terminal, I had to enter a boot loader from the keyboard
one hex digit at a time, completely blind with no feedback of any kind
at all. It took 600 keypresses to enter it. Now that's REAL programming :-)

Re: Student views on Ada

[Robert I. Eachus]

    Several early machines had no "blinkenlights."  For example the
Litton/General Precision LGP-30 and the Royal McBee RPG4000 both had
oscilloscopes to let you see the register contents as they flew by on
the drum.

     But of course Real Computer Operators did it all by ear on the
Univac I.  There was a speaker, usually attached to the sign bit of
the accumulator, which allowed you to debug your program by listening
to it run.  (The same technique was used to play music on the PDP-1 in
Bldg 16 at MIT, but that was just for fun.  The 'Dip had blining
lights for debugging, and the original ddt.)
--

					Robert I. Eachus

with Standard_Disclaimer;
use  Standard_Disclaimer;
function Message (Text: in Clever_Ideas) return Better_Ideas is...

Re: Student views on Ada

[Norman H. Cohen]

In article <35s3lc$69h@gnat.cs.nyu.edu>, dewar@cs.nyu.edu (Robert Dewar)
writes: 

|> Marin, front panel lights are for sissies! The first time I programmed
|> an Incoterm terminal, I had to enter a boot loader from the keyboard
|> one hex digit at a time, completely blind with no feedback of any kind
|> at all. It took 600 keypresses to enter it. Now that's REAL programming :-)

Robert, hex digits are for sissies!  I once programmed a PC with Cassette
Basic.  It made assembly language, with its symbolic labels, seem
high-level.  Now that's REAL programming! :-)

(Unfortunately, since the PC did not have a cassette player attached, I
was unable to save the program.)

--
Norman H. Cohen    ncohen@watson.ibm.com

Re: Student views on Ada

[David Weller]

In article <35ukdh$185r@watnews1.watson.ibm.com>,
Norman H. Cohen <ncohen@watson.ibm.com> wrote:
>In article <35s3lc$69h@gnat.cs.nyu.edu>, dewar@cs.nyu.edu (Robert Dewar)
>writes: 
>
>|> Marin, front panel lights are for sissies! The first time I programmed
>|> an Incoterm terminal, I had to enter a boot loader from the keyboard
>|> one hex digit at a time, completely blind with no feedback of any kind
>|> at all. It took 600 keypresses to enter it. Now that's REAL programming :-)
>
>Robert, hex digits are for sissies!  I once programmed a PC with Cassette
>Basic.  It made assembly language, with its symbolic labels, seem
>high-level.  Now that's REAL programming! :-)
>
>(Unfortunately, since the PC did not have a cassette player attached, I
>was unable to save the program.)
>

Oh, yeah?  Well, I can write that program in THREE lines!  Standing
on one foot.  Underwater.  While making bandwidth-wasting posts to
Internet AT THE SAME TIME! 

	:-)	:-)	:-)	:-)

-- 
Proud (and vocal) member of Team Ada! (and Team OS/2)        ||This is not your
             Ada 9X -- It doesn't suck                       ||  father's Ada
For all sorts of interesting Ada 9X tidbits, run the command:||________________
"finger dweller@starbase.neosoft.com | more" (or e-mail with "finger" as subj.)
   ObNitPick: Spelling Ada as ADA is like spelling C++ as CPLUSPLUS. :-) 

Re: Student views on Ada

[CONDIC]

From: Marin David Condic, 407.796.8997, M/S 731-93
Subject: Re: Student views on Ada
Original_To:  PROFS%"SMTP@PWAGPDB"
Original_cc:  CONDIC



on Thu, 22 Sep 1994 10:17:16, Robert Dewar <dewar@CS.NYU.EDU> writes:
>
>Marin, front panel lights are for sissies! The first time I programmed
>an Incoterm terminal, I had to enter a boot loader from the keyboard
>one hex digit at a time, completely blind with no feedback of any kind
>at all. It took 600 keypresses to enter it. Now that's REAL programming :-)
>
Robert:

When I started programming, we only had punch cards and paper
tapes, (and we were damned glad to have 'em, too! ;-) Nowadays,
these kids think they've got it rough if they have to work with a
VT340 terminal instead of a workstation! In *my* youth, what we
wouldn't have given for a simple bootstrap ROM...

But then there were the *real* old timers who sneered on my
reliance on paper tape and hex keypads. In *their* time, they had
to program machines with plug-in breadboards and jumper-wires.
(and they were damned glad to have 'em, too! ;-) They could even
identify programs by how they *sounded* when the relays were
clicking. Front pannel lights and toggle switches? Us kids didn't
know how good we had it! :-)

BTW: Do you remember programming the old TI-58 calculators? Now
*there* was a sport for Real Programmers!

MDC


Marin David Condic, Senior Computer Engineer    ATT:        407.796.8997
M/S 731-93                                      Technet:    796.8997
Pratt & Whitney, GESP                           Internet:   CONDICMA@PWFL.COM
P.O. Box 109600                                 Internet:   MDCONDIC@AOL.COM
West Palm Beach, FL 33410-9600                  Internet:   4033121@MCIMAIL.COM
===============================================================================
    "Nothing in life is so exhilarating as to be shot at without
    result."

        --  Winston Churchill
===============================================================================

Re: Student views on Ada

[Bob Kitzberger]

CONDIC@PSAVAX.PWFL.COM wrote:
: In *their* time, they had
: to program machines with plug-in breadboards and jumper-wires.
: (and they were damned glad to have 'em, too! ;-) They could even
: identify programs by how they *sounded* when the relays were
: clicking.

Hmmm... I'm just a spring chicken, but doesn't everyone debug via
sound?  A coupla three years ago, I was optimizing an Ada tasking
runtime for the Hartstone tasking benchmark.  On Motorola 680x0 VME
boards, you could tell the progress of the test, and whether or not
the test had stopped, by the barely discernible frequency emitted
(as a side effect) from some circuitry on the board.  As the Hartstone
test progressed through increasing stress test levels (faster task
switches) the frequency got higher and higher... until deadlines
were finally missed and the test stopped, at which time silence
reined.  The higher the frequency, the better the Hartstone performance.

As a side note, our testing tool, TestMate, has an (optional)
predefined "epilog" routine...  if everything went fine with your
test, your Sparc'll say "PASS", otherwise it gives a more detailed
verbal status, like "fail", "exception", etc.  It is customizable, so
that you can replace any of the audio messages with something more
nastalgic, like clicking relays...  (if that doesn't make you rush out
and buy ten copies, what will?)

	.B.

--
Bob Kitzberger	        +1 (916) 274-3075	        rlk@rational.com
Rational Software Corp., 10565 Brunswick Rd. #11, Grass Valley, CA 95945

Student views on Ada

[Prof_Weber-Wulff]

A collection of student comments on Ada (We use Ada as the first language):

- A 3rd semester student commented that he has both C++ and Ada at home,
  but that he uses (Meridian) Ada when he wants to get something done
  fast - because when he finally gets it to compile it's usually right,
  as opposed to C++...

- A 7th semester student looking over the shoulder of a 2nd semester student
  doing something whizzy with the Meridian graphics packages: "I can't 
  believe you're doing that in Ada! I thought Ada was stupid and boring!"

- The students in our department have started a little newspaper (and
  asked for permission to do so, boy in my student days we just DID
  things like that!). The front page article was "ADA, oder was?", (Ada or
  what?) and included a pro and a contra position. The pro article felt
  that our insisting that Ada was too good a language to be left to the
  military was okay, and even went so far as to say that using the 
  language strengthens ones sense of responsibility - doing what you
  think is right despite what every one else says. The contra article
  felt that using Ada legitimizes the US American war machine, the technial
  aspects of the language have no relevance. The writer suspects that since
  the DoD issues the standard [little knowledge has he of Ada9X!] corrupt
  officials could misuse their power to unimaginably evil ends... and closes
  with the call to reject Ada thereby setting onesself against the desire
  for power and unreasonability... 

My comment to Meridian: I'm mad that they've stopped the student pricing 
for the DOS Ada. For 69 marks (when we ordered a class set) the students
got an LRM and a compiler, and they used them at home. What better 
advertising for the language and the company?!

--
Debora Weber-Wulff, Professorin fuer Softwaretechnik und Programmiersprachen
snail: Technische Fachhochschule Berlin, FB Informatik, 
       Luxemburgerstr. 10, 13353 Berlin, Germany
email: weberwu@tfh-berlin.de

Re: Student views on Ada

[Fred McCall]

In <34kh42$le5@sun24.tfh-berlin.de> weberwu@tfh-berlin.de Prof_Weber-Wulff writes:

>
>A collection of student comments on Ada (We use Ada as the first language):
>
>- A 3rd semester student commented that he has both C++ and Ada at home,
>  but that he uses (Meridian) Ada when he wants to get something done
>  fast - because when he finally gets it to compile it's usually right,
>  as opposed to C++...

This seems indicative of two things.  One, it supports the 'first
language preference' theory; i.e., whatever someone had as a first
language is the one they will think is best.  I don't fit that, but this
student apparently does.  Two, and perhaps more important, if the
language bashing comment is indeed the true state of affairs, it would
appear to me that learning Ada first may have taught this individual
some 'bad habits' that have led him to rely on the compiler to check
things for him tht he should be aware of himself.  I've seen this happen
frequently when Pascal programmers are first learning C.

>
>- A 7th semester student looking over the shoulder of a 2nd semester student
>  doing something whizzy with the Meridian graphics packages: "I can't 
>  believe you're doing that in Ada! I thought Ada was stupid and boring!"

One would think that a 7th semester student would be aware that one can
do anything in any language, given sufficient library support (like the
Meridian graphics package).  I think I would worry about a 7th semester
student who made such a comment.

>
>- The students in our department have started a little newspaper (and
>  asked for permission to do so, boy in my student days we just DID
>  things like that!). The front page article was "ADA, oder was?", (Ada or
>  what?) and included a pro and a contra position. The pro article felt
>  that our insisting that Ada was too good a language to be left to the
>  military was okay, and even went so far as to say that using the 
>  language strengthens ones sense of responsibility - doing what you
>  think is right despite what every one else says. The contra article
>  felt that using Ada legitimizes the US American war machine, the technial
>  aspects of the language have no relevance. The writer suspects that since
>  the DoD issues the standard [little knowledge has he of Ada9X!] corrupt
>  officials could misuse their power to unimaginably evil ends... and closes
>  with the call to reject Ada thereby setting onesself against the desire
>  for power and unreasonability... 

Both positions seem to be more oriented toward political justifications
(about the evil American war machine) than they are toward real
technical superiority as a justification.  I'd consider neither
particularly valid.


--
"Insisting on perfect safety is for people who don't have the balls to live
 in the real world."   -- Mary Shafer, NASA Ames Dryden
---------------------------------------------------------------------------
merlin@annwfn.com -- I don't speak for others and they don't speak for me.

Re: Student views on Ada

[Norman H. Cohen]

In article <85B31AAE640@annwfn.com>, merlin@annwfn.com (Fred McCall) writes: 

|>                                                            if the
|> language bashing comment is indeed the true state of affairs, it would
|> appear to me that learning Ada first may have taught this individual
|> some 'bad habits' that have led him to rely on the compiler to check
|> things for him tht he should be aware of himself.  I've seen this happen
|> frequently when Pascal programmers are first learning C.

This line of reasoning leads to the conclusion that one should never use
a spelling checker, or that pilots should not be warned of an approaching
mountainside.  A writer should be aware of correct spelling himself and a
pilot should be aware of approaching mountainsides himself.

Being aware that something is wrong when it is called to one's attention
is one thing; noticing an error--perhaps a clerical error, perhaps an
invalid but seductive line of subtle reasoning--when it's buried in a
large and complex program is something else.

Some C programmers, lacking a language that facilitates strong
consistency checks, may argue that such checks are for sissies--that Real
Programmers do not need them.  However, a compiler that performs strong
consistency checks is, like a spelling checker, an important tool for
protecting us from our imperfections.  Its use should be a part of the
state of the practice for responsible programmers, just as the use of a
safety belt is part of the state of the practice for window washers.  To
call it a bad habit is to deny that humans make errors.

Fools who make NO effort to desk-check their weekly reports to their
managers or the logic of their programs, in the belief that their
spelling checkers and compilers do it all for them, are bound to pay the
price for their laziness one day.  But that's no argument for
discrediting the reliance on tools that make manual error-checking more
efficient and more effective.

--
Norman H. Cohen    ncohen@watson.ibm.com

Re: Student views on Ada

[Laurent Gasser]

In the same vein, you may enjoy reading "Writing Solid Code" at
Microsoft Press.  Yes it is specific to C.  Yes it is edited by
Microsoft and written by one of its member.  But the spirit is quite
sound:

  Every time you find a bug, think about ways you had to catch it in 
  a systematic / automatic way.
  
Reading it is quite instructive.  But I still wonder why C is so
widely used...

In article <35kapa$1fqc@watnews1.watson.ibm.com>, ncohen@watson.ibm.com (Norman H. Cohen) writes:
|> 
|> Being aware that something is wrong when it is called to one's attention
|> is one thing; noticing an error--perhaps a clerical error, perhaps an
|> invalid but seductive line of subtle reasoning--when it's buried in a
|> large and complex program is something else.
|> 
|> Some C programmers, lacking a language that facilitates strong
|> consistency checks, may argue that such checks are for sissies--that Real
|> Programmers do not need them.  However, a compiler that performs strong
|> consistency checks is, like a spelling checker, an important tool for
|> protecting us from our imperfections.  Its use should be a part of the
|> state of the practice for responsible programmers, just as the use of a
|> safety belt is part of the state of the practice for window washers.  To
|> call it a bad habit is to deny that humans make errors.
|> 
|> --
|> Norman H. Cohen    ncohen@watson.ibm.com

-- 
Laurent Gasser (gasser@dma.epfl.ch)
Computers do not solve problems, they execute solutions.

I know very few ideas worth dying for, none is worth killing.

Re: Student views on Ada

[Fred McCall]

In <35kapa$1fqc@watnews1.watson.ibm.com> ncohen@watson.ibm.com Norman H. Cohen rambles
off talking to to nobody knows who:

>In article <85B31AAE640@annwfn.com>, merlin@annwfn.com (Fred McCall) writes: 
>
>|>                                                            if the
>|> language bashing comment is indeed the true state of affairs, it would
>|> appear to me that learning Ada first may have taught this individual
>|> some 'bad habits' that have led him to rely on the compiler to check
>|> things for him tht he should be aware of himself.  I've seen this happen
>|> frequently when Pascal programmers are first learning C.
>
>This line of reasoning leads to the conclusion that one should never use
>a spelling checker, or that pilots should not be warned of an approaching
>mountainside.  A writer should be aware of correct spelling himself and a
>pilot should be aware of approaching mountainsides himself.

No, but it does seem to lead to the conclusion that one should not be
taught to fly automatic aircraft and then expect to be able to fly the
other kind.  In fact, one would rather hope that even if taught to fly
on such an automatic aircraft that a pilot would be told what was going
on.  This apparently did not happen in this particular case (and does
not happen in general, if my experience with people is any indicator).

>
>Being aware that something is wrong when it is called to one's attention
>is one thing; noticing an error--perhaps a clerical error, perhaps an
>invalid but seductive line of subtle reasoning--when it's buried in a
>large and complex program is something else.

But knowing how to operate your tools is yet a third thing.  I assume
you have a point?

>
>Some C programmers, lacking a language that facilitates strong
>consistency checks, may argue that such checks are for sissies--that Real
>Programmers do not need them.  

These are no doubt the same C programmers who developed tools like LINT,
which they no doubt came up with because they felt they didn't need it?
Oh, one can find high school students who will argue for all sorts of
silly positions, but so what?

>However, a compiler that performs strong
>consistency checks is, like a spelling checker, an important tool for
>protecting us from our imperfections.  Its use should be a part of the
>state of the practice for responsible programmers, just as the use of a
>safety belt is part of the state of the practice for window washers.  To
>call it a bad habit is to deny that humans make errors.

Why is it that Ada advocates always have to come up with these silly
strawman arguments?  It's a bad habit to RELY on that protection (and
therefore not watch what the hell you are doing in the first place).
There's a real difference between that and the words you seem to want to
shove into my mouth.  If you really don't understand that difference,
then you are part of the problem you are expounding on.

Studies indicate that many times including 'safety features' doesn't
lead to any decrease in accidents; it just leads to people relying on
those safety features and then managing to get themselves killed when
they fail.  In other words, people wind up writing bad code *because*
they expect the compiler to protect them.  You should write good code
whether the compiler is there to protect you or not; then when you *do*
make a mistake you get some added protection from the tools.  Relying on
the tools and therefore not bothering to think about things in the first
place leads to people who can only write code if they have all that
safety checking -- in other words, people who don't know what they're
doing and routinely write bad code, then pounding on it until they can
get the tool to accept it.  

I'd rather have people who know what they're doing, thanks.

>
>Fools who make NO effort to desk-check their weekly reports to their
>managers or the logic of their programs, in the belief that their
>spelling checkers and compilers do it all for them, are bound to pay the
>price for their laziness one day.  But that's no argument for
>discrediting the reliance on tools that make manual error-checking more
>efficient and more effective.

RELIANCE on tools *should* be discredited, if it has any credit coming
in the first place.  Fools who think that relying on tools instead of
knowing what they are doing in the first place are bound to pay the
price for their ignorance one day.  Nothing is foolproof, because fools
are so ingenious.  And so it is with reliance on tools.  People can come
up with ways to do unsafe things in safe environements because they are
a lot more inventive about it than the folks who are continually trying
to surround them with enough foam so that they don't hurt themselves.

Tools are wonderful things.  Trust yourself, not the tools.  Otherwise
you are going to eventually leave a smoking hole in the ground where the
tool failed because you wrote something unsafe and expected the tool to
catch it.



--
"Insisting on perfect safety is for people who don't have the balls to live
 in the real world."   -- Mary Shafer, NASA Ames Dryden
---------------------------------------------------------------------------
merlin@annwfn.com -- I don't speak for others and they don't speak for me.

Re: Student views on Ada

[Michael Feldman]

In article <35kapa$1fqc@watnews1.watson.ibm.com>,
Norman H. Cohen <ncohen@watson.ibm.com> wrote:
>In article <85B31AAE640@annwfn.com>, merlin@annwfn.com (Fred McCall) writes: 
>
>|>                                                            if the
>|> language bashing comment is indeed the true state of affairs, it would
>|> appear to me that learning Ada first may have taught this individual
>|> some 'bad habits' that have led him to rely on the compiler to check
>|> things for him tht he should be aware of himself.  I've seen this happen
>|> frequently when Pascal programmers are first learning C.
>
>This line of reasoning leads to the conclusion that one should never use
>a spelling checker, or that pilots should not be warned of an approaching
>mountainside.  A writer should be aware of correct spelling himself and a
>pilot should be aware of approaching mountainsides himself.

It is certainly a matter of _opinion_ whether a 16 year old kid should
learn to drive first on a car with an automatic shift, power steering
and brakes, and dual air bags, or on a 1953 MG roadster (or VW Beetle)  
with none of the above. Clearly there are advantages both ways.

We have argued for decades in CS education whether students should
learn assembler first, reasoning that they cannot understand languages
until they understand computers. Clearly there is some advantage
to this, but there are (thought to be) more advantages in learning
from a highler level of abstraction down to a lower one.

Undoubtedly you have seen Pascal programmers get into trouble in C 
because they expected too much from the compiler. And I have seen
(many) C programmers get into trouble (or, rather, write lousy code)
in Ada because they never used subtypes to get the ranges checked.

I'm getting a little bored - and I'm sure you must be, too - with the
blatant religious argument, unsupported by facts or controlled studies.
Let's just stipulate that people have preferences. Some like C. Some like
Ada. Some like Scheme. Some like Smalltalk. Think of it like flavors
of ice cream. And let's stop couching preferences in pseudo-factoids
and anecdotes. It's time to cut the endless language war and get back
to work.

How does this relate to the mandate? A bit. DoD pays the piper, so DoD
has the privilege of calling the tune. If DoD prefers Ada, so be it.
Those contractors who don't like this are welcome to find another line 
of work. The ball is in DoD's court to state its preference and make
sure it is getting what our money is paying for.

Mike Feldman
------------------------------------------------------------------------
Michael B. Feldman -  chair, SIGAda Education Working Group
Professor, Dept. of Electrical Engineering and Computer Science
The George Washington University -  Washington, DC 20052 USA
202-994-5919 (voice) - 202-994-0227 (fax) - mfeldman@seas.gwu.edu (Internet)
NOTE NEW PHONE NUMBER.
"Pork is all that stuff the government gives the other guys."
------------------------------------------------------------------------

Re: Student views on Ada

[Fred McCall]

In <364b4d$itf@felix.seas.gwu.edu> mfeldman@seas.gwu.edu Michael Feldman writes:

>I'm getting a little bored - and I'm sure you must be, too - with the
>blatant religious argument, unsupported by facts or controlled studies.
>[...] It's time to cut the endless language war and get back
>to work.

Quite.  As I'm sure you recall, I periodically display annoyance at this
religious attitude toward 'Language A' or 'Language B'.

>
>How does this relate to the mandate? A bit. DoD pays the piper, so DoD
>has the privilege of calling the tune. If DoD prefers Ada, so be it.
>Those contractors who don't like this are welcome to find another line 
>of work. The ball is in DoD's court to state its preference and make
>sure it is getting what our money is paying for.      

Unfortunately, it isn't.  The ball is in Congress' court, so long as the
Mandate law is on the books.  Right now, DoD doesn't have a lot of
choice, either.


--
"Insisting on perfect safety is for people who don't have the balls to live
 in the real world."   -- Mary Shafer, NASA Ames Dryden
---------------------------------------------------------------------------
merlin@annwfn.com -- I don't speak for others and they don't speak for me.

Re: Student views on Ada

[Norman H. Cohen]

In article <85C41AD374C@annwfn.com>, merlin@annwfn.com (Fred McCall) writes: 
|> In <364b4d$itf@felix.seas.gwu.edu> mfeldman@seas.gwu.edu Michael Feldman
writes: 

|> Quite.  As I'm sure you recall, I periodically display annoyance at this
|> religious attitude toward 'Language A' or 'Language B'.

Didn't you mean 'Language A' or 'Language C'?

:-)

--
Norman H. Cohen    ncohen@watson.ibm.com

Re: Student views on Ada

[Prof Weber-Wulff]

Fred McCall (merlin@annwfn.com) wrote:
: In <34kh42$le5@sun24.tfh-berlin.de> weberwu@tfh-berlin.de I wrote:

: >
: >A collection of student comments on Ada (We use Ada as the first language):
: >
: >- A 3rd semester student commented that he has both C++ and Ada at home,
: >  but that he uses (Meridian) Ada when he wants to get something done
: >  fast - because when he finally gets it to compile it's usually right,
: >  as opposed to C++...

: This seems indicative of two things.  One, it supports the 'first
: language preference' theory; i.e., whatever someone had as a first
: language is the one they will think is best.

This particular student had FORTRAN as a first language, he had 4 years
programming experience before coming to us to get a degree.

:  I don't fit that, 

I don't either, but I never really understood the first languages I
programmed in. Pascal was the first language I understood, which I do
feel contributed to my difficulties in learning Lisp ;-)

: it would
: appear to me that learning Ada first may have taught this individual
: some 'bad habits' that have led him to rely on the compiler to check
: things for him tht he should be aware of himself.  I've seen this happen
: frequently when Pascal programmers are first learning C.

Not necessarily. Typos are not bad habits per se, but when a language 
permits minimal difference (== instead of =) to have a valid syntax, you
can get into problems very easily. I also believe that one can easily get
into <insert language here>-mode and make careless mistakes in one language
that would not be made in another. One gets so used to using integer types
for everything and suddenly one is comparing apple sizes and orange weights.

: >- A 7th semester student looking over the shoulder of a 2nd semester student
: >  doing something whizzy with the Meridian graphics packages: "I can't 
: >  believe you're doing that in Ada! I thought Ada was stupid and boring!"

: One would think that a 7th semester student would be aware that one can
: do anything in any language, given sufficient library support (like the
: Meridian graphics package). 

I wish... honestly, some things get so set in peoples minds, they refuse to
see things in a different light. I've had colleagues sniff their noses at
Logo as a "children's language", not realizing that it is possible to
do much, much more than just turtle graphics in it.

: >- The students in our department have started a little newspaper (and
[long political stuff deleted]

: Both positions seem to be more oriented toward political justifications
: (about the evil American war machine) than they are toward real
: technical superiority as a justification.  I'd consider neither
: particularly valid.

Of course! But they're thinking about it and *writing* [at times it seems
we need to use brute force to get them to write complete sentences].
We don't teach Ada because it is "superior" - I honestly don't think
that one can construct a partial order of languages! But it lets us
teach the things we think are important without making us waste time
explaining intricate bits of syntax.

--
Debora Weber-Wulff, Professorin fuer Softwaretechnik und Programmiersprachen
snail: Technische Fachhochschule Berlin, FB Informatik, 
              Luxemburgerstr. 10, 13353 Berlin, Germany
email: weberwu@tfh-berlin.de            http://sun24.tfh-berlin.de:8000/dww/