mfeldman@seas.gwu.edu (Michael Feldman) (06/01/91)
I've gotten a number of responses to my book list the other day, so I
sat down and annotated it, adding a few more books as well. Here goes...
A Sampling of Ada-Oriented Books for Undergraduate Computer Science
June 1991
Michael B. Feldman
Department of Electrical Engineering and Computer Science
The George Washington University
Washington, DC 20052
202-994-5253
mfeldman@seas.gwu.edu
This is not an exhaustive list, merely a selected list of books I believe
can be successfully used in undergraduate computer science courses. The first
group of books use Ada as their language of discourse but are "subject-
oriented": introductory programming, data structures, file structures,
compilers, comparative languages. The others are "Ada books", focusing on the
language per se and organized around Ada's structures, not curricular material.
I invite you to add to the list. Please write your annotated entry in
the form I have used here and e-mail it to me. I will include it in my next
version and credit you as a co-compiler of the list.
Disclaimer: I wrote two of the books in Group 1; I hope the annotations are
impartial enough.
Group 1: Curriculum-Based Books
Ben-Ari, M. Principles of Parallel and Distributed Programming. (2nd edition)
Prentice-Hall 1990. (OS/concurrency)
In my opinion, the best "formal" intro to concurrency on the market.
Uses Ada notation for everything, but focuses 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
P-H, which finally had to get it from England. The software comes
with a tiny Ada-ish interpreter, complete with 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.
Prentice Hall, 1985. (CS2/data structures)
A reasonable approximation to a modern CS2 book: linked lists, queues
and stacks, graphs, trees, hash methods, sorting, etc. No generics,
though; it was written before compilers could handle generics.
Software available free from author. Currently under revision.
Feldman, M.B., and E.B. Koffman. Ada: Problem Solving and Program Design.
Addison-Wesley, September 1991 (intro-level, CS1-oriented)
Combines the successful stuff from Koffman's CS1 pedagogy with an
Ada-oriented presentation order. Strictly a CS1 book; no dynamic
data structures, pointers, or tasking (these are for later courses).
Heavy emphasis on packages; writing generics is introduced toward the
end. People who like Koffman's style ought to like this. A disk
with all the fully-worked examples (>100) will be readily available.
Fischer, C., and R. LeBlanc. Crafting a Compiler.
Benjamin Cummings, 1988. (compilers)
Uses Ada as both its language of discourse and the language being
compiled. If you can get the "plain Pascal" tool software from the
authors, you'll have a good TWS toolset. But skip the Turbo Pascal
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. Good blend of theory and "how it's really done" coding.
Students like it.
Gehani, N. Ada: Concurrent Programming (2nd edition).
Silicon Press, 1991. (concurrency/OS)
A less formal, more Ada-oriented presentation of concurrency than
Ben-Ari. I use both in my concurrency course - this one has a lot
of nice 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.
Don't count on it - see my comments on Gehani's other book and on
Ben-Ari for reasons why.
Lomuto, N. Problem-Solving Methods with Examples in Ada.
Prentice-Hall, 1987.
Based on Polya's "How to Solve It." Might make a nice addition to
an Ada-oriented algorithms course. Makes too many assumptions about
students' programming background to use as a CS1 book. Doesn't teach
enough Ada to be an "Ada book." But it makes nice reading if the
students are 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.
Succeeds at what it does. Good discussion of ISAM and B-tree
organizations. The authors sell the software for $35.00; I don't
have it yet but conjecture it'll be worth the money, as it will
approximate in Ada all those C-based file packages advertised in
Computer Language and other such publications.
Sebesta, R.W. Concepts of Programming Languages.
Benjamin Cummings, 1989. (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. A nice impartial presentation of
Ada along with the others. I especially like the chapters on
abstraction and exception handling. Covers - comparatively, of
course - most of the lanuages you'd like to see, including C, Lisp,
Smalltalk, etc. Nice historical chapters, too. The book is readable;
the students like it. Our undergrad and grad courses both use it.
Skansholm, J. Ada from the Beginning.
Addison Wesley, 1988. (CS1/intro-level)
A book that uses Ada with CS1-style pedagogy. Excellent sections on
the idiosyncracies of interactive I/O (a problem in all languages).
Enough fully-worked examples to satisfy students. A little on generics,
linked lists and recursion at the end; no tasking (but a CS1 book is
not the place to introduce this). Less spiraled and "choppy" than
Volper/Katz.
Volper, D., and M. Katz. Introduction to Programming Using Ada.
Prentice-Hall, 1990. (CS1/intro-level)
A heavily "spiraled" approach to Ada. Really designed for a
2-semester course, covers pretty much all of Ada eventually. Lots
of fully-coded examples. Pretty 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 LRM order.
Group 2: Ada Books
Barnes, J. Programming in Ada. (3rd edition)
Addison Wesley, 1989.
Historically, one of the most popular "Ada books." Some students
find it hard to see how the pieces fit together from Barnes' examples.
Difficult to find complete, fully-worked out, compilable programs.
Maybe the 4th edition will be more pedagogical.
Booch, G. Object-Oriented Design, with Applications.
Benjamin Cummings, 1991.
New book. Looks like a good comparative intro to the OO concept.
First half gives a balanced presentation of the issues in OO Design.
Second half gives nontrivial examples from Ada, Smalltalk, C++,
CLOS, Object Pascal. Tries to sort out the difference between
object-based (like Ada) and object-oriented (like C++) languages.
My only real complaint is that Booch should've taken some of his
case studies and worked them out using several different languages,
to highlight the similarities and differences in the language
structures. As it is, there are lots of case studies, but, alas,
each is done in only a single language. Oh well, can't have everything.
The good news is that the book is remarkably free of hype (for an OO
book, that is).
Booch, G. Software Components with Ada.
Benjamin Cummings, 1987.
An encyclopedic presentation of data structure packages from Booch's
OOD point of view. Great for those who love taxonomies. Not for the
faint-hearted, because the volume of material can be overwhelming.
Keyed to the (purchasable) Booch Components.
Booch, G.Software Engineering with Ada. (2nd edition)
Benjamin Cummings 1987.
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.
Bryan, D.L., and G.O. Mendal. Exploring Ada, Volume 1.
Prentice-Hall, 1990.
Explores the language. Good study of some of the interesting nooks
and crannies. No tasking in Volume 1. Volume 2 is promised. If you
like Bryan's "Dear Ada" column in AdaLetters, you'll like this book.
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.
Cohen, N. Ada as a Second Language.
McGraw Hill, 1986.
Quite comprehensive exploration of Ada. Mostly follows the LRM in
its presentation order. My grad students like it because it's quite
complete. Good for students who know their languages and want to
study _all_ of Ada. Good discussion of "why's and wherefore's."
Gehani, N. Ada: an Advanced Introduction (2nd edition).
Prentice-Hall, 1989.
I've always liked Gehani's literate style. The man knows his
languages and treats Ada in a balanced fashion. Many of my grad
students didn't like the book; I switched to Cohen in my languages
course; the students seem to like Cohen better. This book comes
with a floppy sealed in the back of the book. The copy I got had
a defective disk; Gehani told me his own copy came that way, too.
(I assume they've fixed this in later releases!) There's a down
side to book publishers dabbling in software distribution!
Gehani, N. Ada: Concurrent Programming (2nd edition).
Silicon Press, 1991.
A less formal, more Ada-oriented presentation of concurrency than
Ben-Ari. I use both in my concurrency course - this one has a lot
of nice 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.
Don't count on it - see my comments on Gehani's other book and on
Ben-Ari for reasons why.
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 a nice intro to Ada
in fairly gentle steps. Lots of completely worked examples, right
from the start. Doesn't follow the LRM order, which is great.