Ada 95: Problem Solving and Program Design (3rd Edition) - Softcover

Feldman, Michael B.; Koffman, Elliot B.

Softcover

ISBN 10: 020136123X ISBN 13: 9780201361230

Publisher: Addison-Wesley, 1999

Synopsis

In this third edition, educators Michael Feldman and Elliot Koffman continue to refine and enhance their balanced presentation of modern programming concepts and Ada 95 language capabilities. Students with no prior programming experience will begin to program with this interesting and powerful, yet flexible language that is used in the Boeing 777 and Airbus 340, the International Space Station, the European high-speed rail system, and many other major projects around the world.

This text includes a CD-ROM containing versions of the GNU Ada 95 compiler (GNAT), other program development tools, and high-resolution graphics support for the Windows, DOS, Macintosh, and Linux operating systems. GNAT supports the full Ada 95 language as standardized by the ISO and the ANSI.

About this title

About the Author

Dr. Michael Feldman is a professor of computer science at The George Washington University, as well as Chair of the Education Working Group of the ACM Special Interest Group on Ada (SIGAda). He has over fifteen years experience teaching Ada in introductory courses, and is the author of two other books, Software Construction and Data Structures with Ada 95 and Data Structures with Modula-2. Dr. Feldman manages the popular Internet site, Ada Programming Language Resources for Educators and Students - http://www.acm.org/sigada/education.

Elliot Koffman is a professor of computer and information science at Temple University. He is one of the country's foremost CS educators, a former chairman of the ACM Task Force for introductory programming methods courses, and author of a number of successful language texts in Modula-2, FORTRAN, in addition to his four editions of Pascal and Turbo Pascal.

020136123XAB04062001

Excerpt. © Reprinted by permission. All rights reserved.

This textbook is intended for the introductory course in problem solving and program design using Ada 95. It assumes no prior knowledge of computers or programming, and for most of its material, high school algebra is sufficient mathematical background. The first two editions of this book have been used with success in a large number of introductory courses.

While the book is generally oriented to the first-term student of programming, there is more material here than is usually covered in a first course. Chapters 11 through 17 focus on abstract data types, generics, recursion, dynamic data structures, inheritance-oriented programming, and concurrency. They can be used selectively in a fairly advanced first course or as part of a second-level course. The book covers the Ada 95 language thoroughly enough to serve as a useful introduction for professionals.

The Ada 95 language standard was adopted early in 1995 by the International Standards Organization and the American National Standards Institute. Ada is a foundation language in a growing number of institutions (about 150 at this writing). Ada is also a language of choice in many important industry sectors, especially commercial aviation and air traffic control, high-speed and metropolitan rail transportation, scientific and communications satellites, and manufacturing control. The consensus among teachers of Ada is that its pedagogical virtues are very similar to its industrial ones.

Problem Solving and Program Design

The primary focus of this book is problem solving with Ada 95, not a study of the Ada 95 programming language per se. We achieve this focus by selecting features of the language that lend themselves to good program design. We also emphasize abstraction and use the time-tested six-step approach to software development: problem specification, analysis, design, test planning, implementation, and testing. Each of the 35 case studies throughout the book follows this software development method.

New in the Third Edition

This edition includes a number of new end-of-chapter projects. Also, a new Chapter 2 uses an Ada 95 "spider" package--similar to the turtle graphics of Logo--to introduce the basics of algorithms and the fundamental sequential, loop, and test control structures, all in a platform-independent animated framework. Chapter 2 is independent of the others and thus provides flexibility to an instructor who sees real benefit in introducing all the major control structures together as early as possible. Instructors who were satisfied with the presentation order in the first two editions can simply skip from Chapter 1 to Chapter 3 without loss of continuity.

This edition also contains alphabetical indexes of syntax displays, case studies, and program style guides and a new Appendix A, High-Resolution Color Graphics. This appendix provides a platform-independent package for simple two-dimensional graphics and examples including a high-resolution color spider package.

Finally, this edition incorporates a CD-ROM, which is described in Appendix G. This CD-ROM contains:

• the complete set of about 200 book programs, all in standard, platform-independent Ada 95
• the Appendix A software for various platforms
• platform-specific versions of the GNU Ada 95 Compiler (GNAT) and interactive development environments (IDEs) for Apple Macintosh, Microsoft Windows 95/98/NT, MS-DOS/PC-DOS, and Linux
• various browsable editions of the Ada 95 Reference Manual and Rationale and additional reference documents such as printable reference cards and graphical syntax diagrams
• a copy of Tenon's MachTen Code Builder system, a virtual UNIX environment for the Macintosh

