This collection of notes on OOP was never meant to stand alone. It also represents a view of OO circa early to mid 1990s. Some people still find them useful, so here they are, caveat emptor. Special thanks to Gilbert Benabou for taking to time to compile the first printable version of this document and inspiring us to provide it.
[ PDF ] Printable Version
Table of Contents
- Motivation for OO
- The OO Paradigm
- Visualizing Program Execution
- OO Naming Conventions
- The Object Model
- Abstraction and Identity
- Object-Oriented Messaging
- Encapsulation & Modularity
- Object-Oriented Hierarchy
- Object-Oriented Typing
- OO Concurrency & Persistence
- The OO Development Process
- OO Analysis Techniques
- Pitfalls in OO Analysis
- UML Notation
- CRC Cards
- OO Class Relationships
- Object Oriented Aggregation
- Object Oriented Interitance
- Other Object Oriented Class Relationships
- Object Oriented Instantiation
- Object Oriented Polymorphism
- Review of OO Programming
- The Quality of Classes and OO Design
Underestimating the need for and difficulty of analysis
Time and money pressures from managers, and the natural tendency of developers to "go to code" quickly, can be a bad combination. Analysis is expensive in time and money, and takes a lot of skill, both in the domain of the problem, and in the OO domain. There is much to consider about each abstraction: the static and dynamic models, the invariants, quality of abstraction, potential for re-use. There are design issues, driven partly by language choice: implementing the abstraction, life cycle issues, safe-use issues, documenting proper use.
Accurate and complete requirement specifications
Except for very constrained domains, re-implementations of existing functionality, or trivial applications, the process of defining requirements is almost guaranteed to result in:
- incomplete specifications
- incorrect specifications
A study in 1999 by Elemer Magaziner of requirement specifications found that they are typically only 7% complete and 15% correct.
Another almost guaranteed phenomenon is that they will change over time as the project progresses.
Given the cost of change over a project's lifecycle this is a huge problem and argues for alternatives to what the above pitfall seems to argue for (lots of upfront analysis).
Building a too-general solution
Generality is good, but comes at a cost. Some balance must be met. Developers who really become OO are particularly prone to this problem. The elegant, complete, general solution to a class design becomes a goal unto itself. You've got to know when good is good enough.
The wrong number of architects
Encapsulation and interface doesn't mean you can split your problem into pieces, give each piece to a team, then never talk across teams only to get back together and expect everything to "just work". There are aspects of class design that don't show up in the interface files, or in the documentation. Someone (or a small team of someones) has to have chief responsibility for the architecture of large projects.
Re-architecting too often or too little
Developers enamored with the beauty and elegance of a design may want to re-architect when something new throws their model for a loop. This is possible, and a big advantage of OO, if done properly, but can be taken too far (re-architecting for its own sake, or for the intellectual challenge). At the same time, you must occassionally face facts and re-think your architecture if you find it growing too complex, hard to understand, full of hacks, etc.