Table of Contents

for

Object Oriented Software Development with Eiffel

James Heliotis
extracted 26 June 1998

1. A Brief History of Computing 1
   1. Pre-20th Century
   2. 20th Century
   3. Programming
   4. Engineering of Software
2. The Structure of Software I -- What is an Object? 6
   1. Where did Objects Come From?
      1. Lots of Computing Paradigms
      2. The Object Paradigm
   2. Processes, Objects, and Roles
      1. A Restaurant Example
      2. Sequential Objects, Parallel Objects
   3. Classification and Hierarchy
   4. Software Objects
      1. What's in a Class?
      2. Types versus Classes
      3. Class Inheritance
   5. Summary
3. Objects in Software Design 20
   1. The Three Sides of an Object
   2. Interfaces
   3. Classes
   4. Instantiation
   5. Message Passing
   6. An Introduction to Inheritance
   7. Summary
   8. Exercises
4. Objects in Eiffel 30
   1. Classes
      1. Deferred Classes
      2. Effective Classes
   2. Creating Objects
      1. Class Names as Data Types
      2. Declarations
      3. Creation Instructions and Routines
   3. Other ways to associate a variable with an object
      1. Assignment Instructions
      2. Literals
      3. Parameter Passing
   4. Special Cases: the Basic Types
   5. Message Passing / Feature Calls
   6. Features, Revisited
      1. Features That Have Return Types
      2. Attributes and States
      3. Local Variables
   7. References and Expanded Variables
   8. An Introduction to Inheritance
      1. The inherit Clause
   9. A Complete Example
      1. Standard Output
   10. Summary
5. The Structure of Software II -- What is an Algorithm? 53
   1. Procedure in Software
      1. An Instruction Defined as a Perturbation of State
      2. Definition of Algorithm
   2. Algorithm Design
      1. Listing the Instructions
      2. Stepwise Refinement
   3. Control of the Flow of an Algorithm
      1. Alternation
      2. Iteration
      3. Iteration Assertions
      4. Looking Back at Flow Control Concepts
   4. Subroutines
      1. Interrupting Oneself: The Stacked Nature of Subroutine Calls
      2. Object Passing: Subroutine Parameters and Return Values
      3. An Introduction to Recursion
   5. Summary
6. Algorithms in Eiffel 69
   1. Sequential Execution
      1. Demarcating Instructions
      2. Compound Statements
   2. Alternation
      1. if - then Instructions
      2. if - then - else Instructions
      3. Boolean Objects, Revisited
   3. Iteration
      1. Loop Assertions
   4. Multi-way Alternation
      1. The if - else if Chain
      2. inspect Instructions
      3. Flow Control in Eiffel -- A Summary
   5. Expressions
      1. Uses of Expressions
      2. Types of Expressions
      3. Operators Found in the Standard Library
      4. Operator Precedence
   6. Chapter Summary
7. Some Useful Data Structures 89
   1. Principles of Reuse
   2. Basic Properties of Containers
   3. The List: Basic Linear Storage
      1. Responsibilities
      2. Applications
   4. The Stack
      1. Responsibilities
      2. Applications
   5. The Queue
      1. Responsibilities
      2. Applications
   6. The Array
      1. Responsibilities
      2. Applications
   7. Lists, Revisited
      1. Iterators
   8. Summary
8. Designing Object-Oriented Software Systems 119
   1. Responsibility-Driven Design
      1. The CRC Card Design Method
      2. A Program as a Set of Cooperating Objects
      3. Finding the Objects
      4. Determining the Objects' Responsibilities
      5. Determining Object Collaborations
      6. About Classes
      7. An Example
      8. Post Mortem on the Design Example
   2. UML
      1. Classes
      2. Associations
      3. Object Interaction Diagrams
   3. A Retrospective
