Ada - Where to get programs and books

Ada - Where to get programs and books

[GROSZ. STEVE]

I have a feeling this is going to be a old/stupid questions for everyone out 
there, but where would I find the program Ada so I can practice/learn the 
language and who can suggest some good books for learning the language.  I'
ve played with C before and didn't find much enjoyment with that. I have 
heard quite a bit about Ada and thought I would give it a try. 

Any suggestions would be appreciated.

	* Steve Grosz	
		GROS1954@VARNEY.IDBSU.EDU

Re: Ada - Where to get programs and books (long)

[Michael Feldman]

An Annotated Sampling of Ada-Oriented Textbooks

September 1994       

Michael B. Feldman
Department of Electrical Engineering and Computer Science
The George Washington University
Washington, DC 20052
(202) 994-5919 (voice)
(202) 994-0227 (fax)
mfeldman@seas.gwu.edu

(with contributions from Jack Beidler, Duane Jarc, Suzanne Pawlan Levy, 
and Mathew Lodge, as indicated by their initials following their reviews)

As chair of the SIGAda Education Working Group, and a denizen of the 
Internet newsgroups, I am often asked to give references for "Ada 
textbooks." This list responds to these many queries. 

The textbooks in the Group 1 are written especially for students without 
programming experience, who are learning Ada as their first language. 
Most of these can also cover at least part of a typical CS2-level 
course. The books in Group 2 use Ada as their language of 
discourse but are "subject-oriented:" data structures, file structures, 
compilers, comparative languages. The remaining books in Group 3 are 
either "Ada books" focusing on the language features or more general 
books that use Ada, at least in part, but do not fit obviously into a 
standard curriculum "pigeonhole."

I invite you to add to the list. Please write your annotated entry in 
the form I have used here and write or e-mail it to me. I will include 
it in my next version and credit you as a co-compiler of the list.

Disclaimers: I wrote two of the texts listed here; I hope the 
annotations are impartial enough. And any annotated bibliography is 
selective and opinionated. Your mileage may vary.

Group 1: Books Suitable for a First Course in Programming

Bover, D.C.C., K.J. Maciunas, and M.J. Oudshoorn.
Ada: A First Course in Programming and Software Engineering.
Addison-Wesley, 1992.
  This work is, to our knowledge, the first Ada book to emerge from 
Australia, from a group of authors with much collective experience in 
teaching Ada to first-year students. A number of interesting examples 
are presented, for example, an Othello game. The book is full of gentle 
humor, a definite advantage in a world of dry and serious texts. In the 
book's favor is the large number of complete programs. On the other 
hand, it is rather "European" in its terseness; American teachers may 
miss the pedagogical apparatus and "hand-holding" typically found in 
today's CS1 books. Generic units are hardly mentioned.

Culwin, F. Ada: a Developmental Approach.
Prentice-Hall, 1992.
  This work introduces Ada along with a good first-year approach to 
software development methodology. Much attention is paid to program 
design, documentation, and testing. Enough material is present in data 
structures and algorithm analysis is present to carry a CS2 course. A 
drawback of the book is that the first third is quite "Pascal-like" in 
its presentation order: procedures, including nested ones, are presented 
rather early, and packages are deferred until nearly the middle of the 
book. This is certainly not a fatal flaw, but it will frustrate teachers 
wishing a more package-oriented presentation. The programs and solutions 
are apparently available from the author.

Dale, N., D. Weems, and J. McCormick. 
Programming and Problem Solving with Ada. D. C. Heath, 1994.
  This book is inspired by Dale and Weems' very successful Introduction to
Pascal and Structured Design, but it is not simply an Ada version.  Ada's
more advanced capabilities such as exceptions, packages and generic units
are included in this text.  In addition, more than half of the material is
completely new, and the order of the topics is signficantly different.  It
also has more of a software engineering focus than the Pascal version. The
only Ada topics not included in this text are tasks and access types.
Procedures and packages are introduced early.  Each chapter includes case
studies, testing and debugging hints and excellent non-programming exercises 
and programming problems.  The text comes with a program disk containing all 
the programs given in the book.  In addition, a validated Meridian Ada 
compiler with complete documentation is available at low cost to students 
using this book. (S. P. L.)