General Organization of the Book

The order of presentation is designed to do justice both to modern programming concepts and to the power of Ada. Each chapter beyond Chapters 1 and 2 presents a balanced mixture of a number of important language and computing issues. These are organized in a number of categories; most chapter section headings give the main category of the section as well as the specific topic, to orient teacher and student alike to the flow of material in a given category from chapter to chapter. The categories are:

• Problem Solving: Here is where language-independent concepts of program design, algorithm development, and so forth, are introduced.

• Control Structures: Each of these sections introduces the program-level control structures of Ada: decisions, loops, assignments, and so on.

• Data Structures: In each of these sections appears a discussion of data types and their uses, in the usual order of scalar types followed by structured or composite (record and array) types.

• System Structures: Each of these sections introduces a concept that is useful in what is often called "programming in the large." These concepts help the student, right from the start, to realize that real-world programs really consist of many smaller pieces built up in systematic fashion. Included under System Structures are such things as functions and procedures, packages, and exception handling and propagation.

• Tricks of the Trade: These are the universal techniques that all programmers must learn in order to survive productively: debugging techniques, program tracing, documentation techniques, and the like.

Pedagogical Features

In this book we employ several proven pedagogical features:

• Complete, compilable programs: From the beginning, students see full, compilable, executable programs. These are captioned "Program x.y" to identify them clearly as compilable programs and not fragments, which are embedded in the text or numbered as figures. Each listing of a main program is immediately followed by a sample execution, to give the student an idea of the expected results.

  A particular advantage of Ada as a teaching language is that the strong standard ensures that program behavior will be nearly independent of the particular compiler or computer being used. The programs in this book have been fully tested and can be compiled and executed using any validated Ada 95 compiler.

• Case Studies: A case study is a program that is developed from specifications, step by step, from a statement of the problem to a complete working program. The software development method is taught, reinforced, and applied. We focus much attention on program testing and the development of test plans.

  Of the 35 case studies, some--especially in the early chapters--are presented in their entirety, while others are intentionally left incomplete so that their completion can be assigned as class projects.

• Syntax displays: A syntax display is a brief description, with words and examples, of the syntax and interpretation of a newly introduced structure. These are set apart typographically for ease of use, and they codify the language structures as they are first presented.

• Programming style displays: These are brief discussions, again set apart typographically, offering advice to the student about how to write good programs. Many of these are of course universal and language-independent; many are also Ada-specific.

• End of section exercises: Following most sections there are two kinds of exercises, self-check and programming.

• End of chapter exercises: Each chapter review contains a set of quick-check exercises with answers, review questions, and programming projects.

• Error discussions and chapter review: Each chapter ends with a section that discusses common programming errors and a review section that includes a table of Ada constructs introduced in that chapter.

Program Design Issues

Concepts of object-oriented programming (OOP) are introduced throughout the book as appropriate. While it is true that type extension and dynamic polymorphism are generally seen as necessary to "full" OOP, it is essential for the student to understand that these are not sufficient. Ada's strong support for packages, generics, exceptions, private types, and subprogram overloading--like their equivalents in other languages--play important roles as well. The idea that an object--even a scalar object--has state (value) and behavior (appropriate operations) is introduced beginning in Chapter 3, and "object thinking" is pervasive in the book. Type extension per se is an advanced topic that cannot be understood without a good grounding in the other topics, so it is deferred until Chapter 16.

We present stepwise refinement of an algorithm right from the start but make only rare use of top-down implementation through procedure stubs and the like. It is crucial to foster habits of design for reusability very early, and this argues for early emphasis of packages and the reusable functions and procedures they provide.

Functions are presented very early: They are used in Chapter 4 and written in Chapter 5. Procedure calls are introduced in Chapters 2 and 3 to support the spider package and Ada's input/output operations; procedures are written starting in Chapter 7. Functions are more intuitive than procedures, and, in Ada, cannot have IN OUT ("variable") parameters. Since functions in Ada are not restricted in their result type--arrays and records as well as scalars can be returned--this early exposure to functions will pay off later in encouraging students to use functional notation where possible. Introducing functions early allows us to introduce the writing of packages early (again in Chapter 5).

