Object-Oriented Analysis and UML

Many programmers think that they are doing object-oriented development. Most of them are wrong. The promises of OO design-improved development times, better maintainability, better usability-cannot be achieved unless you go about doing design in a formal way. Simply programming in Java (or C++) will not get you a good program, or an object-oriented one. Similarly, using a language's object-oriented features, such as derivation, does not make the program object oriented. OO Design is a formal process, and it's unlikely that a good design will emerge if you don't go about creating the design in the "right" way. The first step in the process is the building of a "conceptual" or "analysis" model, which will evolve into the implementation-level design. The line between OO "analysis" and "design" is a fine one. Analysis concerns itself primarily with the large structure of a program, while design is concerned with the fine details needed for implementation, but often both activities go on in parallel. Without the underpinnings of a good analysis model, however, the resulting design will be unworkable.

This class focuses on building the OO analysis model.

We'll start out with a brief discussion of the OO-development process from the programmers perspective. (Find a more in-depth look at process in "Managing the Object-Oriented Development Process).

We'll then define the principles of object orientation in depth, looking at what characteristics actually comprise a true "object." We'll look at requirements gathering, the role of the UI in design, use-case analysis, and object modeling. UML is presented in context throughout this discussion.

Emphasis is placed on the practical application of OO principles and techniques, including UML, to solving real-world problems. We'll work through a significant example in class.

Engineers will come away from this class understanding what objects are, what OO design is, and how to go about designing object-oriented systems from initial conception up to the point of the implementation-level design, and how to model a program using UML. The class "OO Design II: Design Patterns, Class Hierarchy, and Structure" discusses how to take your UML and evolve it into an implementation-level design from which you can code.

Course Outline

• The OO Process, an overview.
  • Recursive/Parallel Development
  • The Development Spiral
  • Agile and Heavyweight Processes
    • RUP (Rational Unified Process)
    • XP (Extreme Programming)
• Object-oriented Concepts
  • OO-vs.-Procedural thinking
  • What is an Object?
    • What are the characteristics of an OO system?
  • Attributes
  • Classes and Classification
  • Inheritance
• Writing the Programs the User Needs
• Goal-directed Design
• The Importance of the User Interface in Program Design
  • The Connection between the UI and the Object Model
  • The Qualities of a good UI
• The Formal Problem Statement
  • Object-oriented requirements gathering.
• Use-case Analysis Defining Use Cases
  • Use cases as a design tool
  • A Use-case Template discussed in depth.
• Use-case factoring
• Scenarios within Use Cases
• Building UML Activity Diagrams.
• The Static and Dynamic Model
  • Evolving Activity Diagrams into a Dynamic Model
    • UML Sequence and Collaboration Diagrams
  • Capturing Structure in a Static Model
    • UML Structure Diagrams