DeLillo, N. J.
A First Course in Computer Science with Ada.
Irwin, 1993.
  This book is a first in the Ada literature: a version comes with an
Ada compiler, the AETech-IntegrAda version of Janus Ada. Author, publisher,
and software supplier are to be commended for their courage in this.
The book itself covers all the usual CS1 topics. In my opinion, the order
of presentation is a bit too Pascal-like, with functions and procedures
introduced in Chapter 5 (of 15) and no sign of packages (other than Text_IO)
until Chapter 10. Unconstrained arrays and generics are, however, done 
nicely for this level, and Chapter 13 is entirely devoted to a single 
nontrivial case study, a statistical package. I wish there were more 
complete programs in the early chapters, to put the (otherwise good) 
discussion of control and data structures in better context.

Feldman, M.B., and E.B. Koffman.
Ada: Problem Solving and Program Design.
Addison-Wesley, 1991.
  This work combines the successful material from Koffman's CS1 pedagogy 
with a software-engineering-oriented Ada presentation order. Packages 
are introduced early and emphasized heavily; chapters on abstract data 
types, unconstrained arrays, generics, recursion, and dynamic data 
structures appear later. The last five chapters, combined with some 
language-independent algorithm theory, can serve as the basis of a CS2 
course. A diskette with all the fully-worked packages and examples 
(about 180) is included; the instructor's manual contains a diskette 
with project solutions.

Savitch, W.J. and C.G. Petersen.
Ada: an Introduction to the Art and Science of Programming.
Benjamin/Cummings, 1992.
  This is a straightforward adaptation of the well-known Savitch Pascal 
books. Ada is introduced in a Pascal-like order, with subtypes and 
packages introduced halfway through the book. This is purely a CS1 book. 
The final chapter covers dynamic data structures. There is minimal coverage 
of unconstrained array types; generics are introduced at the halfway 
point to explain Text_IO, then continued only in the final chapter. The 
authors intended this book to provide a painless transition to Ada for 
teachers of Pascal; one wishes they had taken advantage of the chance to 
show some of the interesting Ada concepts as well. Program examples from 
the text are available on disk, but only as part of the instructor's 
manual; a solutions disk is available for a fee from the authors.

Skansholm, J. Ada from the Beginning. (2nd ed.)
Addison Wesley, 1994.
  This book was one of the first to use Ada with CS1-style pedagogy. 
There are excellent sections on the idiosyncracies of interactive I/O (a 
problem in all languages), and a sufficient number of fully-worked 
examples to satisfy students. Generics, linked lists and recursion are 
covered at the end; there is no tasking coverage, but one would not 
expect this at CS1-level. A very interesting addition is the new
Chapter 14, in which OOP in both Ada 83 and Ada 94 is discussed.
This is an especially lucid explanation of OOP in Ada, and makes a real
contribution because it doesn't just discuss tagged types as a "feature" 
of Ada 94, but shows very nicely what is possible in Ada 83 (instead
of just what is _not_ possible), and shows how Ada 94 adds functionality.

Smith, James F., and Thomas S. Frank
Introduction to Programming Concepts and Methods with Ada
McGraw-Hill, Inc., 1994
  This is a well written and easy to use text.  The book takes a spiraled 
approach to CS 1.  The authors do an excellent job integrating Ada into 
the book.  They take a very direct approach, especially with an early 
introduction to the package concept and the traditional Text_IO package.  
Faculty who have taught CS 1 with Pascal should like this book. Instead 
of making a big fanfare about Ada features, they simply introduce them 
as good support for software development concepts. The authors have 
carefully chosen the Ada topics they decided to cover in this book in 
order to strike a balance between staying true to the CS 1 course while
presenting enough of the programming language. If you teach CS 1 you 
might at least want to get a copy of this text just to look at two 
chapters, Chapter 7 and Chapter 14. Seven covers program correctness and 
run-time event (exception handling) and fourteen is a beautiful presentation 
and example of generic packaging.  Both presentations are done in an 
appropriate manner for CS 1. (J. B.)

