Browse Books

Reviewer: James W. Moore

In the Preface to this book, R. J. A. Burh states that the objectives are: (1) To provide a top:Udown, design:Uoriented introduction to ADA, accessible to a wide audience. (2) To present and to illustrate by example a practically useful, graphical design notation.... (3) To arm the novice system designer with philosophies, strategies, tactics, techniques, and insights into ways of effectively carrying out the design process in a system life:Ucycle context. It becomes clear that the emphasis of this text is upon system design rather than upon ADA. Buhr is interested in describing a technique for system design which uses ADA as a design language, rather than exploring the capabilities of ADA for system design. The description of ADA focuses primarily upon the facilities which the author regards as useful to his method: the facilities for packaging and for concurrency. The metaphor used to describe concurrency and rendezvous is generally apt and is quite readable. The approach to packaging tends to emphasize the traditional concept of :20modularity” rather than the more novel concepts of :20abstraction,” which take advantage of the particular capabilities which ADA provides. To motivate the discussion of system design, Buhr begins by clearly stating the life cycle which he has in mind. With this base, he can discuss the analogy between hardware and software development and a :20vision of the future,” the software factory. (In contrast to some conventional wisdom, he suggests that ADA may not be helpful in designing system via prototyping techniques.) Buhr's goal is to develop a :20parts kit of canonical, structured system parts.” He describes several alternative design strategies and finally settles upon :20data:Uflow:Udriven structured design” as the strategy to be used for the rest of the book. His designs are documented using a single set of graphical conventions throughout the book. (In fact, the use of graphics is so consistent that it may be accurate to say that the graphics :Iare Buhr's methodology. The book is useful in many regards. An excellent taxonomy of the roles of concurrent tasks is provided in Chapter 3. There are many diagrams and the graphics used to describe the designs seem to be a useful tool for summarizing the interactions among tasks. There are some problems, of course. Another round of editing would have helped. Page 142 refers to an example that is found 64 pages before by giving only the number of the chapter; the chapter is 51 pages in length. A set of timing diagrams are included with little explanation of their format. Some of the identifiers used in the figures do not match the identifiers referenced in the text. The published ADA program fragments could be improved; problems range from poor indentation in one case and a mispelling of the keyword :20elsif”, to a couple of programs which include major errors regarding the scope of names. More bothersome are a few broad claims which are insuficiently supported by argument. Examples of this include: :20for design purposes, ADA may be considered to be essentially PASCAL with special added features” [p.32], and :20ADA cannot be used to design and write conventional operating systems” [p.178]. The description of PASCAL concurrency [p.24] is a little murky and the classification of ADA features [p.14] is not obvious. On page 156 and elsewhere, Buhr discourages the usage of nested accept statements without providing a clear argument. An argument is required; the Buhr solution of the readers/writers problem seems to lack the straightforward clarity of other published solutions which do use nested accepts. The reader is left unsatisfied, wondering if there may be an analogue to the celebrated Bohm:UJacopini structured programming theorem here. The evolution of the design examples is occasionally unclear. The text sometimes introduces componenets with little motivation only to later remove them as being unnecessary. In overall terms, it is clear that this book concerns a design method which is conceived independently of ADA. ADA fans, like the reviewer, may be disappointed that the book does not more fully take advantage of the features of the complete ADA languages and may even be offended when the author criticizes ADA because it lacks some of the facilities provided by his graphical techniques. Nevertheless, Buhr has provided a clear description of his method for the design and description of systems. On balance, the flaws of the text are relatively minor. The book describes a process for producing and describing designs which may very well prove to be useful in the production of concurrent systems.

Reviewer: James W. Moore

