A Pascal Subset of Ada (was: Why Ada is Failing Socially)

A Pascal Subset of Ada (was: Why Ada is Failing Socially)

[Larry Carroll]

Someone said something like
> A better comparison would be between Pascal & Ada.

I came to Ada from a Pascal background, & never understood why people thought
it a complex or difficult language.  I was writing working code within a
week.  Within a month the basics had become engrained in my thinking so I
automatically used syntax correctly most of the time.  I started using
features like packages, which I thought (& still think) was a marvelous
invention & had absolutely no trouble with.  Other parts of Ada caused me
more problems, & I've never used tasking.

One of the biggest mistakes of AJPO (or whoever made the decision) was to
disallow Ada subsets.  I think they should have allowed ONE subset, 
corresponding roughly to Pascal and including packages.  We would have had 
inexpensive & commercially useful compilers much earlier, & disposed of the 
"Ada is huge" mindset.

As a footnote, when I later learned C I organized programs as much like 
packages as I could with the limited capabilites of C.  I ended up with 
patterns that look a bit like C++.

Re: A Pascal Subset of Ada (was: Why Ada is Failing Socially)

[Charles H. Sampson]

In article <1991Jun25.022849.18078@jpl-devvax.jpl.nasa.gov> larryc@poe.jpl.nasa.gov (Larry Carroll) writes:

>One of the biggest mistakes of AJPO (or whoever made the decision) was to
>disallow Ada subsets.  I think they should have allowed ONE subset, 
>corresponding roughly to Pascal and including packages.  ...

     What was disallowed was creating a subset (or superset) compiler and