Volper, D., and M. Katz. Introduction to Programming Using Ada.
Prentice-Hall, 1990.
  This book uses a heavily "spiraled" approach to Ada, and is designed 
for a 2-semester course, covering nearly all of Ada eventually. There 
are lots of fully-coded examples, and good pedagogical sections on 
testing, coding style, etc. If you like spiraling, you'll like this. The 
down side is that you can't find all you need on a given subject in one 
place. It's at the other end of the scale from the "Ada books" that 
follow the Ada Language Reference Manual (LRM) order.


Group 2: Other Books Intended for Undergraduate Courses

Ben-Ari, M. Principles of Concurrent and Distributed Programming.
Prentice-Hall 1990. (OS/concurrency)
  In my opinion, this is the best introduction to concurrency on the 
market. Ada notation is used for everything, but the focus is on 
concurrency and not on Ada constructs per se. I liked the CoPascal 
notation of the first edition better, but this book is still great. A 
software disk is promised in the preface; I had to work quite hard to 
get it from the publisher, which finally had to express-ship it from 
England. The software comes with a tiny Ada-ish interpreter, complete 
with Pascal source code, adapted from Wirth's Pascal/S via CoPascal. 
There are also some real Ada programs, most of which I've tested and 
found correct and portable.

Feldman, M.B. Data Structures with Ada.
Addison Wesley, 1993.
(CS2/data structures)
  This book is a reasonable approximation to a modern CS2 book: "big O" 
analysis, linked lists, queues and stacks, graphs, trees, hash methods, 
and sorting, are all covered. The Ada is a bit old-fashioned, especially 
the lack of generics; the book was published before compilers could 
handle generics. The packages and other programs are available free from 
the author. The book is currently under revision with Addison-Wesley and 
should appear in 1995.

Fischer, C., and R. LeBlanc. Crafting a Compiler.
Benjamin Cummings, 1988. (compilers)
  This book uses Ada as its language of discourse and Ada/CS, a usefully 
large Ada subset, as the language being compiled. If you can get the 
"plain Pascal" tool software by ftp from the authors, you'll have a good 
translator-writing toolset. Skip the Turbo Pascal diskette version, 
which is missing too many pieces to be useful. I've used the book since 
it came out with both undergrad and graduate compiler courses; it 
embodies a good blend of theory and "how it's really done" coding. 
Students like it. The authors have recently published a second version, 
which uses C as its coding language but retains Ada/CS as the language 
being compiled.

Hillam, Bruce. Introduction to Abstract Data Types Using Ada. 
Prentice-Hall, 1994. (data structures)
This is a very readable treatment of data structures presented using Ada
that makes good use of Ada features such as generics.  It contain many
complete programs and packages.  Unfortunately, obvious syntax errors make
it apparent that not all examples have been compiled.  The level of
presentation is somewhere between an elementary, CS 2, data structures
course and an advanced, CS 7, course.  A subset of first eleven chapters
provide the appropriate topics for a CS 2 course, but not the pedagogy
necessary for a course at that level. (D. J.)

Lomuto, N. Problem-Solving Methods with Examples in Ada.
Prentice-Hall, 1987.(algorithms)
  Inspired by Polya's classic How to Solve It, this book can make a nice 
addition to an Ada-oriented algorithms course. It makes too many 
assumptions about students' programming background to use as a CS1 book, 
and doesn't teach enough Ada to be an "Ada book." But it makes nice 
reading for students sophisticated enough to handle it. I'd classify it 
as similar to Bentley's Programming Pearls.

Miller, N.E. and C.G. Petersen. File Structures with Ada.
Benjamin/Cummings, 1990. (file structures)
  Designed for a straightforward ACM-curriculum file structures course, 
