Getting where you want to go with objects
- By Tom McDonough
Object orientation (OO)
has vast potential, but it isn't a panacea. Even the best new technologies
and paradigms are counterproductive if deliverables aren't easily
reusable, deadlines or
budgets aren't met, or the desired functionality isn't present. But if
you understand the OO life cycle, you can adopt a best-practice development
process that will minimize your risk of failure.
While this may sound easy, consider this:
- There are approximately four "worst practices" for each best practice.
- The process must be made independent of the technology, which nowadays
changes in "Web time" (weeks, days or even hours).
- There is always legacy code in real-life systems.
- People, teams and organiations may be bound to legacy orientations.
- Virtually all production systems contain elements from each orientation.
Data-oriented systems (relational databases are an example) emphasize
fundamental data entities and their interrelations. In function-oriented
systems (most legacy systems), the stress is on functional decomposition
or what the system does. OO combines the two.
The OO life cycle
Two principles underlie the OO life cycle. The Product Architecture
Principle identifies a product's components. The Lifecycle Traceability
Principle shows how business requirements are developed and transformed
so that what is needed actually gets translated into code.
Because changes in the technology landscape can turn today's best practices
into tomorrow's nightmares, the Product Architecture Principle separates
business functionality (what you want to do) from underlying technical
constructs (how it is done). In OO terms, classes defining business rules
and functionality must not depend upon or reflect those used to implement
or deploy the system.
The traceability characteristic allows users to ensure that business
requirements are transformed into deliverables completely and consistently.
That is, the solution implements end users' needs as expressed through
In addition, any successful OO approach will be:
- Use Case-driven -- this means that the business requirements for
the project are captured via Use Cases. These Use Cases will be translated
into artifacts that can be developed against, while providing the basis
for testing and quality assurance.
- Architecturally focused -- applying an architectural focus to the
development phases will highlight the division between the project's
technical and business architectures, and also help ensure the benefits
- Artifact- and asset-based -- an artifact is a tangible deliverable
necessary to define a system or expand its functionality. Artifacts
are created using the constructs of the Unified Modeling Language (UML).
Assets define the nature and functionality of the reusable components,
schedules and plans used to communicate with senior management, as well
as the functional descriptions that sales or marketing need. Assets
also reflect applied best practices, and are a tangible result of an
- Incremental, Iterative and Integrative (I3) -- the I3 approach breaks
the software development life cycle into successive progressions so
that the project consists of mini life cycles, each of which completely
develops some system sub-component. Iterations are further process divisions.
How the discrete parts are brought back together is the concept of integrative
OO life-cycle phases
There are seven phases in the OO life cycle: Requirements Modeling (RM),
Analysis Modeling (AM), Design Modeling (DM), Implementation Modeling
(IM), Coding (C), Quality Assurance & Testing (QAT) and Maintenance
Requirements Modeling is the foundation for the entire life cycle. Assets
and artifacts developed here will be the basis of later development and
will enable traceability.
RM captures users' desired business functionality and the business rules
for the system. All RM activities and deliverables are expressed in the
semantics of the business user. These elements also serve as the input
for quality assurance. The business analyst is responsible for eliciting
and documenting requirements from the user.
Conceptual User Interface concepts can also be identified, explored
and documented. The most important activity is Use Case Modeling, a complete
methodology in and of itself. Other techniques facilitate Use Case Modeling
deliverables. These include Concept-Responsibility-Collaboration (CRC)
modeling, which is also known as Class-Responsibility-Collaboration modeling.
This technique identifies basic business constructs, their primary responsibilities
and other business constructs involved in satisfying these responsibilities.
RM has three deliverables:
- The Use Case Model, a set of Use Case diagrams showing actors, uses
cases and the relationships among them, with textual descriptions.
- The High-Order Concept Model, generally a result of CRC modeling or
Noun-Verb analysis, which formalizes fundamental business concepts and
their relationships expressed semantically.
- A set of documents that capture the product's capabilities, those
aspects of the business system not implicit in the business rules. These
can include performance requirements, timing semantics, and space and
Analysis Modeling applies object orientation to the business model defined
in RM. In AM, we translate users' requirements into OO representations
using modeling techniques like the UML.
Two key AM functions are traceability and the exploration of business
requirements. AM also lays the groundwork for the balance of the development
activities that specify, enhance and adapt the model to the realities
of the production environment to ensure traceability. Thus, AM must accurately
reflect the business constructs defined in the RM. The business representatives
are responsible for that validation. To maintain traceability, the development
team must not alter the AM fundamentals when specifying, enhancing and
adapting it to the production environment.
The primary AM deliverables are diagrams expressed in the OO notation
of choice, documenting the static and dynamic perspectives of the system.
On the static side, the UML provides Class Diagrams that model the classes
relationships, and Package Diagrams that organize and group related functionality.
On the dynamic side, Sequence Diagrams and Collaboration Diagrams capture
objects' interactions, or the messages they pass to accomplish specified
functionality. Additionally, State Diagrams model transformations of an
object of a specific class.
On the static side, the transformation of the High-Order Concept Model
(HCM) is relatively straightforward. Most of the Concepts in the HCM are
modeled as classes in Class Diagrams. Some may become a simple attribute
of some other class.
Design Modeling is applying the Technical Architecture to OO business
constructs. While RM and AM address "what" to do, DM addresses "how" to
A Technical Architecture is the complete set of technical constructs
needed to implement business rules in a system. They can be divided into
hardware/software constructs and philosophical constructs. Some specific
elements of these aspects are:
- Hardware/Software Constructs such as User Interface Frameworks (MFC,
AWT), implementation languages (Java, C++), distributed middleware (CORBA,
DCOM), messaging middleware, persistency and frameworks to implement
any or all of the previous.
- Philosophical Constructs such as network topologies (OSI model), distributed
architectures (two- and three-tier, peer-to-peer), system topologies
and design patterns (State Patterns, Factory Patterns).
- DM is a continuation of the work performed in AM, but with a broader
and more detailed scope. The processes and techniques used in DM are
varied and wide-ranging, but rest on a fundamental understanding of
the domain of the solution.
It is in DM where details of classes,
attributes and methods in an implementation language are specified, and
where a specific language, such as Java or C++, is first addressed.
Implementation Modeling addresses the deployment or distributed processing
issues of the Technical Architecture.
Modern production business applications use distributed computing architectures
to allocate functionality to the most appropriate, powerful and cost-effective
processing environment. In general, this means different implementation
Another key issue IM addresses is integrating OO and non-OO (data- and
function-oriented) systems. Three flavors of such systems may need to
- New systems developed as part of the current effort.
- Heritage systems that have been previously developed, and whose functionality
we are incorporating.
- Legacy systems also previously developed and to be incorporated, but
from which we plan to migrate.
Each type of non-OO system has a different implication on our object
model. Translating OO concepts into their corresponding non-OO representations
can be quite involved and messy. Effective encapsulation, which hides
the details, is key to maintaining a meaningful object model.
IM and DM activities and deliverables are very similar. The important
distinction is their focus.
As with DM, IM can uncover new support classes. This triggers additional
modeling activities from the previous phases. However, IM adds one additional
form of documentation. The Deployment View is a UML diagram that lays
out the processors of a Technical Architecture, the systems running on
those processors, and the communication media that link them.
An additional IM element is identifying object/non-object boundaries
and specifying the classes, data and functionality that encapsulate that
Coding is the biggest phase of the development cycle in most methodologies
and most practical experience. In this approach, however, it becomes one
of the smallest life-cycle phases because virtually all of the work to
define and expand the functionality in this system has already occurred.
Source code generation and round-trip engineering allow the development
of a consistent model and code base. The model becomes another form of
coding and the code simply a different representation of the model. By
maintaining this integration, we establish the last link in traceability
from Requirements Analysis through Quality Assurance & Testing.
Again, new classes may be discovered in the Coding process. This means
further modeling activities. It is imperative that
developers understand that they shouldn't explore these new classes in
the code, but allow them to be modeled first.
Quality Assurance & Testing verifies technical and business functionality.
As the life cycle's components differ, so
do their validation and verification. The goals are the same, but the
focus is different.
Finally, Maintenance in the OO approach simply reapplies the life cycle.
Its primary concern is identifying when modification and enhancement requests
suggest another development effort. The best course is to map those requests
to Use Cases, and to assess the implied level of effort.