Top

Amazon no longer offers textbook rentals. We do!

Object-Oriented Software Engineering Using UML, Patterns, and Java

by: Bruegge, Bernd; Dutoit, Allen H.

Object-Oriented Software Engineering Using UML, Patterns, and Java

by: Bruegge, Bernd; Dutoit, Allen H.

ISBN 13:
9780136061250
ISBN 10:
0136061257
Edition: 3rd
Format: Hardcover
Copyright: 07/29/2009
Publisher: Pearson

Rent From $18.55

Used From $35.57

New From $218.78

List Price $219.98 Save

Rent $18.55

TERM	PRICE	DUE
SEMESTER	$76.22	Aug 02
QUARTER	$72.41	Jul 17
SHORT TERM	$18.55	Jun 07

Added Benefits of Renting

Free Shipping Both Ways
Highlight/Take Notes Like You Own It
Purchase/Extend Before Due Date

Add to Cart

Free Shipping On Every Order

|In Stock Usually Ships in 24 Hours.

List Price $219.98 Save $184.41

Used $35.57

In Stock Usually Ships in 24 Hours.

We Buy This Book Back!

Included with your book

Free Shipping On Every Order

Add to Cart

List Price $219.98 Save $1.20

New $218.78

Print on Demand: 2-4 Weeks. This item cannot be cancelled or returned.

We Buy This Book Back!

Included with your book

Free Shipping On Every Order

Add to Cart

Note: Supplemental materials are not guaranteed with Rental or Used book purchases.

Extend or Purchase Your Rental at Any Time

Need to keep your rental past your due date? At any time before your due date you can extend or purchase your rental through your account.

Object-Oriented Software Engineering Using UML, Patterns, and Java > ISBN13: 9780136061250

Summary

This widely used book teaches practical object-oriented software engineering with the key real world tools UML, design patterns and Java. This step-by-step approach allows the reader to address complex and changing problems with practical and state-of-the-art solutions.This book uses examples from real systems and examines the interaction between such techniques as UML, Java-based technologies, design patterns, rationale, configuration management, and quality control. It also discusses project management related issues and their impacts.A valuable book for development engineers, software engineers, consulting engineers, software architects, product managers, project leaders, and knowledge managers.

Author Biography

Dr. Bernd Bruegge has been studying and teaching Software Engineering at Carnegie Mellon University for 20 years, where he received his masters and doctorate degrees. He received his Diplom from the University of Hamburg. He is now a university professor of Computer Science with a chair for Applied Software Engineering at the Technische Universitat Munchen and an adjunct faculty member of Carnegie Mellon University. He has taught object-oriented software engineering project courses on the text materials and website described in this book since 1988. He won the Herbert A. Simon Excellence in Teaching Award at Carnegie Mellon University in 1995. Bruegge is also an international consultant and has used the techniques in this book to design and implement many real systems, including an engineering feedback system for DaimlerChrysler, an environmental modeling system for the U.S. Environmental Protection Agency, an accident management system for a municipal police department and a 3-D visualization system for the Munich Airport, to name just a few.

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.

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

Supplemental Materials

What is included with this book?

The New copy of this book will include any supplemental materials advertised. Please check the title of the book to determine if it should include any access cards, study guides, lab manuals, CDs, etc.

The Used, Rental and eBook copies of this book are not guaranteed to include any supplemental materials. Typically, only the book itself is included. This is true even if the title states it includes any access cards, study guides, lab manuals, CDs, etc.