Enumeration types are introduced very early (Chapters 2 and 4). Enumerations are a useful structure for representing a set of values without regard to their internal representation. Students of other languages have a hard time seeing the utility of enumerations because they are so hard to read and display. In Ada, the input/output library provides a generic package for reading and displaying enumeration values. Furthermore, enumerations serve as a useful vehicle for motivating generic instantiation (for Enumeration_IO) and attributes (Pos, Val, Succ, Pred) very early in the game.

Records and arrays are presented together in Chapter 9, with records first. Other books have introduced arrays of scalars early, with arrays of records as an "advanced" topic. We prefer to teach that arrays of records are as natural as arrays of integers.

Design of abstract data types (ADTs) is introduced systematically beginning in Chapter 11. Ada.Calendar is seen as an ADT, and the discussion continues with ADTs for calendar dates, monetary quantities, employee records, and multiple spiders. Unconstrained array types are treated along with generics in Chapter 12; multidimensional arrays and variant records are introduced in Chapter 13. Chapter 14 presents an introduction to recursion. Dynamic data structures, in the form of one-way linked lists, as well as subunits and LIMITED PRIVATE types, are introduced in Chapter 15, with applications to stacks and queues. Tagged records are introduced in Chapter 16; these are seen to be supportive of the type extension (inheritance) that is now seen as essential to full object-oriented programming.

Finally, Chapter 17 introduces the important concept of concurrent programming, introducing Ada's task types and protected types as language-provided constructs for concurrency.

Preconditions and postconditions for subprograms are introduced at the start. We encourage the development of programs from their documentation; in case studies, the steps of the algorithm are written before the program is developed and become comments as the program is refined.

We encourage appropriate use of comments but do not get carried away with them; the programs and the book would be far too long if we used industrial-strength comment conventions.

Ada Issues

Ada 95 is a rich and powerful language. It is important to introduce the language to beginners, step by step, without overwhelming them. Here is a list of a number of Ada capabilities and how we have handled them:

• Numeric Types: Subtypes are introduced early in the book, as a way of specifying ranges of values that are sensible in the application. Where values shouldn't be negative, we always use a positive subtype, for example, and often use a subtype with range constraints where it makes sense not to allow the full range of integer.

  We have avoided the use of new and derived numeric types because the compatibility issues that arise from their use create more problems than they solve for beginners. It is range checking that is important to them, not the esoterica of type compatibility.

  Furthermore, using new or derived numeric types for simple beginning-level numerical problems gives completely counterintuitive results: Attempting to use types for distance, rate, and time, for example, to compute the old

  Distance := Rate * Time; formula leads to type-compatibility grief that no novice should have to endure.

• Packages and related issues: Using packages is introduced in Chapter 2 with the spider system and in Chapter 3 with the use of the various sublibraries of Ada.Text_IO. In Chapter 4, students learn how to use some of the capabilities of Ada.Calendar, which has a richness that is not often explored even by advanced Ada texts. Ada.Calendar is a recurring theme in this book, and is discussed in the absract data type material of Chapter 11, since Time and the various Time and Duration operations from Ada.Calendar serve as a particularly nice predefined example of a private ADT. Also, students understand times and dates intuitively; there is nothing esoteric about them. The year range of Ada.Calendar (1901-2099) provides an opportunity to discuss the Year 2000 problem.

  Also in Chapter 4, use of a simple screen-control package is introduced. Students will need to compile this before they use it, since it is provided with the book and is not part of most compiler distributions. Thus they will learn how to compile a package and understand specifications very early on, even if they don't yet understand the details of the package body, which are discussed at some length in Chapter 8. Screen is used in a number of examples in the book, especially for menu handling, plotting, and the spider examples.

  By Chapter 5, students are writing simple packages; by Chapter 6 they are learning about overloaded function and procedure names. Private types and operator overloading appear in Chapter 11.

• The USE clause: This is introduced in Chapter 8. Ada industry practice generally avoids the USE clause for a number of good reasons. We avoid it here, in general, because qualifying all references to package resources helps the student to really understand which resources are provided by which libraries. USE and its Ada 95 variant USE TYPE can be useful in taking advantage of the overloading of infix operators; this is discussed in Chapter 11...

Edition details

• Publisher: Addison-Wesley
• Publication date: 1999
• ISBN 10: 020136123X
• ISBN 13: 9780201361230
• Binding: Paperback
• Language: English
• Edition number: 3
• Number of pages: 813