this book succeeds at what it does. There are good discussions of ISAM 
and B-tree organizations. The software can be purchased a low cost from 
the authors; it seems to approximate in Ada all those C-based file 
packages advertised in programmer-oriented trade publications.

Schneider, G.M., and S.C. Bruell.
Concepts in Data Structures and Software Development (with Ada 
Supplement by P. Texel).
West, 1991. (CS2/data structures)
  This work is not, strictly speaking, an Ada book; rather, it is a 
solid, language-independent approach to modern CS2. The language of 
discourse in the book is a Pascal-like ADT language rather like Modula-2 
in style; some examples are coded in legal Pascal. The Ada supplement 
makes it usable in an Ada-based course, but the supplement is rather too 
terse (100 pages of large type) for my taste, and insufficiently well 
keyed to the book chapters. The supplement's effectiveness would be 
greatly enhanced by full translations to Ada of a large number of the 
book's examples.

Sebesta, R.W. Concepts of Programming Languages (2nd ed.).
Benjamin Cummings, 1993. (comparative languages)
  If you've been around for a while, you might remember the late Mark 
Elson's 1975 book by the same title. This is similar: a concept-by-
concept presentation, with -- in each chapter -- examples taken from 
several languages. I include this work in an "Ada list" because I like its 
nice, impartial coverage of Ada. I especially like the chapters on  
abstraction and exception handling. The book covers -- comparatively, 
of course -- most of the lanuages you'd like to see, including C, C++, 
Lisp, Smalltalk, etc., with nice historical chapters as well. The book 
is readable; my students like it. Our undergraduate and graduate courses 
both use it as a base text.

Weiss, M.A.
Data Structures and Algorithms in Ada.
Benjamin/Cummings, 1993.
  I think this book reaches its intended market -- data structures courses 
(CS7) -- rather well with Ada. There's a good mixture of theory and practice 
(ADT design, for example), and coverage of new topics like amortized algorithm 
analysis and splay trees. A book at this level should not pay too much 
attention to teaching a language; rather it should make good use of its 
language of discourse. The Ada version does not attempt to teach either the 
language or Ada-style software engineering, but shows good understanding of 
the language, uses generic packages quite well and focuses on the theory of 
algorithms, as a book at this level should. This is the first, and so far 
the only, text in Ada for this course.

Group 3: A Selection of Other Ada-Related Books

Barnes, J. 
Programming in Ada. (4th edition)
Addison-Wesley, 1994.
  Barnes' work has been one of the most popular "Ada books." Some students
find it hard to see how the pieces fit together from Barnes' often 
fragmentary examples; it is difficult to find complete, fully-worked out, 
compilable programs. This just-out fourth edition has a 100-page summary of 
Ada 9X.

Booch, G. Object-Oriented Design, with Applications.
Benjamin Cummings, 1991.
  This is a good comparative introduction to the "object-oriented (OO)" 
concept. The first half gives a balanced presentation of the issues in 
OO Design; the second half gives nontrivial examples from Ada, 
Smalltalk, C++, CLOS, and Object Pascal. The author tries to sort out 
the difference between object-based (weak inheritance, like Ada) and 
object-oriented (like C++) languages. My only real complaint is that 
Booch should have worked out at least some of his case studies using 
several different languages, to highlight the similarities and 
differences in the language structures. As it is, each case study is 
done in only a single language. The good news is that the book is 
remarkably free of the hyperbolic claims one sometimes finds in the OO 
literature. I think this book could be used successfully in a second-
level comparative languages course.

Booch, G. Software Components with Ada.
Benjamin Cummings, 1987.
  This work is an encyclopedic presentation of data structure packages 
from Booch's OOD point of view. It is great for those who love 
taxonomies. It's not for the faint-hearted, because the volume of 
material can be overwhelming. It could serve as a text for an advanced 
data structures course, but it's thin in "big O" analysis and other 
algorithm-theory matters. The book is keyed to the (purchasable) Booch 
Components.

