Object-Oriented Software Engineering Using UML, Patterns, and Java, 3rd edition
Published by Unknown (July 29, 2009) © 2010
- Bernd Bruegge
- Allen H. Dutoit Technical University of Munich
eTextbook
- Easy-to-use search and navigation
- Add notes and highlights
- Search by keyword or page
- Hardcover, paperback or looseleaf edition
- Affordable rental option for select titles
For courses in Software Engineering, Software Development, or Object-Oriented Design and Analysis at the Junior/Senior or Graduate level. This text can also be utilized in short technical courses or in short, intensive management courses.
Shows students how to use both the principles of software engineering and the practices of various object-oriented tools, processes, and products.
Using a step-by-step case study to illustrate the concepts and topics in each chapter, Bruegge and Dutoit emphasize learning object-oriented software engineer through practical experience: students can apply the techniques learned in class by implementing a real-world software project.
The third edition addresses new trends, in particular agile project management (Chapter 14 Project Management) and agile methodologies (Chapter 16 Methodologies).
For the Student
An object-oriented modeling approach covers techniques in a step-by-step manner, from requirements elicitation to testing, enabling students to grasp the complexity of object-oriented modeling.
State-of-the-art coverage of Object-Oriented software engineering shows students how to use the most practical aspects of software engineering including the basic elements of UML (Unified Modeling Language), Java, Distributed Development, Rationale Management, Configuration Management, and Build- and Release Management.
The "Further Readings" section enables students to search for specialized material on the topic presented.
For the Instructor
The Instructor Resource Center includes a new series of directory resources and lecture slides. These resources offer instructors excellent support and flexibility in planning their course, and they provide students with more hands-on practice at modeling skills.
Instructor Directory Resources: Contains 39 PowerPoint presentations organized in 16 chunks which correspond to the chapters of the book. The slides are in "PowerPoint Microsoft PowerPoint 97-2004" format. We have chosen this format for compatibility reasons. We have successfully tested the slides with the 2008 version of PowerPoint. The chunks contain the slides and additional materials the authors use in their lectures. Some of the chapters also contain material or large homework exercises. The lecture and materials can be used for a two semester course with up to 39 lectures and a final review session.  The material can also be used for a single semester class, in which case the chunks provide the basis for 17 lectures and a final review session. Finally, the slides can be used for a senior software engineering project course usually includes lectures, project reviews, and tool tutorials.   Some materials from past project courses such as problement statements, slides and movies from project kickoff, project review and client acceptance events are available for instructors on request from the authors.
PowerPoint Lecture Slides:  Contain solely the PowerPoint Lecture Slides (also included in Instructor Directory Resources).
Solutions: The homework solutions are available for instructors on request.
The "Further Readings" section gives instructors flexibility when assigning out-of-class readings.
NEW. A comprehensive upgrade to the latest version of UML and OCL. All diagrams were checked and revised to take advantage of the latest development in UML. Chapters on System Design and Object Design now include new material on component diagrams and modeling of services.
NEW. Material on agile methods. The chapter on "Configuration Management" describes continuous integration; the chapter on "Project Management" covers Scrum; the chapter on "Methodologies" contrasts agile methodologies--such as XP, Scrum, and Rugby--with traditional methodologies based on the Unified process.
NEW. Material on U2TP. The chapter on "Testing" includes new material on modeling the test system, test automation, and the UML2 Testing Profile.
UPDATED. Examples. The examples in the new edition are updated and improved based on feedback from many readers and students.
Foreword
Preface
Acknowledgments
Â
PART I Getting Started
Chapter 1 Introduction to Software Engineering
1.1 Introduction: Software Engineering Failures
1.2 What Is Software Engineering?
    1.2.1 Modeling
    1.2.2 Problem Solving
    1.2.3 Knowledge Acquisition
    1.2.4 Rationale
1.3 Software Engineering Concepts 1
    1.3.1 Participants and Roles
    1.3.2 Systems and Models
    1.3.3 Work Products
    1.3.4 Activities, Tasks, and Resources
    1.3.5 Functional and Nonfunctional Requirements
    1.3.6 Notations, Methods, and Methodologies
1.4 Software Engineering Development Activities
    1.4.1 Requirements Elicitation
    1.4.2 Analysis
    1.4.3 System Design
    1.4.4 Object Design
    1.4.5 Implementation
    1.4.6 Testing
1.5 Managing Software Development
    1.5.1 Communication
    1.5.2 Rationale Management
    1.5.3 Software Configuration Management
    1.5.4 Project Management
    1.5.5 Software Life Cycle
    1.5.6 Putting It All Together
