Register your product to gain access to bonus material or receive a coupon.
Visual Modeling with Rational Rose 2002 and UML, 3rd Edition
- By Terry Quatrani
- Published Oct 9, 2002 by Addison-Wesley Professional. Part of the Addison-Wesley Object Technology Series series.
Book
- Sorry, this book is no longer in print.
Description
- Copyright 2003
- Dimensions: 7" x 9"
- Edition: 3rd
- Book
- ISBN-10: 0-201-72932-6
- ISBN-13: 978-0-201-72932-0
The third edition of this popular book retains the practical approach to teaching visual modeling techniques and the industry standard Unified Modeling Language. Author Terry Quatrani, the Rose Evangelist from Rational Software Corporation, still uses the simplified case study (a course registration system for a fictional university) that has taught thousands of readers how to analyze and design an application using UML, and how to implement the application using Rational Rose. The screen shots and Rational Rose instructions have been updated to reflect the release of Rational Rose 2002. After a short history of the evolution of UML and a guide to the basic terms of software engineering, the book introduces the concept of requirements, use cases, and class diagrams. Further chapters move toward defining an architecture and even refining the design within the incremental methodology of Rational Rose.
Sample Content
Online Sample Chapter
Introduction to Visual Modeling with Rational Rose 2002 and UML
Downloadable Sample Chapter
Click below for Sample Chapter(s) related to this title:
Sample
Chapter 1
Table of Contents
(NOTE: Each chapter concludes with a Summary.)
Foreword.
Preface.
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.
2. Beginning a Project.
Defining the Right Project.
Eastern State University (ESU) Background.
Risks for the Course Registration Problem.
ESU Course Registration Problem Statement.
3. Creating Use Cases.
System Behavior.
Actors.
Use Cases.
Use Case Relationships.
Use Case Diagrams.
Activity Diagrams.
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.
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.
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.
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.
8. Discovering Inheritance.
Inheritance.
Generalization.
Specialization.
Inheritance Trees.
Single Inheritance versus Multiple Inheritance.
Inheritance versus Aggregation.
9. Analyzing Object Behavior.
Modeling Dynamic Behavior.
States.
State Transitions.
Special States.
State Transition Details.
State Details.
10. Checking the Model.
Why Homogenize?
Combining Classes.
Splitting Classes.
Eliminating Classes.
Consistency Checking.
Scenario Walk-Through.
Event Tracing.
Documentation Review.
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.
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.
Appendix A: Code Generation and Reverse Engineering with C++.
Appendix B: Code Generation and Reverse Engineering with Visual C++ and Visual Basic.
Appendix C: A Visual Basic Example.
Glossary.
Index. 0201729326T09262002
Preface
Goals
When I set out to write the first version of this book, I thought, "This should be pretty easy . . . I do this for a living." Boy, was I wrong! Putting into words what I do on a daily basis was one of the hardest things I have ever done (all right, childbirth was more painful, but not by much). But I persevered, spent many, many nights and weekends in front of my computer, and gave birth to Visual Modeling with Rational Rose and UML. I must admit that the first time I saw my book on the bookshelf at a local bookstore, I was thrilled. I also found out that you need to have very thick skin to read book reviews. My book is unique since people seem to love it (5 stars) or they are less than impressed with it (1 star). For some reason, I rarely get a rating in between.
I have also figured out that writing a book that is tied to a tool is like rearing a child—it needs constant care. So, once again, I have spent hours in front of my computer updating my book to adhere to the features found in Rational Rose 2002. And no, writing it has not gotten much easier. As far as the two camps of reviewers, nothing will change there. If you liked the first two versions, you will like this one since the goal of the book has not changed: to be a simple introduction to the world of visual modeling.
If you were less than impressed with the first two versions, you will probably not like this version either. It is not a complete guide to the UML (these books have been written by Grady and Jim and I am not even going to attempt to compete with the definitive experts). It is not a complete guide to the Rational Unified Process (these books have been written, quite nicely, by Philippe and Ivar). It is not even a good book on C++ (in fact, I usually tell people that I no longer write code for a living, and there is a very good reason that I don't). As I stated, this book is meant to take a simple, first look at how a process, a language, and a tool may be used to create a blueprint of your system.
ApproachThis book takes a practical approach to teaching visual modeling techniques and the UML. It uses a case study to show the analysis and design of an application. The application is a course registration system for a university. This problem domain was chosen because it is understood easily and is not specific to any field of computer science. You can concentrate on the specifics of modeling the domain rather than investing time in understanding an unfamiliar problem domain.
The problem is treated seriously enough to give you practical exercise with visual modeling techniques and the feeling for solving a real problem, without being so realistic that you are bogged down in details. Thus many interesting and perhaps necessary requirements, considerations, and constraints were put aside to produce a simplified, yet useful case study fitting the scope of this book.
For additional details on visual modeling and the UML or on applying the techniques to your application, you should consider the training and mentoring services offered by Rational Software Corporation. Details may be found at the Rational website: www.rational.com.
Chapter SummariesThe ordering and number of chapters in this version of the book have not been changed, but the content of the chapters has been updated. The screen shots and Rational Rose instructions have been changed so they reflect what you will see with Rational Rose 2002.
Chapter 1: Introduction
Introduces the techniques, language, and process that are used throughout the book. This chapter discusses the benefits of visual modeling, the history of the UML, and the software development process used.
Chapter 2: Beginning a Project
Contains information that is related to the Course Registration System case study that is used throughout the book.
Chapter 3: Creating Use Cases
Discusses the techniques used to examine system behavior from a use-case approach.
Chapter 4: Finding Classes
Discusses the concepts and notations used for finding objects and classes. This chapter also discusses the UML concepts of stereotypes and packages.
Chapter 5: Discovering Object Interaction
Discusses the addition of scenarios to the system to describe how use cases are realized as interactions among societies of objects. This chapter also examines how sequence diagrams and collaboration diagrams may be used to capture scenarios.
Chapter 6: Specifying Relationships
Illustrates the definition of relationships between classes in the system. Specifically, the concepts of association and aggregation are explored.
Chapter 7: Adding Behavior and Structure
Shows how the needed structure and behavior of classes are added to the model under development.
Chapter 8: Discovering Inheritance
Illustrates the application of generalization and specialization principles to discover superclass/subclass relationships.
Chapter 9: Analyzing Object Behavior
Uses Harel state transition diagrams to provide additional analysis techniques for classes with significant dynamic behavior.
Chapter 10: Checking the Model
Discusses techniques used to blend and check models for consistency. These techniques are needed when different teams are working on a single project in parallel.
Chapter 11: Designing the System Architecture
Contains an introduction to the concepts and notation needed to specify and document the system architecture. This chapter is not meant to be a tell-all process guide to the development of the architecture—it is meant to be a guide to the notation and process used to specify, visualize, and document the system architecture. It is placed at this point in the structure of the book since the architectural decisions specified in this chapter must be made prior to the information contained in later chapters.
Chapter 12: Building the Iterations
Discusses the iteration planning process. It also looks at the UML notation used to specify and document the design decisions that occur during the implementation of an iteration. The chapter does not focus on good (or bad) design decisions—it looks at the process and notations used to capture the design of an iteration.
Appendix A: Code Generation and Reverse Engineering with C++
Provides step-by-step guides to code generation and reverse engineering using the Rational Rose 2002 and the C++ language.
Appendix B: Code Generation and Reverse Engineering with Visual C++ and Visual Basic
Provides step-by-step guides to code generation and reverse engineering using Rational Rose 2002 and the Visual C++ and Visual Basic languages.
Appendix C: A Visual Basic Example
Provides a step-by-step demonstration showing how to create and reuse a Visual Basic DLL.
Glossary
Provides definitions of terms used throughout the book.
0201729326P09262002
Index
Click below to download the Index file related to this title:
Index