larryc@poe.jpl.nasa.gov (Larry Carroll) (06/25/91)
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++.sampson@cod.NOSC.MIL (Charles H. Sampson) (06/25/91)
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
jls@netcom.COM (Jim Showalter) (06/26/91)
>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++. *
dhesi@cirrus.com (Rahul Dhesi) (06/26/91)
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
fisher@edwards-vax.af.mil (06/26/91)
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" ---------------------------------------------------------------------------
andrewd@chook.adelaide.edu.au (Andrew Dunstan) (06/26/91)
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 # # #######################################################################
mfeldman@seas.gwu.edu (Michael Feldman) (06/26/91)
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
doug@saturn.cs.swin.OZ.AU (Doug_Grant) (06/26/91)
>|> 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)
pattis@june.cs.washington.edu (Richard Pattis) (06/27/91)
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."
jls@netcom.COM (Jim Showalter) (06/27/91)
> 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++. *
g_harrison@vger.nsu.edu (George C. Harrison, Norfolk State University) (06/27/91)
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....
jls@netcom.COM (Jim Showalter) (06/27/91)
[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++. *
orville@weyrich.UUCP (Orville R. Weyrich) (06/27/91)
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) -------------------------------------- ******************************
neeri@iis.ethz.ch (Matthias Ulrich Neeracher) (06/27/91)
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_
sampson@cod.NOSC.MIL (Charles H. Sampson) (06/28/91)
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
mfeldman@seas.gwu.edu (Michael Feldman) (06/28/91)
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
mfeldman@seas.gwu.edu (Michael Feldman) (06/28/91)
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
mfeldman@seas.gwu.edu (Michael Feldman) (06/28/91)
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
jls@netcom.COM (Jim Showalter) (06/28/91)
>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++. *jls@netcom.COM (Jim Showalter) (06/28/91)
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++. *
neeri@iis.ethz.ch (Matthias Ulrich Neeracher) (06/28/91)
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_
neeri@iis.ethz.ch (Matthias Ulrich Neeracher) (06/28/91)
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_
ok@goanna.cs.rmit.oz.au (Richard A. O'Keefe) (06/30/91)
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.
mfeldman@seas.gwu.edu (Michael Feldman) (07/01/91)
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