1.6 ARENA Case Study
1.7 Further Reading
1.8 Exercises
Â
Chapter 2 Modeling with UML
2.1 Introduction
    2.2 An Overview of UML
    2.2.1 Use Case Diagrams
    2.2.2 Class Diagrams
    2.2.3 Interaction Diagrams
    2.2.4 State Machine Diagrams
    2.2.5 Activity Diagrams
2.3 Modeling Concepts
    2.3.1 Systems, Models, and Views
    2.3.2 Data Types, Abstract Data Types, and Instances
    2.3.3 Classes, Abstract Classes, and Objects
    2.3.4 Event Classes, Events, and Messages
    2.3.5 Object-Oriented Modeling
    2.3.6 Falsification and Prototyping
2.4 A Deeper View into UML
    2.4.1 Use Case Diagrams
    2.4.2 Class Diagrams
    2.4.3 Interaction Diagrams
    2.4.4 State Machine Diagrams
    2.4.5 Activity Diagrams
    2.4.6 Diagram Organization
    2.4.7 Diagram Extensions
2.5 Further Readings
2.6 Exercises
Â
Chapter 3 Project Organization and Communication
3.1 Introduction: A Rocket Example
3.2 An Overview of Projects
3.3 Project Organization Concepts
3.3.1 Project Organizations
    3.3.2 Roles
    3.3.3 Tasks and Work Products
    3.3.4 Schedule
3.4 Project Communication Concepts
    3.4.1 Planned Communication
    3.4.2 Unplanned Communication
    3.4.3 Communication Mechanisms
3.5 Organizational Activities
    3.5.1 Joining a Team
    3.5.2 Joining the Communication Infrastructure
    3.5.3 Attending Team Status Meetings
    3.5.4 Organizing Client and Project Reviews
3.6 Further Readings
3.7 Exercises
Â
PART II Dealing with Complexity
Chapter 4 Requirements Elicitation
4.1 Introduction: Usability Examples
4.2 An Overview of Requirements Elicitation
4.3 Requirements Elicitation Concepts
    4.3.1 Functional Requirements
    4.3.2 Nonfunctional Requirements
    4.3.3 Completeness, Consistency, Clarity, and Correctness
    4.3.4 Realism, Verifiability, and Traceability
    4.3.5 Greenfield Engineering, Reengineering, and Interface Engineering
4.4 Requirements Elicitation Activities
    4.4.1 Identifying Actors
    4.4.2 Identifying Scenarios
    4.4.3 Identifying Use Cases
    4.4.4 Refining Use Cases
    4.4.5 Identifying Relationships among Actors and Use Cases
    4.4.6 Identifying Initial Analysis Objects
    4.4.7 Identifying Nonfunctional Requirements
4.5 Managing Requirements Elicitation
    4.5.1 Negotiating Specifications with Clients: Joint Application Design
    4.5.2 Maintaining Traceability
    4.5.3 Documenting Requirements Elicitation
4.6 ARENA Case Study
    4.6.1 Initial Problem Statement
    4.6.2 Identifying Actors and Scenarios
    4.6.3 Identifying Use Cases
    4.6.4 Refining Use Cases and Identifying Relationships
    4.6.5 Identifying Nonfunctional Requirements
    4.6.6 Lessons Learned
4.7 Further Readings
4.8 Exercises
Â
Chapter 5Analysis
5.1 Introduction: An Optical Illusion
5.2 An Overview of Analysis
5.3 Analysis Concepts
    5.3.1 Analysis Object Models and Dynamic Models
    5.3.2 Entity, Boundary, and Control Objects
    5.3.3 Generalization and Specialization
5.4 Analysis Activities: From Use Cases to Objects
    5.4.1 Identifying Entity Objects
    5.4.2 Identifying Boundary Objects
    5.4.3 Identifying Control Objects
    5.4.4 Mapping Use Cases to Objects with Sequence Diagrams
    5.4.5 Modeling Interactions among Objects with CRC Cards
    5.4.6 Identifying Associations
    5.4.7 Identifying Aggregates
    5.4.8 Identifying Attributes
    5.4.9 Modeling State-Dependent Behavior of Individual Objects
    5.4.10 Modeling Inheritance Relationships between Objects
    5.4.11 Reviewing the Analysis Model
    5.4.12 Analysis Summary
5.5 Managing Analysis
    5.5.1 Documenting Analysis
    5.5.2 Assigning Responsibilities
    5.5.3 Communicating about Analysis
    5.5.4 Iterating over the Analysis Model
    5.5.5 Client Sign-Off