9. From Design to Implementation and Debugging in Eiffel 139
   1. Design to Implementation
      1. Class Diagrams and the Eiffel Class Interface
      2. Object Interaction Diagrams and Eiffel Routines
      3. The "Short Form"
      4. What We Learned
   2. Debugging
      1. pre- and post- Conditions: require and ensure
      2. Other Assertions
      3. invariant - Checking the Integrity of the Object
      4. check - Sanity Checks
      5. Loop Assertions
      6. Debugging with Assertions
   3. Introduction to the Notion of Exceptions
      1. Assertions as Potential Exception Raisers
      2. How Exceptions Work
      3. The Debugger as an Exception Handler and Exception Avoider
   4. Summary
10. More Useful Data Structures 153
    1. Trees
       1. Motivation
       2. More on Recursion
       3. The Interface
       4. Tree Traversal Algorithms
    2. Binary Trees
       1. Motivation
       2. The Interface
       3. Traversals
    3. The Binary Search Tree
    4. An Introduction to Graphs
       1. Motivation
       2. The Model
       3. Applications
    5. Summary
11. Trees for an Eiffel Library 168
    1. The Class LIST_TREE
    2. The Class BINARY_TREE
    3. The Class BINARY_SEARCH_TREE
    4. Conclusions
12. Inheritance I 185
    1. Reuse, revisited
       1. Design Reuse
       2. Importance of Inheritance in Design Reuse
       3. Implementation Reuse
       4. How Inheritance is Used to Reuse Implementation
    2. Inheritance and Classes
       1. When is Inheritance Handy?
       2. Abstract Classes - A Good Bet
       3. Some Uses to Consider Carefully
       4. Inheriting for Implementation: Look Before You Leap!
    3. Conclusions
13. Inheritance in Eiffel I 194
    1. The Inherit Clause
    2. Redefining Features
    3. Multiple Children
    4. The Notion of Polymorphism
    5. Renaming Features
    6. Summary
    7. Exercises
14. Inheritance II 212
    1. Abstraction, Types, and Classes
       1. Interfaces and Abstract Classes
       2. Type Inheritance
       3. Implementation Inheritance
    2. Design Patterns
       1. Internal Iterator
    3. A Summary of Two Relationships
15. Inheritance in Eiffel II 221
    1. Accessing Old Versions of Features
    2. Multiple Inheritance
       1. When To Use Multiple Inheritance
       2. The "Multiple Deferred + One Effective" Rule
    3. Anchored Types
    4. Constrained Genericity
    5. Conditional Assignment
    6. Example: Binary Search Tree and Internal Iterators
    7. Summary
    8. Exercises
16. Searching and Sorting 242
    1. Complexity Measures
    2. Measuring Input Size
    3. Time Complexity Measures
    4. Searching Algorithms
       1. Linear Search
       2. Introducing "Divide and Conquer"
       3. Binary Search with a Sorted Array
       4. Using a Binary Search Tree
    5. Sorting Algorithms
       1. Bubble
       2. Merge
       3. Heap
       4. Quick
    6. Summary
    7. Exercises
17. Introduction to Software Requirements and Analysis 273
    1. A Review of the Software Life Cycle
       1. Requirements Gathering
       2. Analysis
       3. Design
       4. Implementation
       5. Testing
       6. Maintenance
    2. Analysis: The Engineering Specification of The Problem
       1. Use Cases
       2. Object Interaction Diagrams
       3. Class Diagrams
       4. Prototypes
    3. From Analysis to Design
    4. Summary
    5. Exercises
18. A Survey of Software Testing 285
    1. Testing Requirements
       1. Group Review
       2. Prototyping - System Verification
    2. Testing Designs
       1. Design Reviews
       2. Drivers and Skeletons - System Observation
       3. Automatic Design Analysis - Formal Verification
    3. Testing Code
       1. Code Reviews
       2. System Observation
       3. Black Box
       4. Clear Box
       5. Formal Verification
    4. Beta Releases: The "Guinea Pig" Approach
    5. Summary
19. Graphs 296
    1. Definitions
       1. How to Express Efficiency
    2. Implementations
       1. Nodes and Node References
       2. Edge Lists
       3. Adjacency Matrices
    3. Graph Problems
       1. Depth-First Search
       2. Shortest Path
       3. Minimum Spanning Tree
       4. Traveling Salesman
       5. Other Interesting Problems
    4. Summary
    5. Exercises