ADA 95
PROBLEM SOLVING PROGRAM DESIGN
2nd Edition
Published on 18. April 1996
Book
Paperback/Softback
744 pages
978-0-201-87009-1 (ISBN)
Description
This title is now available in a Book/CD-ROM package. (ISBN: 0-201-30485-6)Ada 95 Problem Solving and Program Design, Second Edition provides students with an introduction to programming using Ada 95. Students with no prior programming experience will begin to explore programming in this powerful, yet flexible language ideal for large-scale software system development. Adopted as a standard by the ISO and the ANSI, Ada 95 is the first fully object-oriented programming language to be internationally standardized. This allows the programs presented in the text to be completely portable to any validated Ada 95 compiler. While presenting a balanced mixture of modern programming concepts and Ada 95 language capabilities, this text provides a solid programming foundation benefiting from the richness of Ada 95.Highlights: * Emphasizes "object thinking" by introducing object-based and object-oriented programming concepts throughout the book. * Presents encapsulating design from the beginning to stress the importance of reusability of functions, packages, and procedures. * Introduces control structures, data structures, and system (encapsulation) structures in parallel throughout the book.
* Presents about 200 complete, compilable, executable programs followed immediately by a sample output. * Helps students build on concepts with a continuing project, "spider graphics" recurring throughout the book. * Uses proven pedagogical features to encourage strong programming skills. These include case studies, self-check exercises, programming style displays, syntax displays, and common-error discussions in every chapter. 0201870096B04062001
* Presents about 200 complete, compilable, executable programs followed immediately by a sample output. * Helps students build on concepts with a continuing project, "spider graphics" recurring throughout the book. * Uses proven pedagogical features to encourage strong programming skills. These include case studies, self-check exercises, programming style displays, syntax displays, and common-error discussions in every chapter. 0201870096B04062001
More details
Edition
2nd edition
Language
English
Place of publication
United States
Publishing group
Pearson Education (US)
Target group
College/higher education
Dimensions
Height: 234 mm
Width: 186 mm
Thickness: 32 mm
Weight
1180 gr
ISBN-13
978-0-201-87009-1 (9780201870091)
Copyright in bibliographic data and cover images is held by Nielsen Book Services Limited or by the publishers or by their respective licensors: all rights reserved.
Schweitzer Classification
Other editions
New editions
Book
05/1999
3rd Edition
Pearson
€123.00
Article is exhausted; no reprint
Person
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.
0201870096AB04062001
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.
0201870096AB04062001
Content
1. Introduction to Computers and Programming. Electronic Computers Then and Now. Components of a Computer. The Art and Science of Problem Solving. The Software Development Method. Programming Languages. Processing a High-level Language Program. Using the Computer. 2. Introduction to Ada 95. About Ada 95. The "Look" of Ada 95 Programs. System Structures: Numerical Input and Output. Problem Solving: Software Development Illustrated. Data Structures: Declaring Constants and Variables. System Structures: General Form of an Ada 95 Program. Control Structures: Assignment Statements. Control Structures: Input/Output Statements. Programs in Memory. Data Structures: Introduction to Data Types. Tricks of the Trade: Common Programming Errors. Chapter Review. 3. Problem Solving; Using Packages. Problem-Solving: Stepwise Refinement. Problem Solving: Extending a Problem Solution. Problem Solving: Structured Programming. Data Structures: Introducing Enumeration Types. System Structures: The Importance of Packages. System Structures: Using Ada's Calendar Package. System Structures: Using a Screen Control Package. Continuing Saga: Introducing the Spider. Tricks of the Trade: Common Programming Errors. Chapter Review. 4. Decision Statements; Writing Simple Functions and Packages. Control Structures: Boolean Expressions and the IF Statement. Problem Solving: Decision Steps in Algorithms. Tricks of the Trade: Tracing a Program or Algorithm. Problem Solving: More Strategies. Control Structures: Multiple-Alternative IF Statement. System Structures: Using Ada's Math Library. System Structures: Writing Simple Functions. System Structures: Writing a Simple Package. Tricks of the Trade: Common Programming Errors. Chapter Review. 5. Repetition in Programs. Control Structures: Counting Loops and the FOR Statement. Problem Solving: Generalizing a Solution. Problem Solving: Repeating a Program Body. Control Structures: Nested Loops. Continuing Saga: Nice Spider Patterns. Data Structures: Subtypes of Scalar Types. Tricks of the Trade: Debugging and Regression Testing. System Structures: A Useful Functions Package and the Overloading Principle. System Structures: Introducing Exception Handling. Tricks of the Trade: Common Programming Errors. Chapter Review. 6. Other Loop Forms; Procedures; Exception Handling. Control Structures: the WHILE Statement. Problem Solving: Loop Design. Problem Solving: Assertions and Loop Invariants. Control Structures: the General LOOP and EXIT Statements. System Structures: Robust Exception Handling. System Structures: Writing Simple Procedures. System Structures: A Package for Robust Input. Continuing Saga: a Child Package for the Spider. Tricks of the Trade: Testing with Exception Handling. Tricks of the Trade: Common Programming Errors. Chapter Review. 7. A Systematic Look at Scalar Data Types. Data Structures: Constant Declarations. Data Structures: Numeric Data Types. System Structures: More on Ada.Numerics; the USE Clause. Continuing Saga: Random Numbers and the Drunken Spider. Data Structures: the Boolean Type. Data Structures: the Character Type. Control Structures: the CASE Statement. System Structures: a Package to Print a Number in Words. Continuing Saga: Inside the Spider Package. Tricks of the Trade: Common Programming Errors. Chapter Review. 8. Structured Types: Records and Arrays. Data Structures: Record Types. Control Structures: Records as Operands and Parameters. System Structures: a Package for Calendar Dates. Hierarchical Records. Data Structures: Array Types. Problem-Solving: Selecting Array Elements for Processing. Problem-Solving: Using Arrays. Tricks of the Trade: Reading Part of an Array. Data Structures: Arrays with Non-Integer Subscripts. Problem-Solving: Searching and Sorting an Array. Case Study: Sorting an Array of Records. Common Programming Errors . Chapter Review. 9. Programming in the Large: Procedural Abstraction. The Software Life Cycle. Problem-Solving: Using Abstraction to Manage Complexity. Problem-Solving: Top-Down Refinement Using Procedural Abstraction. System Structures: Nested Procedures and Scope of Identifiers. Case Studies: Top-Down Development. System Structures: a Systematic View of Text Files. Tricks of the Trade: Debugging a Program System. Tricks of the Trade: Common Programming Errors. Chapter Review. 10. Programming in the Large: Abstract Data Types. System Structures: Abstract Data Types (ADTs). System Structures: Using Package Calendar as an ADT. System Structures: Writing an ADT for Calendar Dates. System Structures: Writing an Abstract Data Type for Rational Numbers. System Structures: Writing an ADT for Money Quantities. System Structures: Writing an ADT for Employee Records. Case Study: Employee Inquiry System. Continuing Saga: Writing an ADT for Multiple Spiders. Tricks of the Trade: Common Programming Errors. Chapter Review. 11. Introduction to Unconstrained Array Types and Generics. Data Structures: Unconstrained Array Types. Case Study: a General Sorting Program. Case Study: Mathematical Vectors and Matrices. System Structures: Generic Units. Case Study: a Generic Sorting Program. Case Study: a Generic Vector Package. Tricks of the Trade: Common Programming Errors. Chapter Review. 12. Multi-dimensional Arrays. Data Structures: Multi-dimensional Arrays. Problem Solving: Using Multi-dimensional Arrays. Continuing Saga: Keeping Track of Multiple Spiders. Case Study: Analysis of Sales Trends. System Structures: Mathematical Matrices. Tricks of the Trade: Common Programming Errors. Chapter Review. 13. Variant and Tagged Record Types: Object-Oriented Programming. System Structures: Object-Oriented Programming. Data Structures: Variant Records. Data Structures: Employees Revisited. System Structures: Geometric Figures. System Structures: Metric System. System Structures: Tagged Types; Primitive and Abstract Operations. System Structures: Geometric Figures Revisited. Continuing Saga: Multiple Kinds of Spider Systems. Chapter Review. 14. Introduction to Recursion. Problem Solving: The Nature of Recursion. Tricks of the Trade: Tracing a Recursive Procedure or Function. Problem Solving: Recursive Mathematical Functions. Problem Solving: More Recursive Programs. Problem Solving: More Case Studies in Recursion. Problem Solving: Recursive Searching and Sorting. Tricks of the Trade: Common Programming Errors. Chapter Review. 15. Access Types and Linked Lists. Data Structures: Access Types and the NEW Operator. Data Structures: Linked Lists and their Operations. Problem Solving: Recursive Implementations of Linked List Operations. Problem Solving: Iterative Implementation of Linked List Operations. Data Structures: Linked Lists with Head and Tail Pointers. Problem Solving: Ordered Insertions in Linked Lists. Tricks of the Trade: Debugging Programs with Linked Lists. Data Structures: General Access Types. System Structures: Tagged Types Revisited. Chapter Review. 16. Dynamic Data Structures. Stacks. Stack Applications. Queues. Binary Trees. Binary Search Tree ADT. Tricks of the Trade: Common Programming Errors. Chapter Review. 17. Introduction to Concurrent Programming. Problem Solving: What is Concurrent Programming? System Structures: Task Types and Task Objects. System Structures: Protected Types and Protected Objects. Case Study: Dining Philosophers. Continuing Saga: Multiple Concurrent Spiders. Chapter Review. Appendices. A. Reserved Words and Special Symbols. B. Ada Syntax. C. Ada 95's Predefined Language Environment. D. Ada Hints for Pascal Users. E. Summary of Ada 95 Execution-Time Exceptions. F. Reference Guide to Ada 95 Constructs. 0201870096T04062001