5.6 ARENA Case Study
    5.6.1 Identifying Entity Objects
    5.6.2 Identifying Boundary Objects
    5.6.3 Identifying Control Objects
    5.6.4 Modeling Interactions Among Objects
    5.6.5 Reviewing and Consolidating the Analysis Model
    5.6.6 Lessons Learned
5.7 Further Readings
5.8 Exercises
Â
Chapter 6System Design: Decomposing the System
6.1 Introduction: A Floor Plan Example
6.2 An Overview of System Design
6.3 System Design Concepts
    6.3.1 Subsystems and Classes
    6.3.2 Services and Subsystem Interfaces
    6.3.3 Coupling and Cohesion
    6.3.4 Layers and Partitions
    6.3.5 Architectural Styles
6.4 System Design Activities: From Objects to Subsystems
    6.4.1 Starting Point: Analysis Model for a Route Planning System
    6.4.2 Identifying Design Goals
    6.4.3 Identifying Subsystems
6.5 Further Readings
6.6 Exercises
Â
Chapter 7System Design: Addressing Design Goals
7.1 Introduction: A Redundancy Example
7.2 An Overview of System Design Activities
7.3 Concepts: UML Deployment Diagrams
7.4 System Design Activities: Addressing Design Goals
    7.4.1 Mapping Subsystems to Processors and Components
    7.4.2 Identifying and Storing Persistent Data
    7.4.3 Providing Access Control
    7.4.4 Designing the Global Control Flow
    7.4.5 Identifying Services
    7.4.6 Identifying Boundary Conditions
    7.4.7 Reviewing System Design
7.5 Managing System Design
    7.5.1 Documenting System Design
    7.5.2 Assigning Responsibilities
    7.5.3 Communicating about System Design
    7.5.4 Iterating over the System Design
7.6 ARENA Case Study
    7.6.1 Identifying Design Goals
    7.6.2 Identifying Subsystems
    7.6.3 Mapping Subsystems to Processors and Components
    7.6.4 Identifying and Storing Persistent Data
    7.6.5 Providing Access Control
    7.6.6 Designing the Global Control Flow
    7.6.7 Identifying Services
    7.6.8 Identifying Boundary Conditions
    7.6.9 Lessons Learned
7.7 Further Readings
7.8 Exercises
Â
Chapter 8Object Design: Reusing Pattern Solutions
8.1 Introduction: Bloopers
8.2 An Overview of Object Design
8.3 Reuse Concepts: Solution Objects, Inheritance, and Design Patterns   Â
    8.3.1 Application Objects and Solution Objects
    8.3.2 Specification Inheritance and Implementation Inheritance
    8.3.3 Delegation
    8.3.4 The Liskov Substitution Principle
    8.3.5 Delegation and Inheritance in Design Patterns
8.4 Reuse Activities: Selecting Design Patterns and Components
    8.4.1 Encapsulating Data Stores with the Bridge Pattern
    8.4.2 Encapsulating Legacy Components with the Adapter Pattern
    8.4.3 Encapsulating Context with the Strategy Pattern
    8.4.4 Encapsulating Platforms with the Abstract Factory Pattern
    8.4.5 Encapsulating Control Flow with the Command Pattern
    8.4.6 Encapsulating Hierarchies with the Composite Design Pattern
    8.4.7 Heuristics for Selecting Design Patterns
    8.4.8 Identifying and Adjusting Application Frameworks
8.5 Managing Reuse
    8.5.1 Documenting Reuse
    8.5.2 Assigning Responsibilities
8.6 ARENA Case Study
    8.6.1 Applying the Abstract Factory Design Pattern
    8.6.2 Applying the Command Design Pattern
    8.6.3 Applying the Observer Design Pattern
    8.6.4 Lessons Learned
8.7 Further Readings
8.8 Exercises
Â
Chapter 9 Object Design: Specifying Interfaces
9.1 Introduction: A Railroad Example
9.2 An Overview of Interface Specification
9.3 Interface Specification Concepts
    9.3.1 Class Implementor, Class Extender, and Class User
    9.3.2 Types, Signatures, and Visibility
    9.3.3 Contracts: Invariants, Preconditions, and Postconditions
    9.3.4 Object Constraint Language
    9.3.5 OCL Collections: Sets, Bags, and Sequences
    9.3.6 OCL Quantifiers: forAll and exists
9.4 Interface Specification Activities
    9.4.1 Identifying Missing Attributes and Operations
    9.4.2 Specifying Types, Signatures, and Visibility
    9.4.3 Specifying Pre- and Postconditions
    9.4.4 Specifying Invariants
    9.4.5 Inheriting Contracts
