Visual Modeling with Rational Rose 2000 and UML

Visual Modeling with Rational Rose 2000 and UML
TERRY QUATRANI
Publisher: Addison Wesley
Second Edition October 19, 1999
ISBN: 0-201-69961-3, 288 pages

The Unified Modeling Language (UML) offers standard semantics and notation for describing object structure and behavior and has emerged as the design medium of choice for developing large-scale distributed object applications. Augmented by the Rational Unified Process, an extensive set of software development guidelines, and the Rational Rose visual modeling tool, the UML greatly facilitates the development of quality object-oriented applications that meet both deadlines and requirements.

Visual Modeling with Rational Rose 2000 and UML is a comprehensive introduction and tutorial providing guidance on how to use a tool (Rational Rose 2000), a process (the Rational Unified Process), and a language (the UML) to successfully visualize, specify, document, and construct a software system. Written by the Rose Evangelist at Rational Software Corporation, a leader in UML and object technology, this book breaks the technology down to its essentials and provides clear explanations of each element. It follows a simplified version of the Rational Unified Process from project inception through system analysis and design. A sample case study running throughout the book illustrates this iterative development process, the UML in practice, and the application of Rational Rose. New appendices demonstrate code generation and reverse engineering using Rational Rose 2000 with the Visual C++, C++, and Visual Basic languages.
Topics covered include:
• Creating use cases
• Finding objects and classes
• UML stereotypes and packages
• Scenarios, sequence diagrams, and collaboration diagrams
• Discovering object interaction
• Specifying relationships, association, and aggregation
• Adding behavior and structure
• Superclass/subclass relationships and inheritance
• Object behavior and Harel state transition diagrams
• Checking for model consistency
• Specifying, visualizing, and documenting system architecture
• The iteration planning process

Foreword
Preface
Approach
Chapter Summaries
Acknowledgments
1. Introduction
What is Visual Modeling
The Triangle For Success
The Role of Notation
History of the UML
The Role of Process
What is Iterative and Incremental Development
The Rational Unified Process
The Rational Rose Tool
Summary
2. Beginning a Project
Defining the Right Project
Eastern State University (ESU) Background
Risks for the Course Registration Problem
ESU Course Registration Problem Statement
Summary
3. Creating Use Cases
System Behavior
Actors
Use Cases
Use Case Relationships
Use Case Diagrams
Activity Diagrams
Summary
4. Finding Classes
What is an Object?
State, Behavior, and Identity
What is a Class?
Stereotypes and Classes
Discovering Classes
Documenting Classes
Packages
Objects and Classes in the ESU Course Registration Problem
Class Diagrams
Summary

5. Discovering Object Interaction
Use Case Realization
Documenting Scenarios
Sequence Diagrams
Sequence Diagrams And Boundary Classes
Complexity And Sequence Diagrams
Collaboration Diagrams
Why Are There Two Different Diagrams?
Sequence Diagram For The ESU Course Registration System
Summary
6. Specifying Relationships
The Need for Relationships
Association Relationships
Aggregation Relationships
Association or Aggregation?
Naming Relationships
Role Names
Multiplicity Indicators
Reflexive Relationships
Finding Relationships
Package Relationships
Summary
7. Adding Behavior and Structure
Representing Behavior and Structure
Creating Operations
Documenting Operations
Relationships and Operation Signatures
Creating Attributes
Documenting Attributes
Displaying Attributes and Operations
Association Classes
Summary
8. Discovering Inheritance
Inheritance
Generalization
Specialization
Inheritance Trees
Single Inheritance Versus Multiple Inheritance
Inheritance Versus Aggregation
Summary
9. Analyzing Object Behavior
Modeling Dynamic Behavior
States
State Transitions
Special States
State Transition Details
State Details
Summary
10. Checking the Model
Why Homogenize
Combining Classes
Splitting Classes
Eliminating Classes
Consistency Checking
Scenario Walk-Through
Event Tracing
Documentation Review
Summary
11. Designing the System Architecture
The Need For Architecture
The Architecture Team
The 4 + 1 View Of Architecture
The Logical View
The Implementation View
The Process View
The Deployment View
The Use Case View
Summary
12. Building the Iterations
The Iteration Planning Process
Designing The User Interface
Adding Design Classes
The Emergence Of Patterns
Designing Relationships
Designing Attributes And Operations
Designing For Inheritance
Coding, Testing, And Documenting The Iteration
Using Reverse Engineering To Set The Stage For The Next Iteration
Summary
A. Code Generation and Reverse Engineering with C++
Code Generation Steps
Reverse Engineering Steps
Code Generation
Step 2: Create Body Components in the Component Diagram
Step 3: Assign the C++ Language to the Components
Step 4: Assign Classes to Components
Step 5: Attach Property Sets to Modeling Elements
Step 6: Select the Components and Generate the Code
Step 7: Evaluate the Code Generation Errors
Reverse Engineering using the C++ Analyzer
Step 2: Add Project Caption
Step 3: Add Referenced Libraries and Base Projects
Step 4: Set the File Type and Analyze the Files
Step 5: Evaluate the Errors
Step 6: Select Export Options and Export to Rose
Step 7: Update Rose Model
B. Code Generation and Reverse Engineering with Visual C++ and Visual Basic
Code Generation Steps
Reverse Engineering Steps
code generation
Step 5: Evaluate the Code Generation Errors
Reverse Engineering
Step 2: Evaluate the Errors
C. A Visual Basic Example
Make an activex dll
Reuse the activex dll

Download
Another Software Engineering Books