Booch, G. and D. Bryan
Software Engineering with Ada. (3rd edition)
Benjamin/Cummings 1994.
  Another of the classical "Ada books." Introduces Booch's OOD ideas. Not 
for use to introduce Ada to novices, in my opinion; there are some nice 
fully-worked case studies but they begin too far into the book, after long 
sections on design, philosophy, and language elements. The earlier chapters 
contain too much fragmentary code, a common flaw in books that follow the LRM 
order. The third edition contains an appendix describing Ada 9X.

Bryan, D.L., and G.O. Mendal. Exploring Ada, Volumes 1.and 2.
Prentice-Hall, 1990 and 1992 respectively.
  This is an excellent study of some of the interesting nooks and 
crannies of Ada; it sometimes gets tricky and "language-lawyerly." 
Volume 2 takes up tasking, generics, exceptions, derived types, scope 
and visibility; Volume 1 covers everything else. The programs are short 
and narrowly focused on specific language issues. If you like Bryan's 
"Dear Ada" column in Ada Letters, you'll like this book. It is certainly 
not a book for beginners, but great fun for those who know Ada already 
and wish to explore.

Burns, A. Concurrent Programming in Ada.
Cambridge University Press, 1985.
  I used this book for years in my concurrency course. It's roughly 
equivalent to Gehani's book, but its age is showing. Cambridge Press is 
not always easy to get books from, especially in the US.

Burns, Alan and Wellings, Andy
Real Time Systems and their Programming Languages 
Addison-Wesley 1990. (ISBN 0-201-17529-0)
  This is an excellent and unique book. Basic concepts and terminology are
explained before moving on to explain the major aspects of real time design.
"Real world" examples are presented in Ada, Modula-2 and occam 2, though
Ada is clearly the authors' language of choice and gets the most coverage.
Topics covered include reliability and fault tolerance, concurrency,
synchronisation, scheduling, message passing, atomic transactions, resource
control, distributed systems and low-level device control. Efficiency is not
neglected, and Ada support here is particularly strong with detail on the
CIFO package. Several case studies are also presented. The only failing of
the book is that it needs updating to cover Ada 9x and its real-time annex,
Modula-3 etc. However, the basic concepts that the authors convey so clearly
are independent of implementation language. (M. L.)

Cohen, N. Ada as a Second Language.
McGraw Hill, 1986.
  This book is a quite comprehensive exploration of Ada which 
follows the LRM in its presentation order. My graduate students like it 
because it is more detailed and complete than alternative texts. It's an 
excellent book for students who know their languages and want to study 
all of Ada. There are good discussions of "why's and wherefore's" and 
many long, fully-worked examples.

Gauthier, M. Ada: Un Apprentissage (in French).
Dunod, 1989.
  I found this an especially interesting, almost philosophical approach 
to Ada. The first section presents Ada in the context of more general 
laguage principles: types, genericity, reusability. The second section 
introduces testing and documentation concerns, as well as tasking; the 
third considers generics and variant records in the more general context 
of polymorphism. For mature Ada students in the French-speaking world, 
and others who can follow technical French, this book can serve as a 
different slant on the conventional presentations of the language. An 
English translation would be a real contribution to the Ada literature.

Gehani, N. Ada: an Advanced Introduction (2nd edition).
Prentice-Hall, 1989.
  I've always liked Gehani's literate writing style; he knows his 
languages and treats Ada in an interesting, mature, and balanced 
fashion. This book comes with a diskette sealed in the back of the book, 
which is advantageous because the book has numerous nontrivial, fully-
worked examples.

Gehani, N. Ada: Concurrent Programming (2nd edition).
Silicon Press, 1991.
  This is a less formal, more Ada-oriented presentation of concurrency 
than the Ben-Ari work. I use both books in my concurrency course; its 
real strength is the large number of nontrivial, fully worked examples. 
Gehani offers a nice critique of the tasking model from the point of 
view of an OS person. The preface promises the availability of a 
software disk from the publisher.