Ada is a programming language developed for the Department of Defense specifically for the purpose of programming large software systems involving embedded computers. Because the language incorporates features supporting many modern software engineering techniques, some have claimed that Ada will become widely used in the commercial sector as well as the defense sector, and in traditional data processing applications as well as embedded applications. On February 17, 1983, the standard for the programming language was approved by ANSI. Since then, usable and efficient compilers have been slow to appear, but text books have not. This comparative review deals with five such texts. (The reader should note that evaluation is made in the context of a larger number of texts, some of which are too poor to be considered within this review. In total, at least 50 books on Ada have been published to date.) Table 1: Objective Data Barnes Habermann Booch Gehani Buhr Length (in pages) 367 479 502 325 256 Number of chapters 16 16 24 8 9 Number of exercises 153 87 102 -- 78 Answers given Yes Hints Some No No Bibliography entries -- -- 167 99 10 Version of Language* ANSI 782 ANSI 782 782 *ANSI Standard Ada, approved on February 17, 1983, differs in small but significant details from the July 1982 draft. The updated version of Barnes can be recognized by a green cover and the words Second Edition. The updated version of Booch has the legend Fully Reflects ANSI Standards printed as a banner across the corner of the cover. Because of the emphasis on software engineering implicit within Ada, authors differ in the relative attention that they pay to the language itself versus the use of the language to support good software engineering techniques. The five texts reviewed here vary widely in this regard and, hence, vary greatly in their appropriate usage. Barnes and Buhr can be regarded as the endpoints in the range to be considered; Barnes emphasizes the presentation of the important features of the language, while Buhr subordinates the teaching of Ada to the description of his system design methodology. The other texts occupy the middle ground. Booch is most comprehensive, trying to fully describe the language while also offering an approach (which has become well known) to the object-oriented design of Ada programs. Both the Gehani and the Habermann texts approach Ada from more advanced viewpoints. Gehani emphasizes how the advanced features of the language support top-down programming. Habermann approaches Ada from the vantage point of Pascal in order to illustrate the Ada approach to software engineering issues. Barnes My purpose in writing this book is to present an overall description of Ada. Some knowledge of the principles of programming is assumed. [p. xi] T his text is an eminently readable presentation of the Ada language accompanied by insightful explanations of the purpose of the various features of the language. The text is organized by language features, which enhances the usefulness of the book as a reference source. The order of presentation tends to place the more basic and conventional features of the language at the beginning, building to greater complexity and novelty toward the end. (But Barnes somehow manages to adequately motivate even those language features which are best understood in the context of advanced usage.) The style of writing is clear and even humorous. The usage of examples is both succinct and diverse and serves to illustrate the great power of Ada in modeling the problem domain. The subject is treated in sufficient depth to provide complete, overall coverage without dwelling upon the arcana of the language. The strengths of exposition make this text the choice for classroom presentation of the Ada language. The overall size of the book, the depth of treatment, and the scale of the exercises are appropriate for a short course while the concise, yet entertaining, style encourages appropriate diligence in reading. The insight into the motivation of the language features is a bonus. Habermann The goal of this book is a presentation of the major features of the Ada programming language and their relevance to software engineering…. Our goal is achieved if the examples demonstrate to what extent the Ada language supports good programming style in software engineering. [p. iii] The intended audience for this book is the experienced programmer. This text differs from the others in this review because it is, in effect, a comparative treatment of Pascal and Ada, using dual example programs in the two languages to illustrate software engineering techniques. The development of the example programs provides abundantly exploited opportunities to compare the capabilities of the two languages and to discuss tradeoffs among various Ada approaches. The selection of the design issues and the overall organization of the book seem to be derived from the shortcomings of Pascal. But, for those unfamiliar with Pascal, and who wish to remain so, the Preface promises that “the Ada sections are not dependent on the Pascal sections”; this reviewer, literate but not fluent in Pascal, agrees. The most remarkable feature of this text is its tight organization. Each chapter begins with a brief list of the topics and issues to be discussed, followed by a statement of a problem to be solved and a discussion of the approach. The next two sections incrementally develop Pascal and Ada solutions, respectively, with emphasis upon the software engineering issues raised by the usage of various language features. Finally, complete Pascal and Ada solutions are presented followed by a section of “Reminders” (actually a summary of issues) and a set of problems related to the example programs. An appendix contains apt hints, but not solutions, for the problems. The text covers the Ada language very completely and devotes particular attention to the advanced features of the language. The issue-oriented organization of the chapters will encourage readers to refer back to discussions of engineering tradeoffs but will discourage quick reference for questions regarding language features. The style of exposition is clear but dense, readable but somewhat short of entertaining. The discussions of tradeoffs among various language features and approaches make this the reviewers personal favorite among the Ada texts. The reader may safely ignore the Pascal sections if he or she considers them irrelevant, or may use them as an opportunity to gain additional insight into the software engineering advantages provided by Ada. Table 2: Subjective Ratings Barnes Habermann Booch Gehani Buhr* PurposeUsefulness: Tutorial Excellent Good Good Fair Good Reference Good Fair Fair Poor Fair Readability Excellent Good Good Fair Good Depth OK Deep Varies Varies Deep Innovativeness OK OK High OK High Order of Presentation Good Excellent Fair Fair Good Logic of Progression Good Excellent Good Fair Good Liveliness Excellent Good Good Fair Good Clarity Excellent Good Good Poor Good Examples Excellent Excellent Excellent Fair Good *Unlike the other texts, the Buhr text is tabulated with respect to its value as a textbook for teaching system design rather than the Ada language. Booch This book … has been written to satisfy… three specific goals … intensive study of Adas features …examples of good Ada design and programming style …object-oriented design methodology. [p. xv] The stated goals are certainly ambitious, but this text moves beyond them in an apparent attempt for encyclopedic comprehensiveness. Included are chapters on the “Ada culture,” the “software crisis,” Ada Programming Support Environments (APSE), the software life cycle (complete with illustrations of Ada Lovelaces own life cycle), “trends in DoD software,” and an Ada style guide. In other words, this book is too long. Furthermore, the eight or so chapters of inessential material are (excepting an excellent history of the Ada language) shallow in content and boosterish in tone—indoctrination rather than education. But, setting aside these obvious flaws and concentrating on the heart of the text, the result is more satisfactory. This portion of the book is organized into a series of design examples which serve to illustrate features of the language and to provide opportunities for explaining object-oriented design. The text provides a generally good explanation of language features and often excellent advice on usage and style. On the other hand, the descriptions of object-oriented design seem somewhat facile to this reviewer; I wonder how much retrospective revision went into the “informal strategy” examples to permit easy application of Boochs technique of underlining nouns, verbs, adjectives, and adverbs to provide cues for abstraction. (Advanced page proofs show that the forthcoming second edition of the text adopts a more sophisticated approach to analysis and design.) Nevertheless, the description is valuable in that it provides a starting point for novice Ada programmers attempting to move beyond simple translation of design paradigms borrowed from other languages. If one desires a single text to be used in a course encompassing a software design methodology, as well as the Ada language, then this is probably the text of choice. Otherwise, one of the more succinct books should suffice. Gehani This book is written especially for readers who have a good knowledge of at least one procedural programming language…. The book focuses primarily on the novel aspects of Ada …. The example programs are developed using stepwise refinement. [p. xiii] This text is very selective in its depth of treatment of various features of the language. Features that are deemed “rather common” [p. xiv] in other programming languages are described in a single 73-page introductory chapter while seven additional chapters describe novel features, such as tasking or packages. The result is that the greater part of the language, including important concepts like derived types, is so tersely described in the introduction that even an experienced programmer would have to have read some other text as a prerequisite. To further complicate matters, the style of writing is vague and occasionally misleading, and the presentation is poorly ordered. Unfortunately, the problems continue in some of the subsequent chapters. For example, the chapter on generics fails to adequately differentiate generic parameters from the more usual forms of subprogram parameters. The result is an explanation of generics which cannot be understood unless one already understands the subject. At least one important advanced topic, real arithmetic, is substantially neglected. On the other hand, the treatment of representation specifications and implementation-dependent features is superior to the other reviewed texts, although, incredibly, the author neglects to mention that the features are optional parts of the language. The text includes extended examples which are generally very interesting problems treated in considerable depth and approached well. The value of the examples is substantially diminished by their placement at the end of the chapters. The effect is to emphasize the algorithms applied to solve the problems rather than the language features employed in the solution. The net result is mixed: good for tasks, for example, and poor for packages. A commendable feature of the text is a fine annotated bibliography. Although superior to most available Ada texts, in overall terms this book must be regarded as less desirable than the others which are reviewed here. This is unfortunate because its examples are the most interesting. Buhr The objectives of this book … are …to provide a top-down, design-oriented introduction to Ada …to present … a practically useful, graphical design notation …to arm the novice system designer [for] effectively carrying out the design process. [p. xi] The Buhr text differs substantially from the others reviewed here because its really about system design rather than about Ada. The design technique is a data-driven method using a graphical representation refined from that of Booch and others. The designs are ultimately described using Ada as a design language. The methodology is interesting and appears useful, although it stresses traditional concepts of modularity rather than the more modern concepts of abstraction. Buhrs treatment of the Ada language is deliberately uneven. He emphasizes features related to packaging and concurrency because these are central to his design methodology. Other important areas are ignored or dismissed because they are irrelevant or ill-suited to his design method. It seems clear that his methodology was conceived independently of Ada and is best expressed graphically; in some details, the fit with Ada is forced. The examples are generally well conceived and informative, with the last two chapters set aside for extended examples taken from communications. The evolution of the examples is occasionally hazy. Furthermore, some of the example Ada designs display serious errors in the scope of names. In overall terms, the Buhr text successfully teaches a design methodology which may be useful in designing systems for implementation in Ada or other languages. The book should be regarded not as an alternative to any of the other texts reviewed here, but rather as a possible supplement, particularly for those texts which emphasize the Ada language rather than software engineering. Comparison Some quantitative and evaluative factors are summarized in Tables 1 and 2, respectively. Although most notations are self-explanatory or clear from the preceding individual reviews, some entries require additional explanation. Each text is primarily intended to be tutorial in nature, but their usage for reference is inevitable; the Barnes text is relatively better in both regards. Furthermore, it provides the clearest, most readable, and most entertaining presentation of the material. The Booch and Buhr texts were notably innovative in their approaches to softwaresystems design.