For lots of information and great links regarding Ada 95, visit Ada Programming Language Resources for Educators and Students (http://www.acm.org/sigada/education) and AdaPower (http://www.adapower.com).
This bibliography is a project of the SIGAda Education Working Group. I am serving as the editor of the list, and the contact point for sending in reviews, but there are many reviewers. You too can be one! Just send a capsule review, in the form of the ones here, and I will be glad to add it to the list and credit you for the contribution.
Reviewers in this edition are Ted Baker, Jack Beidler, Michael Feldman, Stan Kwasny, Mathew Lodge, Gail Miles, Jerry Petrey, and Pat Rogers. Their initials appear after their respective reviews.
An excellent first Ada programming book is Programming and Problem-Solving with Ada by Dale, Weems, and McCormick The strength of the book a is in the spiral approach to teaching programming: starting from the basic concepts and systematically building the knowledge base of the students until they can write sophisticated, complicated programs. One of the strengths of these authors is the writing style of the book. Students find it easier to read than some of the other available texts.
The authors support a strong pedagogical foundation such as providing an historical introductory section, a software engineering section, and a strong emphasis on the process of developing a program. They introduce a topic and provide further exploration in depth in a later chapter Introducing file I/O early is also helpful for students since they need to manipulate files early. Often, this topic is pushed later in the course.
The examples and the exercises are another strength of the book.
They provide students with significant examples to explain the concepts.
Finally, having warm-up programming problems and then programming problems
are very useful for a faculty member because they fit nicely into the chapter
[2nd edition review]
As with the earlier edition by the same authors, the first 2/3 of the book is suitable as a CS1 text with Ada as the language of instruction, and the the last few chapters, combined with some language-independent algorithm theory, cover the rest of the Ada langauge in sufficient depth to serve as the language-specific basis of a CS2 course.
The style is like that of a musical fugue: sections that develop general programming and problem solving techniques are interleaved with sections that develop successively larger subsets of the Ada 95 language and libraries; examples recur from one chapter to another, in progressively more completely developed forms. Packages are introduced from the start; other language features are introduced very gradually at first and then at a progressively faster pace. Loops come up in chapter 5, records and arrays by chapter 8, generics by chapter 11, and pointers, tagged types, and tasks in chapters 14-16. The nearly 200 examples have all been compiled and tested, and are available in electronic format from the first author, the Addison Wesley home page, and the usual Ada archives.(T.B.)
[author adds, regarding 3rd edition]
The 3rd edition contains a new Chapter 2 devoted to the Spider, a simple
turtle-graphics-like package for learning algorithms, control structures,
and exception handling. The body of this package is simple enough to be
understood toward the end of a one-semester course, and is examined in
detail in Chapter 8. A new Appendix A introduces a high-resolution color
graphics package, AdaGraph, and a high-resolution implementation of the
Spider package. Finally, the 3rd edition is packaged with a new CD-ROM,
Ada 95 Educational Resources, which includes all the book examples together
with versions for four platforms of the GNU Ada 95 (GNAT) compiler, the
GRASP development environment, and much documentation and other resources.
This 400-page book is a very nice, if relatively brief, introduction
to most of Ada 95, suitable for Portuguese-speaking students at first level.
The examples are complete and compilable, moving from the very simple to
more interesting ones using packages, tagged types, and tasks (the
last a subject in which the author is especially interested). Included
with the book is a set of diskettes containing the book examples and a
copy of AVLAda95, the author's Windows 95/98/NT student development environment.
While some English-language Ada texts have been translated into other languages,
this is one of the few original texts not written in English, and one of
the very few such books intended for first-year students. The author is
using it in Brazil, and it ought to be useful for other Ada-related courses
in Brazil and Portugal. It can serve as a good example to encourage others
to write non-English Ada textbooks. (M.B.F.)
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 95 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 95, but shows very
nicely what is possible in Ada 83 (instead of just what is not possible), and shows how Ada 95 adds functionality. (M.B.F.)
The 2nd edition was published before the Ada 95 standard was finalized,
but this 3rd edition fully takes into account the Ada 95
[first edition review]
The ultimate Ada concurrency book (Burns' "Concurrent Programming In
Ada") has a successor for Ada95. Written by acknowledged real-time experts,
it covers the tasking model in great depth, including all the existing
and new capabilities as well as the Systems Programming Annex, the Real-Time
Systems Annex, and the Distributed Systems Annex. Also included are an
introduction to concurrent programming and an examination of the interaction
of the tasking facilities with those for object-oriented programming. More
than just a detailed language examination, the book offers many examples
of usage and analysis of feature interaction that only these two authors
could provide. Highly recommended for introductory and advanced courses
in concurrent and real-time programming with Ada. (P.R.)
[first edition review]
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.)
[note from MBF]
The 2nd edition indeed gives significant coverage to Ada 95 and the real-time annex.
As a book about data structures, this well-written, teachable book assumes a base knowledge of Ada, although a quick review of the basics is included.
Ada95 features are incorporated smoothly into the discussion and the coded examples (which are available from the author). The book strikes a nice balance between theoretical issues and practice with a wealth of examples and much attention to detail, including a nice discussion on how to time a program. The extensive material coverage includes standard CS2 topics like "big O" analysis, linked lists, queues and stacks, graphs, trees, hash methods, and sorting, but the reader is allowed to investigate topics beyond the basics through additional topics like strings, vectors, tables, file I/O, sets, priority queues, AVL trees, and B-Trees, and several complete and illustrative examples, including an employee database, an airline passenger list, an RPN calculator, a discrete simulation, and even a simple window manager.
By introducing generic units relatively early (chapter 5), the text can focus on reusability and sound software engineering solutions to a wide variety of data structures problems, but never neglects the underlying analysis. As a capstone to the development of several generic data structures, chapter 14 covers generic sorting according to a wide variety of methods each with its own data structure nuances. The final chapter introduces concurrency.
The nearly 200 programs and packages have all been compiled and tested,
and are available in electronic form from the author, the Addison Wesley
home page, and the usual Ada archives.(S.C.K.)
This is a very interesting book written by a long-standing expert in Ada and software engineering. Various methodologies are compared (Booch, HOOD, Schlaer-Mellor, etc.), all in the context of Ada 95 but not limited to language-specific discussions. Enough Ada 95 fundamentals are taught that it should not be necessary to know Ada 95 before reading the book, but this is not a book for people without some programming background.
Recommended for classes taught in French and for individuals with a
good reading knowledge of French. The author is developing an English translation,
which I await enthusiastically. (M.B.F.)
This book begins by providing an introduction to problem solving using
a Fusion-based object-oriented design methodology, in addition to examining
the basic constructs in the Ada 95 language. The book then moves on to
discuss the object-oriented features of the language, using numerous examples
to illustrate the ideas of encapsulation, inheritance, and polymorphism.
The book's capstone is a detailed case study of the design and implementation
of a textual user interface (TUI) using object-oriented design methodology.
This is a nice, understandable, straightforward book on OOP with Ada 95,
quite suitable for self-study or an advanced undergraduate course. The
brief survey of Ada 95 at the beginning should be sufficient for readers
with programming experience. The several dozen source code files are available
on the Internet. (M.B.F.)
[first edition review]
This new book by John Barnes continues a tradition of easy readability that belies the depth of understanding required to make a complex subject accessible. Though a new book for a new Ada, the style and humor from the earlier book remain. The new Ada standard is covered as a language in its own right, with few references to its predecessor beyond a summary of language differences in each chapter. The core facilities are covered extensively, with emphasis on rationale and the "programming in the large" issues of abstraction, OOP, tasking and exceptions. Of particular value is the chapter entitled Object Oriented Techniques, which explores the application of the OOP, tasking and generic unit facilities explained earlier in the book. Each chapter contains coding exercises for further study, with fullly worked-out answers in the back. The many who appreciated the earlier book will likewise enjoy this, the new classic on Ada95. Highly recommended for readers with programming experience. (P.R.)
The second edition contains a number of new case studies and a CD-ROM
that provides an Aonix ObjectAda Special Edition development environment
as well as the xample source code from the text. (M.B.F.)
This is more like a new book than like a new edition. The first edition of this book was a excellent reference to Ada(83), well organized and filled with excellent examples of realistic code sequences. It was the perfect reference to the language for those with substantial programming experience in another programming language. One of the more important features of the first edition is a well constructed index, which becomes the major passageway into the book as it grows old and worn.
That was the first edition, the second edition builds upon the excellent organization that made the first edition an excellent reference and adds material on the new features in Ada(95). To be more precise, the new material is not added, it is integrated into a seamless reference to Ada(95). The book is composed into twenty well focused chapters and five appendices, including an appendix on the special needs annexes. Each chapter concludes with two sections, one on differences between Ada(83) and Ada(95), and a very brief chapter summary. Isolating the discussion of '83 versus '95 differences to a single section in each chapter has kept the rest of the presentation in each chapter clean and to the point.
As an example of the quality in this book, consider Chapter Twelve, Classwide Programming. This is the chapter that describes Ada's object oriented programming support. Again the word "seamless" comes to mind. Unless you know ahead of time what are the new features in the language and what are the old features, you could not tell from the presentation. Polymorphism, type extension, dispatching are presented in a clear direct way, with excellent sample pieces of code. I was particularly impressed by the clean presentation of Ada.Finalization, and the realistic easy to follow sample code for the Initialize, Finalize, and Adjust procedures.
In conclusion, "Ada as a Second Language, is the best non-language lawyer
reference to Ada(95), even for those whose first language is Ada(83). (J.B.)
This is an outstanding book that in 227 pages gives an amazingly complete coverage of Ada95. It is intended for someone with prior programming experience but who is new to Ada and who needs to get the essentials quickly in order to be productive with Ada in as little time as possible. It accomplishes that goal very well. It uses graphics (Booch-type diagrams), and lots of examples to illustrate the notion of an Ada program architecture as "a set of Lego blocks snapped together".
The chapters are well organized and lead the student through an understanding of the language in a very logical order with the diagrams making it much easier to visualize the concepts as they are introduced in the example programs. Each chapter has a summary with questions and answers and key points to remember. Object oriented programming and concurrency are covered in addition to what you would expect in a short introductory text such as this. Some good references are included as well as a quite complete glossary. In a book of this size, I think it would be hard to find a better coverage of Ada. The style seems to self motivate the reader and unveil the real "beauty of Ada". (JP)
Simon Johnston's work makes an important contribution to the growing collection of Ada 95 texts for specific audiences. Johnston's target readers are the many programmers with experience in the C and C++ languages. Johnston's perspective is that of an active software developer fluent in all these languages; his goal is to show readers how Ada 95 helps them to do what they already know how to do in C and C++.
Johnston has shown considerable bravery by putting early versions of this text on the World Wide Web. He has revealed his ideas to the eyes of many thousands of critical readers, and this courageous approach has benefited both readers and author. The result is a very polished piece of work.
Three features of Johnston's book are especially useful. First, his prose and code are cogent and clear. Second, throughout the book the author develops and follows through one major case study, introducing Ada 95 capabilities through refinement of the design and alternative strategies. Finally, Johnston introduces and carefully explains the richness of the standard libraries, presenting these in a systematic fashion without merely paraphrasing the Reference Manual.
This book is bundled with a CDROM that includes the book's program distribution
as well as the Aonix ObjectAda Special Edition development system. For
the C or C++ programmer, Johnston's text, aided by this or another of the
nice Ada 95 development systems, will go far in making the Ada 95 experience
a pleasant and rewarding one. (M.B.F.)
This book is a revision of Naiditch's earlier "quick introduction" to
Ada for experienced programmers. The second edition is no longer "quick"
(it is nearly 150 pages longer) but is the best integrated introduction
to Ada 95 to appear thus far. One wishes only that the author had provided
more complete, compilable examples instead of the fragments so typical
of Ada texts. (M.B.F.)
Springer-Verlag, 1997 (ISBN 3-540-63144-5)