Naiditch, D.J.  Rendezvous with Ada
New York: John Wiley and Sons, 1989.
  A nice, relatively quick survey of the language for experienced 
programmers. Warning: there are not too many complete programs here, at 
least at the beginning. But overall, this is a good choice, less overwhelming 
than, say, Cohen, for "learning the language" quickly.

Nyberg, K. (editor) The Annotated Ada Reference Manual.(2nd edition)
Grebyn Corporation, 1991.
  This is the definitive work on Ada legalities, because it presents not 
only the full text of the LRM but also the official Ada Interpretations
as prepared by the Ada Rapporteur Group of Working Group 9 of the
International Organization for Standardization (ISO) and approved by
that organization. These commentaries, interleaved with the LRM text, 
are promulgated by the Ada Joint Program Office, the American National
Standards Institute (ANSI) agent for Ada, in the Ada Compiler Validation
Suite (ACVC). They are thus binding upon compiler developers. I recommend 
this book as an essential volume in the library of every serious Ada 
enthusiast.

Shumate, K. Understanding Ada. (2nd edition)
John Wiley, 1989.
  This would make a CS1 book if it included more overall pedagogy, 
independent of language constructs. Otherwise it is a nice introduction 
to Ada in fairly gentle steps. Lots of completely worked examples, right 
from the start. Doesn't follow the LRM order, which is great.

Watt, D.A., B.A. Wichmann, and W. Findlay. Ada Language and Methodology.
Prentice-Hall, 1987.
  This work presents some interesting programming projects, and the 
coverage of design and testing--at the level of a first-year student--is 
quite good. The first third of the book concentrates heavily on 
classical control and data structures, leaving exceptions, packages and 
even procedures until the "programming in the large" material in the 
second third. CS2 teachers will find too little concentration on 
algorithm analysis. On the other hand, tasking and machine-dependent 
programming are covered. Like the Shumate work, this book would make a 
suitable introduction to Ada for students with a semester or so of 
programming experience; it "jumps in" too quickly to satisfy the needs 
of neophytes and is not well-tailored to CS1 or CS2 needs.

Re: Ada - Where to get programs and books (long)

[David Weller]

In article <35sb2f$592@felix.seas.gwu.edu>,
Michael Feldman <mfeldman@seas.gwu.edu> wrote:
>
>Booch, G. Object-Oriented Design, with Applications.
>Benjamin Cummings, 1991.
>  This is a good comparative introduction to the "object-oriented (OO)" 
>concept. The first half gives a balanced presentation of the issues in 
>OO Design; the second half gives nontrivial examples from Ada, 
>Smalltalk, C++, CLOS, and Object Pascal. The author tries to sort out 
>the difference between object-based (weak inheritance, like Ada) and 
>object-oriented (like C++) languages. My only real complaint is that 
>Booch should have worked out at least some of his case studies using 
>several different languages, to highlight the similarities and 
>differences in the language structures. As it is, each case study is 
>done in only a single language. The good news is that the book is 
>remarkably free of the hyperbolic claims one sometimes finds in the OO 
>literature. I think this book could be used successfully in a second-
>level comparative languages course.
>
I believe the publisher is no longer printing this edition, since
Grady released the second edition (which no longer uses a variety of
languages, but instead uses only C++  -- please, no arguments about
whether you agree or disagree with this decision.  What's done is
done).  It is still a good text on OO design.  However, I'm hoping
that somebody comes out with an equivalent that uses Ada 9X as the
language.

>Burns, A. Concurrent Programming in Ada.
>Cambridge University Press, 1985.
>  I used this book for years in my concurrency course. It's roughly 
>equivalent to Gehani's book, but its age is showing. Cambridge Press is 
>not always easy to get books from, especially in the US.
>
I don't have the ISBN, but Burns and Davies has a 1993 version out
now called "Concurrent PRogramming".  It's a good text, but uses a
language called FC-Pascal (Functionally Concurrent).  If you look,
however, you'll notice the syntax looks a lot like...protected types
in Ada 9X.  You'll also find a good discussion of writing concurrent
software in Ada 9X at the end of the book.  I recommend this one
until a version specifically for Ada 9X comes out (next year, maybe?).