calling it Ada.  Even in the days when the name Ada was trademarked it would
have been possible to write and market a compiler for a Pascal subset of Ada,
provided it was called something like PasAda and no attempt was made to pass
it off as "an Ada compiler".  (My opinion.  I'm not a lawyer.)

     By the way, in the early 80s I tried to define a Pascal subset of Ada.
I found it a non-trivial exercise.  The problem was, I didn't want to in-
clude generics, but that is the only way you can do I/O.  Of the several
"solutions" I came up with to this dilemma, none really satisfied me.

                                 Charlie

Re: A Pascal Subset of Ada (was: Why Ada is Failing Socially)

[Jim Showalter]

>     By the way, in the early 80s I tried to define a Pascal subset of Ada.
>I found it a non-trivial exercise.  The problem was, I didn't want to in-
>clude generics,

Why on earth not?
-- 
*** LIMITLESS SOFTWARE, Inc: Jim Showalter, jls@netcom.com, (408) 243-0630 ****
*Proven solutions to software problems. Consulting and training on all aspects*
*of software development. Management/process/methodology. Architecture/design/*
*reuse. Quality/productivity. Risk reduction. EFFECTIVE OO usage. Ada/C++.    *

Re: A Pascal Subset of Ada (was: Why Ada is Failing Socially)

[Orville R. Weyrich]

In article <1991Jun26.203828.11797@netcom.COM> jls@netcom.COM (Jim Showalter) writes:
>>     By the way, in the early 80s I tried to define a Pascal subset of Ada.
>>I found it a non-trivial exercise.  The problem was, I didn't want to in-
>>clude generics,
>
>Why on earth not?

It may be of some value to consider the early history of Janus/Ada. Early
releases dis not provide generics and had to use special hacks for I/O.

Somewhat later versions provided generics that only supported instantiation
of the standard I/O routines.

Finally, full generic support was introduced.

The bottom line is, without generics you must provide some special-case
I/O, which may in turn limit the data typeing facilities which you use,
or else force you to do things that are not strictly compliant with the Ada
standard (i.e. weaken type checking for I/O routines).

In the balance, I would like to see a cheap, floppy-disk based Ada
subset with a power comparable to Turbo Pascal 4.0. It would provide
a better starting point for teaching full Ada than Turbo Pascal, Modula-2,
etc. does. Since neither of these languages are well standardized, IMHO it
would be hard to argue in favor of them against a subset of Ada with a clear
upgrade route to full standard Ada.



--------------------------------------           ******************************
Orville R. Weyrich, Jr., Ph.D.                   Certified Systems Professional
Internet: orville%weyrich@uunet.uu.net             Weyrich Computer Consulting
Voice:    (602) 391-0821                         POB 5782, Scottsdale, AZ 85261
Fax:      (602) 391-0023                              (Yes! I'm available)
--------------------------------------           ******************************

Re: A Pascal Subset of Ada (was: Why Ada is Failing Socially)

[Charles H. Sampson]

In article <1991Jun26.203828.11797@netcom.COM> jls@netcom.COM (Jim Showalter) writes:
>>     By the way, in the early 80s I tried to define a Pascal subset of Ada.
>>I found it a non-trivial exercise.  The problem was, I didn't want to in-
>>clude generics,

[The above was from me.]

>Why on earth not?

     Because the point of the exercise was to define a Pascal subset of Ada.
By this I meant a subset that had roughly the power of Pascal, but in Ada's
syntax and semantics.  There were two points to this exercise: To clean up
Pascal's known shortcomings (e.g., unblocked if, lack of modular compilation)
and to end up with a subset for which a compiler could be written for a rea-
sonably low cost.  There was no precise dividing line between "cleaning up"
and "adding useful new features", of course, so figurative coins were often
flipped.  However, it was easy to exclude generics on the grounds of compiler
costs.

                                 Charlie

Re: A Pascal Subset of Ada (was: Why Ada is Failing Socially)

[George C. Harrison, Norfolk State University]

In article <3155@cod.NOSC.MIL>, sampson@cod.NOSC.MIL (Charles H. Sampson) writes:
> In article <1991Jun25.022849.18078@jpl-devvax.jpl.nasa.gov> larryc@poe.jpl.nasa.gov (Larry Carroll) writes:
> 
>>One of the biggest mistakes of AJPO (or whoever made the decision) was to
>>disallow Ada subsets.  I think they should have allowed ONE subset, 
>>corresponding roughly to Pascal and including packages.  ...
> 
>      ...in the early 80s I tried to define a Pascal subset of Ada.
> I found it a non-trivial exercise.  The problem was, I didn't want to in-
> clude generics, but that is the only way you can do I/O.  Of the several
> "solutions" I came up with to this dilemma, none really satisfied me.
> 
>                                  Charlie

I never thought about the I/O stuff.  I had always felt that SubAda == Pascal
could be done.  

You might have wanted to name it   "Ada--"

George....

Re: A Pascal Subset of Ada (was: Why Ada is Failing Socially)

[Michael Feldman]

In article <1133.2868ee55@vger.nsu.edu> g_harrison@vger.nsu.edu (George C. Harrison, Norfolk State University) writes:
>
>You might have wanted to name it   "Ada--"
>

Ada-- has existed for years. It's called Modula-2. And just what Wirth left
out is all the good stuff that makes Ada such a pleasure by comparison
(see my previous post re: M2).

Mike

Re: A Pascal Subset of Ada (was: Why Ada is Failing Socially)

[Matthias Ulrich Neeracher]

In article <3395@sparko.gwu.edu> mfeldman@seas.gwu.edu (Michael Feldman) writes:
>In article <1133.2868ee55@vger.nsu.edu> g_harrison@vger.nsu.edu (George C. Harrison, Norfolk State University) writes:
>>
>>You might have wanted to name it   "Ada--"
>>
>
>Ada-- has existed for years. It's called Modula-2. And just what Wirth left
>out is all the good stuff that makes Ada such a pleasure by comparison
>(see my previous post re: M2).

[Another post bearing little relevance to Ada -- sorry:]

In all fairness, you might mention that:

- There exist very fast compilers for Modula-2 running in 128K of RAM on a 12
  year old workstation. I doubt it would be a "pleasure" to use Ada on a Lilith.
  While the above concern is clearly academic, it is my impression that for
  todays PCs, compilation speed and memory consumption of Ada compilers are
  still just barely acceptable (At least one Ada compiler for the Macintosh is
  just a very slow C preprocessor).

- One think that makes Modula-2 a pleasure to work with, in comparison with
  Ada, are procedure variables. (I know, I know. I just couldn't resist :-)

- Although this is impossible to qualify, I find that Modula-2 has an
  aesthetically very pleasing overall syntax, while some Ada syntax details don't
  look as nice (With all due respect to the Principle of Uniform Referents or
  whatever it is called, I don't like a.all := b.all).

Matthias

-----
Matthias Neeracher                                      neeri@iis.ethz.ch
   "These days, though, you have to be pretty technical before you can 
    even aspire to crudeness." -- William Gibson, _Johnny Mnemonic_

Re: A Pascal Subset of Ada (was: Why Ada is Failing Socially)

[Jim Showalter]

>You might have wanted to name it   "Ada--"

Or (C++)++. ;-)
-- 
*** LIMITLESS SOFTWARE, Inc: Jim Showalter, jls@netcom.com, (408) 243-0630 ****
*Proven solutions to software problems. Consulting and training on all aspects*
*of software development. Management/process/methodology. Architecture/design/*
*reuse. Quality/productivity. Risk reduction. EFFECTIVE OO usage. Ada/C++.    *

Re: A Pascal Subset of Ada (was: Why Ada is Failing Socially)

[Richard A. O'Keefe]

In article <1133.2868ee55@vger.nsu.edu>, g_harrison@vger.nsu.edu (George C. Harrison, Norfolk State University) writes:
> I never thought about the I/O stuff.  I had always felt that SubAda == Pascal
> could be done.  You might have wanted to name it   "Ada--"

With all this discussion about wanting a small cheapo version of Ada for
the educational environment, I'm surprised that no-one has mentioned
SmallAda.  Here's part of a posting from last year:

    From mfeldman@seas.gwu.edu@munnari.oz Tue Sep 11 13:20:16 1990
    Path: goanna!munnari.oz.au!uunet!seas.gwu.edu!mfeldman
    From: mfeldman@seas.gwu.edu (Michael Feldman)
    Newsgroups: comp.lang.ada
    Subject: Announcing (free) distribution of SmallAda 1990
    Message-ID: <2107@sparko.gwu.edu>
    Date: 11 Sep 90 03:20:16 GMT
    Reply-To: mfeldman@seas.gwu.edu (Michael Feldman)
    Organization: The George Washington University, Washington D.C.
    Lines: 205

    F R E E  S O F T W A R E  A N N O U N C E M E N T
    SmallAda 1990 for Apple Macintosh and IBM-PC family computers
    ...
    SmallAda is a compiler/interpreter for a part of the Ada language, namely
    the "Pascal subset" plus the Ada tasking support. It is not intended
    ever to be a full Ada compiler, rather a vehicle for teaching, learning,
    and experimenting with concurrent programming. The compiler is quite
    fast, producing P-code which is then interpreted by the interpreter.

    Both the Mac and DOS versions are integrated systems, complete with editor
    and window-oriented runtime monitor. The Mac editor is like any Mac ASCII
    editor, supporting cut/copy/paste and the like. The Mac version is Mac-like.

    The DOS version editor is Turbo-Pascal or WordStar-like, including pull-
    down menus for editor and compiler commands. No mouse support is provided
    at this time.

Price: $0.  Is there something wrong with SmallAda, or what?

-- 
I agree with Jim Giles about many of the deficiencies of present UNIX.

Re: A Pascal Subset of Ada (was: Why Ada is Failing Socially)

[Michael Feldman]

In article <6570@goanna.cs.rmit.oz.au> ok@goanna.cs.rmit.oz.au (Richard A. O'Keefe) writes:

     SmallAda is a compiler/interpreter for a part of the Ada language, namely
     the "Pascal subset" plus the Ada tasking support. It is not intended
     ever to be a full Ada compiler, rather a vehicle for teaching, learning,
     and experimenting with concurrent programming. The compiler is quite
 
>Price: $0.  Is there something wrong with SmallAda, or what?

Hmmm. The first line says it all. There's nothing wrong with SmallAda except
that it ain't Ada, not even close. No packages, generics, pointer types,
etc. etc. Just Pascal + tasking, designed as a teaching tool. Great system,
by the way. But no substitute for the real thing.

Dislaimer: I and my students developed the li'l sucker.

If anyone wants a copy, send e-mail. It's available by ftp now, but I'm still
asking for a simple application to be filled in.

Mike

Re: A Pascal Subset of Ada (was: Why Ada is Failing Socially)

[Jim Showalter]

>One of the biggest mistakes of AJPO (or whoever made the decision) was to
>disallow Ada subsets.  I think they should have allowed ONE subset, 
>corresponding roughly to Pascal and including packages.

There was no need--Modula-2 already existed... ;-)
-- 
*** LIMITLESS SOFTWARE, Inc: Jim Showalter, jls@netcom.com, (408) 243-0630 ****
*Proven solutions to software problems. Consulting and training on all aspects*
*of software development. Management/process/methodology. Architecture/design/*
*reuse. Quality/productivity. Risk reduction. EFFECTIVE OO usage. Ada/C++.    *

Re: A Pascal Subset of Ada (was: Why Ada is Failing Socially)

[Michael Feldman]

In article <1991Jun25.201958.13285@netcom.COM> jls@netcom.COM (Jim Showalter) writes:
>>One of the biggest mistakes of AJPO (or whoever made the decision) was to
>>disallow Ada subsets.  I think they should have allowed ONE subset, 
>>corresponding roughly to Pascal and including packages.
>
>There was no need--Modula-2 already existed... ;-)

Well, not quite. Wirth's first edition appeared in 1982, contemporaneous with
the Ada standard-adoption process. M2 was little known till the 2nd ed.,
at least a year later.

Having translated a book _from_ Ada _to_ Modula-2, I can say from hard
personal experience that Modula-2 is really Ada-- :-).

Seriously, the biggest differences (other than the lack of generics) are:

1. Ada guarantees pointers initialized to null, M2 does not (BIG convenience).
2. Ada allows multidimensional unconstrained arrays, M2 does not (BIG
   convenience in writing matrix handlers).
3. Ada does not restrict the return type of a function, M2 has the outdated
   Pascal rule restricting function returns to scalar types. (BIG convenience
   for those who like functional notation).
4. Ada does not restrict the form of a private type; M2 restricts it to
   pointers (BIG convenience for those who believe that use of pointers
   should be limited to linked structures, by and large).
5. Ada allows overloaded subprogram names, M2 does not (e.g. the I/O
   library in M2 has WriteInt, WriteReal, WriteString, WriteCard, WriteFoo,
   WriteBar, etc. etc. In Ada you can call them all PUT).

M2 has substantial portability problems, by the way. Especially in the
libraries.

As for the "Pascal subset + packages" issue: both TeleSoft and Janus/Ada
sold "incomplete" implementations for years. Essentially, both were missing
generics and most of tasking. As far as I know, DoD never complained. These 
systems were quite readily available and in wide use. My department trained 
HUNDREDS of students on the TeleSoft VMS and VM interim systems. So let's get 
the facts straight. No, DoD wouldn't VALIDATE a partial implementation, but
the assertion that DoD squelched these is just plain BS. Only validated
(or at least validatable) compilers are currently being sold because that
is what the market demands, including educators. Please, guys - validation
(or at least validatability) is a part of the Ada culture most of us wouldn't
give up. I'd love it if the behavior of compilers for other languages were
as dependable as it is for Ada.

[By "validatability" I mean a compiler that has at least passed the current
ACVC in-house, even without a DoD site visit. This is enough for me. The
site visit is EXPENSIVE. I will take the word of a vendor unless he is proved
to be lying. DoD can't afford to, which is why they use the 5-sided 
certification mark these days. But it's quite legal to sell a compiler
called Ada, even if it doesn't carry the mark (has been since '88).]

By the way - "subsets" will be effectively a part of Ada9x, in the sense
that there will be a core language with "annexes" containing e.g. realtime,
info. systems, graphics, rep specs, etc. Not all compilers will be required
to support all annexes. So the subset fans will get their way in the end.
(Of course, they may STILL argue that the _required_ subset is too big,
but some people are impossible to satisfy...)

Mike

Re: A Pascal Subset of Ada (was: Why Ada is Failing Socially)

[Jim Showalter]

[accurate and detailed description of deficiencies of Modula-2 relative
 to Ada deleted]

I was just kidding, Mike! Surely you know by now I'm a die-hard Ada fan.
Modula-2 was an interesting way-station on the road to software engineering
languages, but not an end in itself.
-- 
*** LIMITLESS SOFTWARE, Inc: Jim Showalter, jls@netcom.com, (408) 243-0630 ****
*Proven solutions to software problems. Consulting and training on all aspects*
*of software development. Management/process/methodology. Architecture/design/*
*reuse. Quality/productivity. Risk reduction. EFFECTIVE OO usage. Ada/C++.    *

Re: A Pascal Subset of Ada (was: Why Ada is Failing Socially)

[Matthias Ulrich Neeracher]

In article <1991Jun27.074515.9755@netcom.COM> jls@netcom.COM (Jim Showalter) writes:
>Modula-2 was an interesting way-station on the road to software engineering
>languages, but not an end in itself.

I wish a similiar conclusion would arise from the Ada experience.

Matthias

-----
Matthias Neeracher                                      neeri@iis.ethz.ch
   "These days, though, you have to be pretty technical before you can 
    even aspire to crudeness." -- William Gibson, _Johnny Mnemonic_

Re: A Pascal Subset of Ada (was: Why Ada is Failing Socially)

[Michael Feldman]

In article <NEERI.91Jun27142501@iis.ethz.ch> neeri@iis.ethz.ch (Matthias Ulrich Neeracher) writes:
>In article <1991Jun27.074515.9755@netcom.COM> jls@netcom.COM (Jim Showalter) writes:
>>Modula-2 was an interesting way-station on the road to software engineering
>>languages, but not an end in itself.
>
>I wish a similiar conclusion would arise from the Ada experience.
>
Oh, it will, eventually. The only unchanging aspect of the computer indystry
is that it's always changing. I have no illusions that eventually Ada will
be seen as very primitive (as will C++). If we disagree, it's probably
about the time-frame. I'll stick to Ada for now, thank you.

Mike

Re: A Pascal Subset of Ada (was: Why Ada is Failing Socially)

[Jim Showalter]

neeri@iis.ethz.ch (Matthias Ulrich Neeracher) writes:

>In article <1991Jun27.074515.9755@netcom.COM> jls@netcom.COM (Jim Showalter) writes:
>>Modula-2 was an interesting way-station on the road to software engineering
>>languages, but not an end in itself.

>I wish a similiar conclusion would arise from the Ada experience.

Perhaps it will--as soon as something better comes along. What do you suggest?
-- 
*** LIMITLESS SOFTWARE, Inc: Jim Showalter, jls@netcom.com, (408) 243-0630 ****
*Proven solutions to software problems. Consulting and training on all aspects*
*of software development. Management/process/methodology. Architecture/design/*
*reuse. Quality/productivity. Risk reduction. EFFECTIVE OO usage. Ada/C++.    *

Re: A Pascal Subset of Ada (was: Why Ada is Failing Socially)

[Matthias Ulrich Neeracher]

In article <1991Jun27.235212.21155@netcom.COM> jls@netcom.COM (Jim Showalter) writes:
>neeri@iis.ethz.ch (Matthias Ulrich Neeracher) writes:
>
>>In article <1991Jun27.074515.9755@netcom.COM> jls@netcom.COM (Jim Showalter) writes:
>>>Modula-2 was an interesting way-station on the road to software engineering
>>>languages, but not an end in itself.
>
>>I wish a similiar conclusion would arise from the Ada experience.
>
>Perhaps it will--as soon as something better comes along. What do you suggest?

[Sorry for wasting the bandwidth of this group for discussion on other languages]

I don't think there is currently a language that handles everything Ada does as
well. On the other hand, I believe there are several languages (Eiffel for
instance) that handle certain aspects of Ada better. There are also some
languages that can't be matched by Ada for special tasks. I don't hope there's
anyone who would use Ada for typical tasks suited for Scheme, Prolog, ML, or
PostScript (would you rather use Ada as a page description language ?-). I'm
quite sure that by the year 2000, a language will exist that is simply better
than Ada. But in the meantime, it seems reasonable to use the best that is
available :-) 
   But what I'm afraid of is that Ada will stay around long after it is found
to be inadequate, that it will become the FORTRAN of the 3rd millenium.

Matthias

-----
Matthias Neeracher                                      neeri@iis.ethz.ch
   "These days, though, you have to be pretty technical before you can 
    even aspire to crudeness." -- William Gibson, _Johnny Mnemonic_

Re: A Pascal Subset of Ada (was: Why Ada is Failing Socially)

[Michael Feldman]

In article <1991Jun27.074515.9755@netcom.COM> jls@netcom.COM (Jim Showalter) writes:
>[accurate and detailed description of deficiencies of Modula-2 relative
> to Ada deleted]
>
>I was just kidding, Mike! Surely you know by now I'm a die-hard Ada fan.
>Modula-2 was an interesting way-station on the road to software engineering
>languages, but not an end in itself.

Of course I knew you were kidding. But I thought outlining some of the
"little" differences would help other readers to understand how well-
thought-out Ada is, in the main, and what a pleasure it is to use compared
with the alternatives I can think of.

I give an exam problem quite frequently on the "too many notes" theme.
Students must, for three different languages, outline two features that
could be eliminated without having a disastrous effect on what could be 
done with the language. Everything is so integrated in Ada that it's
quite hard to do. Tasking is orthogonal, but almost nothing else is.

Mike

Re: A Pascal Subset of Ada (was: Why Ada is Failing Socially)

[Rahul Dhesi]

In <1991Jun25.022849.18078@jpl-devvax.jpl.nasa.gov>
larryc@poe.jpl.nasa.gov (Larry Carroll) writes:

>One of the biggest mistakes of AJPO (or whoever made the decision) was to
>disallow Ada subsets.  I think they should have allowed ONE subset, 
>corresponding roughly to Pascal...

In fact the AJPO did not disallow subsets of Ada.  They only disallowed
such subsets from being sold under the name "Ada".  They did not
disallow any subset of Ada from being called "PL/17" or "Modula-5" or
even "ASOA" ("a subset of Ada").

The only restriction imposed by AJPO at that time was that if you
called a language "Ada" (registered trade mark), you had to make sure
it *was* Ada, through either a certification procedure, or by having
gone through a certification procedure, or by making a statement that
you were *intending* to undergo the certification procedure.  Even that
mild restriction was eliminated a couple of years ago.
-- 
Rahul Dhesi <dhesi@cirrus.COM>
UUCP:  oliveb!cirrusl!dhesi

Re: A Pascal Subset of Ada (was: Why Ada is Failing Socially)

[fisher]

In article <1991Jun25.022849.18078@jpl-devvax.jpl.nasa.gov>, larryc@poe.jpl.nasa.gov (Larry Carroll) writes:
> 
> One of the biggest mistakes of AJPO (or whoever made the decision) was to
> disallow Ada subsets.  I think they should have allowed ONE subset, 
> corresponding roughly to Pascal and including packages.  We would have had 
> inexpensive & commercially useful compilers much earlier, & disposed of the 
> "Ada is huge" mindset.
> 

Actually, the original JANUS STUDENT compiler (NON VALIDATED) was essentially
just that....I found it terrible.  I was using it for an Ada class, and
everytime I wanted to try out a neat feature in Ada, it wouldn't work.  It was
quite frustrating to try things like:

	- Overloading Operators
	- Auto-backlinking of pointers on node creation
	- Tasking

When everytime I attempted something, the compiler didn't support it.  I
thought a really neat to try out some generics with overloaded operators;
create a class for "imaginary", with a package for imaginary overloading all of
the operators (+, -, *, etc) which would do the math for the imaginary numbers,
and return the expected results.  Then apply a generic package to type
imaginary for something and see how well it worked.  Unfortunately, the
overloading of operators did not work at all, and I never satisfied myself that
the generics even worked!

I'm sorry, my feeling is that Ada should be Ada should be Ada, no subsets, no
supersets.  When teaching it to beginning programmers, teach the "pascal
subset" by all means, then expand on it.  When teaching engineers who know
about software development/engineering, infuse them with the Ada philosophy of
project development, and teach the unique features Ada provides.

I was unfortunate enough to have attended a class that thought Ada as a first
language, with only the last few weeks really getting into Ada specific
features.  The tragedy was that while the class was being taught at a junior
college, 28 out of 30 students were computer professionals or at least
engineers familiar with programming!  Of the two full time students in
attendance, they were both familiar with programming, as having a previous
langauge was a prerequisite for the class!  I feel it was a short coming of the
instructor to teach the class in this form.  Combined with absolutely terrible
equipment and the brain-dead non-validated Ada compiler, I felt the class was
barely more than a waste of my time!

To really learn Ada, I guess I'll have to write a full software package of some
kind myself.  I have an idea of what I want to write, but  no time ...(sigh)!

P.S. I've since bought the Meridian Ada for $149.00, and am ecstatic with the
product!  

-- 
---------------------------------------------------------------------------
  Lawrence Fisher                Internet: fisher@edwards-vax.af.mil
  Digital Equipment Corporation                         ^
  Principal Software Specialist  Currently working here | (Edwards AFB, CA)
  Specializing in Realtime       
  Disclaimer:  I don't speak for Digital or the U. S. Air Force
    "Bomb Number 20, you're out of the bomb bay again"
---------------------------------------------------------------------------

Re: A Pascal Subset of Ada (was: Why Ada is Failing Socially)

[Andrew Dunstan]

In article <1991Jun25.022849.18078@jpl-devvax.jpl.nasa.gov>,
larryc@poe.jpl.nasa.gov (Larry Carroll) writes:
|> Someone said something like
|> > A better comparison would be between Pascal & Ada.
|> 
|> I came to Ada from a Pascal background, & never understood why people
thought
|> it a complex or difficult language.  I was writing working code within a
|> week.  Within a month the basics had become engrained in my thinking so I
|> automatically used syntax correctly most of the time.  I started using
|> features like packages, which I thought (& still think) was a marvelous
|> invention & had absolutely no trouble with.  Other parts of Ada caused me
|> more problems, & I've never used tasking.
|> 

Actually, it's better than that. I recently wrote a reasonably substantial
program in Pascal, for a variety of reasons. I found that my Pascal code was 
much better than it used to be, largely because of the way Ada makes me
write code, and I have got used to that.

|> One of the biggest mistakes of AJPO (or whoever made the decision) was to
|> disallow Ada subsets.  I think they should have allowed ONE subset, 
|> corresponding roughly to Pascal and including packages.  We would have had 
|> inexpensive & commercially useful compilers much earlier, & disposed of the 
|> "Ada is huge" mindset.

This "Ada is too big" stuff is bunk. You just use the bits you want.
Still, a reasobale subset compiler would have to include generics IMHO,
or you would be too hamstrung. Leaving out tasking would be OK.

#######################################################################
#  Andrew Dunstan                   #   There's nothing good or bad   #
#  Department of Computer Science   #   but thinking makes it so.     #
#  University of Adelaide           #                                 #
#  South Australia                  #          - Shakespeare          #
#  net: andrewd@cs.adelaide.edu.au  #                                 #
#######################################################################

Re: A Pascal Subset of Ada (was: Why Ada is Failing Socially)

[Doug_Grant]

>|> One of the biggest mistakes of AJPO (or whoever made the decision) was to
>|> disallow Ada subsets.  I think they should have allowed ONE subset, 
>|> corresponding roughly to Pascal and including packages.  We would have had 
>|> inexpensive & commercially useful compilers much earlier, & disposed of the 
>|> "Ada is huge" mindset.

The issue is not whether subsets are allowed or not, but rather
whether a compiler for the Pascal subset (whatever that is) could be
used productively for a first course in Ada. Having taught Ada as a
first language for 2 years now, to a diverse group of students of
variable ability, I am convinced that a VERY CHEAP (or FREE) compiller
for the Pascal subset that will run on the old 8088 machines that some
of my students have (yes, without hard disks), would be worthwhile.

I ussed to be, but now am not, sure that we need to cover (Ada \
Pascal) in the first course.


Doug Grant(Swinburne Inst of Tech, Melbourne, Australia)
(apologies for my mis-bahaving keyboard)

Re: A Pascal Subset of Ada (was: Why Ada is Failing Socially)

[Richard Pattis]

In article <1822@stan.xx.swin.oz.au> doug@saturn.cs.swin.OZ.AU (Doug_Grant) writes:
>
>The issue is not whether subsets are allowed or not, but rather
>whether a compiler for the Pascal subset (whatever that is) could be
>used productively for a first course in Ada. Having taught Ada as a
>first language for 2 years now, to a diverse group of students of
>variable ability, I am convinced that a VERY CHEAP (or FREE) compiller
>for the Pascal subset that will run on the old 8088 machines that some
>Pascal) in the first course.
  Allow me to disagree. I have taught Ada in CS-1 and CS-2 to over a thousand
students. By week 15 my students have learned, and are using when they write
their programs: exception handling, unconstrained arrays, generic subprograms
and packages, private types, and operator overloading.  I will not discuss
the difficulties in creating a coherent and consistent Ada subset (such a
discussion has already appeared in this forum).

  Sure, an Ada subset compiler for an 8088 that is cheap is better than
nothing. But the availability of such a product would not support my
goals in teaching Ada. What is more important is the availability of
full Ada compilers that are as good and as cheap as as Pascal/C/C++
compilers for a wide variety of computing platforms.

  Of course, this all assumes that we want Ada taught at the undergraduate
level: this sentiment is not universal in the Ada community.

Rich Pattis

PS: When I taught Pascal and Modula-2 at this level, I always taught a subset
of these languages: the really important, powerful, and useful parts. I
continue this approach when teaching Ada.

-- 
------------------------------------------------------------------------------
  Richard E. Pattis			"Programming languages are like
  Department of Computer Science	 pizzas - they come in only "too"
    and Engineering			 sizes: too big and too small."