Overview

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.   Object-Oriented Software Engineering Using UML, Patterns, and Java, 3e, shows readers 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: readers 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).

Full Product Details

Author:   Bernd Bruegge ,  Allen Dutoit ,  Allen Dutoit
Publisher:   Pearson Education (US)
Imprint:   Pearson
Edition:   3rd edition
Dimensions:   Width: 1.00cm , Height: 1.00cm , Length: 1.00cm
Weight:   1.320kg
ISBN:  

9780136061250

ISBN 10:   0136061257
Pages:   816
Publication Date:   12 October 2009
Audience:   College/higher education ,  Tertiary & Higher Education
Replaced By:   9781292024011
Format:   Hardback
Publisher's Status:   Active
Availability:   In Print  
This item will be ordered in for you from one of our suppliers. Upon receipt, we will promptly dispatch it out to you. For in store availability, please contact us.

Table of Contents

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

Reviews

Author Information

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.

Tab Content 6

Author Website:  

Customer Reviews

Recent Reviews

No review item found!

Add your own review!

Countries Available

All regions