>Cohen, N. Ada as a Second Language.

	Does Norm Cohen have an idea when the second edition of this
	book will be ready? (Norm?)

-- 
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: Ada - Where to get programs and books (long)

[Michael Feldman]

In article <35sdvl$l36@starbase.neosoft.com>,
David Weller <dweller@Starbase.NeoSoft.COM> wrote:
>In article <35sb2f$592@felix.seas.gwu.edu>,
>Michael Feldman <mfeldman@seas.gwu.edu> wrote:
>>
>>Booch, G. Object-Oriented Design, with Applications.
>>Benjamin Cummings, 1991.

[snip]

>I believe the publisher is no longer printing this edition, since
>Grady released the second edition (which no longer uses a variety of
>languages, but instead uses only C++  -- please, no arguments about
>whether you agree or disagree with this decision.  What's done is
>done).  It is still a good text on OO design.  However, I'm hoping
>that somebody comes out with an equivalent that uses Ada 9X as the
>language.

You're right - I never got around to writing a review of the second
edition. I have no proprietary interest in the bibliography; I've
been writing capsule reviews as I have time, mostly because nobody 
else has done it. AdaIC has a big bibliography, but thery are a
government contractor and don't get much into expressing opinions. :-)

I'd be delighted to have Team_Ada-ers or anyone else in the
community add or update reviews in the booklist. Did I hear you
volunteer to do the Booch one? (Note: I'm crediting other
contributors at the top of the list, and by initials with their
review.)

>I don't have the ISBN, but Burns and Davies has a 1993 version out
>now called "Concurrent PRogramming".  It's a good text, but uses a
>language called FC-Pascal (Functionally Concurrent).  If you look,
>however, you'll notice the syntax looks a lot like...protected types
>in Ada 9X.  You'll also find a good discussion of writing concurrent
>software in Ada 9X at the end of the book.  I recommend this one
>until a version specifically for Ada 9X comes out (next year, maybe?).

This one too - are you volunteering, Dave? :-)
>
>>Cohen, N. Ada as a Second Language.
>
>	Does Norm Cohen have an idea when the second edition of this
>	book will be ready? (Norm?)

I'm waiting too. :-)

I would be quite happy to see this booklist become a community
project, perhaps with a Team_Ada header. I'm still signing it
myself at this point, mostly because I wrote all but 4 of the 
reviews.

Cheers -

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: Ada - Where to get programs and books (long)

[Norman H. Cohen]

In article <35sdvl$l36@Starbase.NeoSoft.COM>, dweller@Starbase.NeoSoft.COM
(David Weller) writes: 

|> In article <35sb2f$592@felix.seas.gwu.edu>,
|> Michael Feldman <mfeldman@seas.gwu.edu> wrote: 
...
|> >Cohen, N. Ada as a Second Language.
|>
|>      Does Norm Cohen have an idea when the second edition of this
|>      book will be ready? (Norm?)

I'm aiming for 1Q95.  The revision will not be a description of Ada 83
with a summary of what is different in Ada 94.  Rather, I start with the
presumption that Ada means Ada 94, and provide a comprehensive
description of Ada 94, including the standard libraries and the annexes.
Each chapter has a section near the end called "Differences in Ada 83" to
warn the poor unfortunates still stuck using Ada 83 compilers what they
are missing and how to work around the absence of certain features.

I've also reorganized some of the early chapters for pedagogical reasons,
in repsonse to comments from instructors who used the first edition.  The
thrust of the changes is to enable readers to start writing interesting
complete Ada programs right away.

--
Norman H. Cohen    ncohen@watson.ibm.com
(Bleary-eyed from staying up too late too many nights to get the revision
done.)