9.5 Managing Object Design
    9.5.1 Documenting Object Design
    9.5.2 Assigning Responsibilities
    9.5.3 Using Contracts During Requirements Analysis
9.6 ARENA Case Study
    9.6.1 Identifying Missing Operations in TournamentStyle and Round
    9.6.2 Specifying the TournamentStyle and Round Contracts
    9.6.3 Specifying the KnockOutStyle and KnockOutRound Contracts
    9.6.4 Lessons Learned
9.7 Further Readings
9.8 Exercises
Â
Chapter 10 Mapping Models to Code
10.1 Introduction: A Book Example
10.2 An Overview of Mapping
10.3 Mapping Concepts
    10.3.1 Model Transformation
    10.3.2 Refactoring
    10.3.3 Forward Engineering
    10.3.4 Reverse Engineering
    10.3.5 Transformation Principles
10.4 Mapping Activities
    10.4.1 Optimizing the Object Design Model
    10.4.2 Mapping Associations to Collections
    10.4.3 Mapping Contracts to Exceptions
    10.4.4 Mapping Object Models to a Persistent Storage Schema
10.5 Managing Implementation
    10.5.1 Documenting Transformations
    10.5.2 Assigning Responsibilities
10.6 ARENA Case Study
    10.6.1 ARENA Statistics
    10.6.2 Mapping Associations to Collections
    10.6.3 Mapping Contracts to Exceptions
    10.6.4 Mapping the Object Model to a Database Schema
    10.6.5 Lessons Learned
10.7 Further Readings
10.8 Exercises
Â
Chapter 11Testing 437
11.1 Introduction: Testing The Space Shuttle
11.2 An Overview of Testing
11.3 Testing Concepts
    11.3.1 Faults, Erroneous States, and Failures
    11.3.2 Test Cases
    11.3.3 Test Stubs and Drivers
    11.3.4 Corrections
11.4 Testing Activities
    11.4.1 Component Inspection
    11.4.2 Usability Testing
    11.4.3 Unit Testing
    11.4.4 Integration Testing
    11.4.5 System Testing
11.5 Managing Testing
    11.5.1 Planning Testing
    11.5.2 Documenting Testing
    11.5.3 Assigning Responsibilities
    11.5.4 Regression Testing
    11.5.5 Automating Testing
    11.5.6 Model-based Testing
11.6 Further Readings
11.7 Exercises
Â
PART III Managing Change
Chapter 12 Rationale Management
12.1 Introduction: Slicing Ham
12.2 An Overview of Rationale
12.3 Rationale Concepts
    12.3.1 Centralized Traffic Control
    12.3.2 Defining the Problem: Issues
    12.3.3 Exploring the Solution Space: Proposals
    12.3.4 Evaluating the Solution Space: Criteria and Arguments
    12.3.5 Collapsing the Solution Space: Resolutions
    12.3.6 Implementing Resolutions: Action Items
    12.3.7 Examples of Issue-Based Models and Systems
12.4 Rationale Activities: From Issues to Decisions
    12.4.1 CTC System Design
    12.4.2 Capturing Rationale in Meetings
    12.4.3 Capturing Rationale Asynchronously
    12.4.4 Capturing Rationale when Discussing Change
    12.4.5 Reconstructing Rationale
12.5 Managing Rationale
    12.5.1 Documenting Rationale
    12.5.2 Assigning Responsibilities
    12.5.3 Heuristics for Communicating about Rationale
    12.5.4 Issue Modeling and Negotiation
    12.5.5 Conflict Resolution Strategies
12.6 Further Readings
12.7 Exercises
Â
Chapter 13 Configuration Management
13.1 Introduction: An Aircraft Example
13.2 An Overview of Configuration Management
13.3 Configuration Management Concepts
    13.3.1 Configuration Items and CM Aggregates
    13.3.2 Versions and Configurations
    13.3.3 Change Requests
    13.3.4 Promotions and Releases
    13.3.5 Repositories and Workspaces
    13.3.6 Version Identification Schemes
    13.3.7 Changes and Change Sets
    13.3.8 Configuration Management Tools
13.4 Configuration Management Activities
    13.4.1 Configuration Item and CM Aggregate Identification
    13.4.2 Promotion Management
    13.4.3 Release Management
    13.4.4 Branch Management
    13.4.5 Variant Management
    13.4.6 Change Management
