Ada 95: The Craft of Object-Oriented Programming


John English

(originally published by Prentice Hall, 1997)

Copyright © John English 2001. All rights reserved.

Permission is given to redistribute this work for non-profit educational use only, provided that all the constituent files are distributed unchanged and without charge.

This book, originally published by Prentice Hall in 1996, was taken out of print in 2001 and the rights to the book were subsequently returned to me by Pearson (the successor company to Prentice Hall). I have decided to make it available online in HTML format, and at the same time I have corrected several errata which were present in the printed editions of the book. It’s perfectly possible that I might have missed some, or even introduced some brand-new ones, as part of the process of transforming the text into HTML. If you spot any mistakes, please let me know so I can correct the master copy, which can be found at

Downloadable copies are available as (in zip format for Windows systems) or as (a gzipped tarball for Unix systems). Each distribution also includes the complete set of examples from the book, both for Windows ( and for Unix (adacraft.tar.gz).



Part One: Fundamentals

1. Programming concepts
1.1 What is a program?
1.2 Readability, maintainability, portability and reusability
1.3 Specifications and implementations
1.4 Abstract data types
1.5 Generics
1.6 Inheritance and polymorphism
2. Fundamentals of Ada
2.1 Hello, world!
2.2 Names in Ada
2.3 Program layout
2.4 Context clauses
2.5 Strings
2.6 A simple calculator
2.7 Procedure specifications
3. Statements
3.1 If statements
3.2 Assignment statements
3.3 Compound conditions
3.4 The case statement
3.5 Range tests
3.6 The null statement
3.7 Loops
3.8 The calculator program revisited
3.9 Exception handling
4. Procedures, functions and packages
4.1 Zeller's Congruence
4.2 Declaring procedures
4.3 Declaring functions
4.4 Scope and lifetime
4.5 Separate compilation
4.6 Subprograms as library units
4.7 Packages
4.8 Child packages
5. Defining new data types
5.1 Standard data types
5.2 Integers
5.3 Subtypes
5.4 Derived types
5.5 Modular integers
5.6 Real types
5.7 Numeric literals
5.8 Constants
5.9 Enumerations
5.10 The type Boolean
5.11 The type Character
5.12 Renaming declarations
6. Composite data types
6.1 Record types
6.2 Strings
6.3 Declaring array types
6.4 Unconstrained types
6.5 For loops revisited
6.6 A simple sorting procedure
6.7 Multidimensional arrays
6.8 Discriminants
6.9 Limited types
6.10 Using packages with data types
7. Exceptions
7.1 The importance of exception handling
7.2 Declaring exceptions
7.3 Re-raising exceptions
7.4 Getting information about exceptions
7.5 File input/output
8. Program design and debugging
8.1 Stepwise refinement
8.2 Initial design
8.3 Diary package design
8.4 Debugging the main program
8.5 Displaying the appointments
8.6 Adding new appointments
8.7 Deleting appointments
8.8 Loading and saving
8.9 Assessing the program

Part Two: Abstract Data Types

9. Private types
9.1 The need for abstraction
9.2 Package design
9.3 Private types
9.4 Full and partial views
9.5 Deferred constants
9.6 The package body
9.7 Overloaded operators
9.8 ‘Use type’ clauses
9.9 A word of caution
9.10 The package Ada.Calendar
10. Designing with abstract data types
10.1 The design process revisited
10.2 Separating out the user interface
10.3 Designing the model
10.4 Defining the view package
10.5 Implementing the ADT packages
10.6 Diary operations
10.7 Maintenance issues
11. Dynamic memory allocation
11.1 Access types
11.2 Linked lists
11.3 Doubly linked lists
11.4 Iterators
11.5 Deallocating memory
11.6 Designing a linked list diary
11.7 Implementing a linked list diary
11.8 General access types
11.9 Access parameters and discriminants
12. Generics
12.1 Generic packages
12.2 Generic parameters
12.3 Revising the diary package
12.4 A generic sorting procedure
12.5 Generics and general access types
13. Building a calculator
13.1 Handling operator precedence
13.2 A stack package
13.3 An improved calculator
13.4 Implementing the stack package
13.5 Opaque types
13.6 Formalising the syntax of expressions
13.7 A recursive descent parser

Part Three: Designing extensible software

14. Tagged types
14.1 Extending existing software
14.2 Variant records
14.3 Tagged types
14.4 Inheriting primitive operations
14.5 A package for representing meetings
14.6 The dangers of inheritance
14.7 Inheritance or containment?
15. Polymorphism and dispatching
15.1 Class-wide types
15.2 Dispatching
15.3 Abstract types
15.4 An object-oriented diary
15.5 Stream input/output
15.6 Other diary operations
15.7 Extending the diary
16. Controlled types
16.1 Memory leaks
16.2 User-defined finalisation
16.3 Smart pointers
16.4 User-defined assignment
16.5 Testing controlled types
17. An object-oriented calculator
17.1 Expression-handling objects
17.2 Tokens
17.3 Token extraction
17.4 Expression evaluation
17.5 Was it worth it?
18. Designing a spreadsheet
18.1 Spreadsheets
18.2 Defining the program
18.3 The spreadsheet class
18.4 Cell implementation
18.5 Formula cells
18.6 Deriving a new expression type
19. Multitasking
19.1 Active objects
19.2 Task types
19.3 Communicating with tasks
19.4 More about select statements
19.5 Transferring data during a rendezvous
19.6 Sharing data between tasks
19.7 An active spreadsheet
20. Loose ends
20.1 Other features of Ada
20.2 Other sources of information


A. Language summary
A.1 Compilation units
A.2 Statements
A.3 Declarations
A.4 Type declarations
A.5 Exceptions
A.6 Expressions
A.7 Generics
A.8 Multitasking features
A.9 The Ada type hierarchy
B. Selected standard packages
B.1 The hierarchy of the standard packages
B.2 The package Standard
B.3 The package Ada.Text_IO
B.4 The package Ada.Sequential_IO
B.5 The package Ada.Streams.Stream_IO
B.6 The package Ada.Characters.Handling
B.7 The package Ada.Characters.Latin_1
C. Language-defined attributes
D. Package Listings
D.1 JE
D.2 JE.Appointments
D.3 JE.Appointments.Meetings
D.4 JE.Appointments.Deadlines
D.5 JE.Diaries
D.6 JE.Expressions
D.7 JE.Expressions.Spreadsheet
D.8 JE.Lists
D.9 JE.Menus
D.10 JE.Pointers
D.11 JE.Spreadsheets
D.12 JE.Spreadsheets.Active
D.13 JE.Stacks
D.14 JE.Times


Revision history

    $Log: contents.htm,v $
    Revision 1.2  2002/02/22 01:47:19  WouldBeRoot
    Updated textbooks.

    Revision 1.3  2002/02/21 13:00:00  JE
    Minor corrections to chapters 2, 3, 13, 17 and 18, and to the examples
    for chapters 3, 13, 18 and 19: the British usage of "full stop" instead
    of "period" has confused some American readers, so "semicolon" has been
    substituted throughout to keep things language-independent.

    Revision 1.2  2001/11/17 12:00:00  JE
    An astonishing number of errors in both the text and the formatting
    have now been fixed. I am particularly indebted to Tad Ashlock and
    Jeffrey Cherry for sending me extremely detailed lists of problems
    and corrections.

    Revision 1.1  2001/09/12 11:00:00  JE
    Initial revision