The Object-Oriented Development Process

TOM ROWLETT is director of technology for Object Based Project Systems/Inc. a consulting company specializing in mentoring developers new to object-oriented analysis and design. His 33 years of experience include IBM's Software Engineering Institute and Lockheed Martin's Advanced Concepts Center.

I. THE OBJECT-ORIENTED DEVELOPMENT PROCESS.

1. The Process Model.


Why a process? Process architecture. An example. Process models. Incremental with use cases.

2. The Object-Oriented Development Process.


High-level use case definition. The rationale behind the use case model. How use cases link the process. Criteria for a robust process. Overview of the activities of OODP.

3. Requirements Definition.


The use case. Rules of granularity. Use case signature. Why this level of use case detail during requirements? The raw requirements (the way they normally are provided). Searching for use cases from known information. Finding scenarios. When to stop looking for more use cases. The case study. Correctness. Partitioning the problem by use case. Distributing and maintaining the requirements. Use case naming conventions.

4. Analysis.


Analysis vs design. Purpose of analysis. Details of the analysis activity. Another use case model. Creating the data dictionary. Creating the class diagram. Unified Modeling Language notation. Other ways to identify use cases. Analysis review.

5. Use Case Design.


Mapping the analysis use case to design. The MVC design pattern. Variations on MVC. An example of recording a use case design. Other design considerations. Design correctness questions. An example of design verification. Design from requirements. Language library objects. Creating control and interface objects.

6. Class Design.


Purpose of class specification. Class specifications. Language types and legal values. UML constraints. Class owners. Object-to-object links. Handling duplicate information. Use case owner. Designing using inheritance. Correctness questions. Revisiting the incremental and traceable property of the process.

7. Persistence.


Persistence definition. Persistence considerations. Persistence classes. Maintenance.

8. Implementation.


Implementation tasks. Developing new classes. Implementing new methods. Implementation-specific coding considerations. Correctness. Correctness questions using a sequence diagram. Language implementation considerations. Method pre-conditions. Inheritance. Abstract classes. Reusable hierarchies. Class libraries. Frameworks. Encapsulation. Public vs private methods. Support of the test and user interface (UI) teams. Runtime scenarios.

9. Test Planning.


Testing use cases. The use case testing process. Creating and reviewing the test plan. A simple test plan for the video store. Why test planning is a separate activity.

10. Test Case Development and Execution.


Test case design vs test case development. The test object. The return code object. Writing the test cases. Test execution and evaluation. A test case reviewed in detail. Test object state data. Testing with existing databases. Kinds of tests. Enhancing use case testing.

11. User Interface.


Product development roles. User interface design drivers. Importance of separating user interface and application design. The interface object. Pseudo use cases. Testing the interface. The ReturnCode object. Requirements changes.

12. Maintenance.


New objects and attributes. Dealing with encapsulated data. Updating process deliverables. Identifying the real scope of changes.

13. Project Management.


Project management and the transition to OT. Managing the learning curve. Planning and estimating. Metrics and the SEI capability maturity model (CPM). Pilot projects. Tracking and controlling the new process. Improving the process. Skill acquisition and development.

II. AN EXAMPLE CREATING OODP DELIVERABLES.

14. Requirements and the Incremental Plan.


Requirements statement. Requirements deliverables.

15. Increment One Deliverables.


Increment one-Plan/schedule. Increment one-Analysis. Increment one-Design. Increment one-Class design. Increment one-Test plan.

16. First Increment Code Samples.


Increment one-Test cases. Increment one-Implementation.

17. Increment Two.


Increment two-Analysis. Increment two-Use case design. Increment two-Class design. Increment two-Test plan.

18. Increment Three.


Increment three-Analysis. Increment three-Use case design. Increment three-Class design. Increment three-Test plan.

19. Increment Four.


Increment four-Analysis. Increment four-Use case design. Increment four-Class design. Increment four-Test plan.

20. Other Deliverables.


State diagrams. User interface design.

III. REFERENCE

Glossary.
A. Sources and References.
B. The Complete Use Case Process Details.


Requirements gathering. Test planning. Analysis (and application specification). User interface implementation and test. Test case design and development. Use case design. Class design. Implementation. Use case test. Interface and application integration.

C. Building an Estimating Model Using a Spreadsheet.


Linear regression. Exponential regression. Using the model to calculate effort.

D. Summary of Correctness Questions and Guidelines.


Correctness questions. Rules and guidelines.

Index.