13.5 Managing Configuration Management
    13.5.1 Documenting Configuration Management
    13.5.2 Assigning Configuration Management Responsibilities
    13.5.3 Planning Configuration Management Activities
    13.5.4 Continuous Integration: Testing and Promotion Management
13.6 Further Readings
13.7 Exercises
Â
Chapter 14Project Management
14.1 Introduction: The STS-51L Launch Decision
14.2 An Overview of Project Management
14.3 Project Management Concepts
    14.3.1 Tasks and Activities
    14.3.2 Work Products, Work Packages, and Roles
    14.3.3 Work Breakdown Structure
    14.3.4 Task Model
    14.3.5 Skill Matrix
    14.3.6 The Software Project Management Plan
14.4 Classical Project Management Activities
    14.4.1 Planning the Project
    14.4.2 Organizing the Project
    14.4.3 Controlling the Project
    14.4.4 Terminating the Project
14.5 Agile Project Management Activities
    14.5.1 Planning the Project: Create Product and Sprint Backlogs
    14.5.2 Organizing the Project
    14.5.3 Controlling the Project: Daily Scrums and Burn Down Charts
    14.5.4 Terminating the Project: Sprint Reviews
14.6 Further Readings
14.7 Exercises
Â
Chapter 15Software Life Cycle
15.1 Introduction: Polynesian Navigation
15.2 IEEE 1074: Standard for Developing Life Cycle Processes
    15.2.1 Processes and Activities
    15.2.2 Life Cycle Modeling
    15.2.3 Project Management
    15.2.4 Pre-Development
    15.2.5 Development
    15.2.6 Post-Development
    15.2.7 Integral Processes (Cross-Development)
15.3 Characterizing the Maturity of Software Life Cycle Models
15.4 Life Cycle Models
    15.4.1 Sequential Activity-Centered Models
    15.4.2 Iterative Activity-Centered Models
    15.4.3 Entity-Centered Models
15.5 Further Readings
15.6 Exercises
Â
Chapter 16Methodologies: Putting It All Together
16.1 Introduction: The First Ascent of K2
16.2 Project Environment
16.3 Methodology Issues
    16.3.1 How Much Planning?
    16.3.2 How Much Reuse?
    16.3.3 How Much Modeling?
    16.3.4 How Much Process?
    16.3.5 How Much Control and Monitoring?
    16.3.6 When to Redefine Project Goals?
16.4 A Spectrum of Methodologies
    16.4.1 Royce’s Methodology
    16.4.2 Extreme Programming
    16.4.3 Rugby methodologies
16.5 Case Studies
    16.5.1 XP Project: ATRACT
    16.5.2 Local King Client: FRIEND
    16.5.3 Distributed Project: JAMES
    16.5.4 Case Studies Summary
16.6 Further Readings
16.7 Exercises
Â
PART IV Appendices
Appendix ADesign Patterns
A.1 Abstract Factory: Encapsulating Platforms
A.2 Adapter: Wrapping Around Legacy Code
A.3 Bridge: Allowing for Alternate Implementations
A.4 Command: Encapsulating Control Flow
A.5 Composite: Representing Recursive Hierarchies
A.6 Facade: Encapsulating Subsystems
A.7 Observer: Decoupling Entities from Views
A.8 Proxy: Encapsulating Expensive Objects
A.9 Strategy: Encapsulating Algorithms
A.10 Heuristics for Selecting Design Patterns
Â
Appendix B Glossary
Appendix CBibliography
Index
Dr. Allen Dutoit works in the aerospace industry in the area of avionics systems. He received his M.S. and Ph.D. from Carnegie Mellon University and his Diplôme d'Ingenieur from the Swiss Federal Institute of Technology in Lausanne. He has taught software engineering project courses with Professor Bruegge since 1993, both at Carnegie Mellon University and the Technische Universitat Munchen, where they used and refined the methods described in this book. Dutoit's research covered several areas of software engineering and object-oriented systems, including requirements engineering, rationale management, distributed development, and prototype-based systems. He was previously affiliated with the Software Engineering Institute and the Institute for Complex Engineered Systems at Carnegie Mellon University.
Need help? Get in touch
Play
Pearson eTextbook: What’s on the inside just might surprise you
They say you can’t judge a book by its cover. It’s the same with your students. Meet each one right where they are with an engaging, interactive, personalized learning experience that goes beyond the textbook to fit any schedule, any budget, and any lifestyle.Â
Digital Learning NOW
Extend your professional development and meet your students where they are with free weekly Digital Learning NOW webinars. Attend live, watch on-demand, or listen at your leisure to expand your teaching strategies. Earn digital professional development badges for attending a live session.