Software Engineering Modern Approaches 2nd edition by Eric Braude,Michael Bernstein 9781478632306 1478632305

PART I: Introduction to Software Engineering

Chapter 1: The Goals and Terminology of Software Engineering

1.1 What is Software Engineering

1.2 Why Software Engineering Is Critical: Software Disasters

1.2.1 The Virtual Case File Project

1.2.2 The Ariane project

1.2.3 Radiation Overdose

1.2.4 More Software Disasters

1.3 Why Software Fails or Succeeds

1.4 Software Engineering Activities

1.4.1 People

1.4.2 Product

1.4.3 Project

1.4.4 Process

1.5 Software Engineering Principles

1.6 Ethics in Software Engineering

1.7 Case Studies

1.8 Summary

1.9 Exercises

Bibliography

Chapter 2: Introduction to Quality and Metrics in Software Engineering

2.1 The Meaning of Software Quality

2.2 Defects in Software

2.3 Verification and Validation

2.4 Planning for Quality

2.5 Metrics

2.5.1 Quality Metrics

2.6 Summary

2.7 Exercises

Bibliography

PART II: Software Process

Chapter 3: Software Process

3.1 The Activities of Software Process

3.2 Software Process Models

3.2.1 The Waterfall Process Model

3.2.2 Iterative and Incremental Development

3.2.3 Prototyping, Feasibility Studies, and Proofs of Concept

3.2.4 Spiral Model

3.2.5 Unified Process and the Rational Unified Process

3.2.6 Agile Processes

3.2.7 Open-Source Processes

3.3 Case Study: Student Team Guidance

3.3.1 Team Guidance-Initial Team Meeting

3.3.2 Team Guidance-Communication Plan

3.3.3 Team Guidance-Test Communication Plan

3.4 Summary

3.5 Exercises

Bibliography

Chapter 4: Agile Software Processes

4.1 Agile History and Agile Manifesto

4.2 Agile Principles

4.3 Agile Methods

4.4 Agile Processes

4.4.1 Extreme Programming

4.4.2 Scrum

4.4.3 Crystal

4.5 Integrating Agile with Non-Agile Processes

4.5.1 A Non-Agile-Driven Approach

4.5.2 An Agile-Driven Approach

4.6 Summary

4.7 Exercises

Bibliography

Chapter 5: Quality in the Software Process

5.1 Principles of Managing Quality

5.2 Managing Quality in Agile Processes

5.3 Quality Planning

5.3.1 Software Quality Assurance Plan

5.3.2 IEEE Quality Documents

5.4 Inspections

5.4.1 Inspection Principles

5.4.2 Inspection Process

5.5 QA Reviews and Audits

5.6 Defect Management

5.6.1 Classifying Defects

5.6.2 Tracking Defects

5.7 Process Improvement and Process Metrics

5.8 Organization-Level Quality and the CMMI

5.8.1 Level 1: Initial

5.8.2 Level 2: Managed

5.8.3 Level 3: Defined

5.8.4 Level 4: Quantitatively Managed

5.8.5 Level 5: Optimizing

5.8.6 Relationship of the CMMI to the PSP, TSP

5.8.7 Relationship of the CMMI to Agile Methods

5.9 Case Study: Software Quality Assurance Plan for Encounter

5.10 Summary

5.11 Exercises

Bibliography

Chapter 6: Software Configuration Management

6.1 Software Configuration Management Goals

6.2 SCM Activities

6.2.1 Configuration Identification

6.2.2 Baselines

6.2.3 Change Control

6.2.4 Version Control

6.2.5 Configuration Audits

6.2.6 Configuration Status Reporting

6.2.7 Release Management and Delivery

6.3 Configuration Management Plans

6.4 Configuration Management Systems

6.4.1 Concurrent Version System (CVS)

6.5 Case Study: Encounter Video Game

6.6 Case Study: Eclipse

6.7 Student Team Guidance: Configuration Management

6.8 Summary

6.9 Exercises

Bibliography

PART III: Project Management

Chapter 7: Principles of Software Project Management I: Organization, Tools, and Risk Management

7.1 Software Project Organization

7.1.1 Project-Oriented Organization

7.1.2 Function-Oriented Organization

7.1.3 Matrix Organization

7.1.4 Agile Organization

7.2 Team Size

7.3 Geographically Distributed Development

7.4 The Team Software Process

7.4.1 Introductory Team Software Process (TSPi)

7.5 Software Project Tools and Techniques

7.5.1 Tool Selection

7.5.2 Build or Buy Decisions

7.5.3 Language Selection

7.5.4 Decision Making with Triage

7.5.5 Project Variables

7.6 Risk Management

7.7 Student Team Guidance: Organizing the Software Project’s Management

7.7.1 Team Guidance-Student Team Organization

7.7.2 Team Guidance-Team Meetings

7.8 Summary

7.9 Exercises

Bibliography

Chapter 8: Principles of Software Project Management II: Estimation, Scheduling, and Planning

8.1 Cost Estimation

8.1.1 Estimate Precision

8.1.2 Estimation Methods

8.1.3 Estimating Lines of Code without Function Points

8.1.4 Function Points

8.1.5 Estimating Effort and Duration from Lines of Code

8.1.6 Assessments for Agile Projects: Story Points and Velocity

8.2 Scheduling

8.3 The Software Project Management Plan

8.4 Case Study: Encounter Project Management Plan

8.5 Case Study: Project Management in Eclipse

8.6 Case Study: Project Management for Open Office

8.7 Case Study: Student Team Guidance

8.8 Summary

8.9 Exercises

Bibliography

Chapter 9: Quality and Metrics in Project Management

9.1 Cultivating and Planning Internal Quality

9.2 Project Metrics

9.2.1 Identification

9.2.2 Planning

9.2.3 Monitor and Review

9.3 Using Metrics for Improvement

9.3.1 Improvement within a Project

9.3.2 Improvement across Projects

9.4 Software Verification and Validation Plan

9.5 Case Study: Software Verification and Validation Plan for Encounter

9.6 Summary

9.7 Exercises

Bibliography

PART IV: Requirement Analysis

Chapter 10: Principles of Requirements Analysis

10.1 The Value of Requirements Analysis

10.2 Sources of Requirements

10.3 High-Level vs. Detailed Requirements

10.4 Types of Requirements

10.4.1 Functional Requirements

10.5 Nonfunctional Requirements

10.5.1 Quality Attributes

10.5.2 Constraints

10.5.3 External Interface Requirements

10.5.4 User Interface Requirements: Principles

10.5.5 Error-Handling Requirements

10.6 Documenting Requirements

10.7 Traceability

10.8 Agile Methods and Requirements

10.9 Updating the Project to Reflect Requirements Analysis

10.10 Summary

10.11 Exercises

Bibliography

Chapter 11: Analyzing High-Level Requirements

11.1 Examples of Customer Wants

11.2 Stakeholder Vision

11.3 The Interview and Documentation Process

11.4 Writing an Overview

11.5 Describing Main Functions and Use Cases

11.6 Agile Methods for High-Level Requirements

11.7 Specifying User Interfaces: High Level

11.7.1 Step 1: Know Your User

11.7.2 Step 2: Understand the Business Function

11.7.3 GUI Transitions

11.8 Security Requirements

11.9 Using Diagrams for High-Level Requirement

11.9.1 Data Flow Diagrams

11.9.2 State Transition Diagrams

11.10 Case Study: High-Level Software Requirements Specification (SRS) for the Encounter Video Game

11.11 Case Study: High-Level Requirements for Eclipse

11.12 Eclipse Platform Subproject (First of Three)

11.13 Case Study: High-Level Requirements for OpenOffice

11.14 Summary

11.15 Exercises

Bibliography

Chapter 12: Analyzing Detailed Requirements

12.1 The Meaning of Detailed Requirements

12.2 Organizing Detailed Requirements

12.2.1 Organizing Detailed Requirements by Feature

12.2.2 Organizing Detailed Requirements by Use Case

12.2.3 Organizing Detailed Requirement by GUI

12.2.4 Organizing Detailed Requirements by State

12.2.5 Organizing Requirements by Class

12.2.6 Classification Methods: Advantages and Disadvantages

12.3 User Interfaces: Detailed Requirements

12.4 Detailed Security Requirements

12.5 Error Conditions

12.6 Traceability of Detailed Requirements

12.7 Using Detailed Requirements to Manage Projects

12.8 Prioritizing Requirements

12.9 Associating Requirements with Tests

12.10 Agile Methods for Detailed Requirements

12.11 Using Tools and the Web for Requirements Analysis

12.11.1 Simple Projects

12.11.2 IBM’s RequisitePro

12.12 The Effects on Projects of the Detailed Requirements Process

12.13 Student Project Guide: Requirements for the Encounter Case Study

12.14 Case Study: Detailed Requirements for the Encounter Video Game

12.15 Summary

12.16 Exercises

Bibliography

Chapter 13: Quality and Metrics in Requirements Analysis

13.1 Quality of Requirements for Agile Projects

13.2 Accessibility of Requirements

13.3 Comprehensiveness of Requirements

13.4 Understandability of Requirements

13.5 Unambiguity of Requirements

13.6 Consistency of Requirements

13.7 Prioritization of Requirements

13.8 Security and High-Level Requirements

13.9 Self-Completeness of Requirements

13.10 Testability of Requirements

13.11 Traceability of Requirements

13.12 Metrics for Requirements Analysis

13.13 Inspecting Detailed Requirements

13.14 Summary

13.15 Exercises

Chapter 14: Formal and Emerging Methods in Requirements Analysis: An Introduction (Online Chapter)

PART V: Software Design

Chapter 15: Principles of Software Design

15.1 The Goals of Software Design

15.2 Integrating Design Models

15.2.1 Use Case Model

15.2.2 Class Models

15.2.3 Data Flow Models

15.2.4 State Models

15.3 Frameworks

15.4 IEEE Standards for Expressing Designs

15.5 Summary

15.6 Exercises

Chapter 16: The Unified Modeling Language

16.1 Classes in UML

16.2 Class Relationships in UML

16.2.1 Packages

16.2.2 Associations

16.3 Multiplicity

16.4 Inheritance

16.4.1 Aggregation

16.4.2 Composition

16.4.3 Dependency

16.4.4 Class Diagrams

16.4.5 Object Diagrams

16.5 Sequence Diagrams

16.6 State Diagrams

16.6.1 States and Substates

16.6.2 Events

16.6.3 Transitions

16.6.4 OnlineShopper State Diagram Example

16.6.5 The Relationship between States and GUls

16.7 Activity Diagrams

16.8 Data Flow Models

16.9 A Design Example with UML

16.10 Summary

16.11 Exercises

Bibliography

Chaper 17: Software Design Patterns

17.1 Examples of a Recurring Design Purpose

17.1.1 A Simple Example

17.1.2 A More Complex Example

17.2 An Introduction to Design Patterns

17.2.1 Example Application: Without Applying Design Patterns

17.2.2 Example Application: Applying a Design Pattern

17.3 Summary of Design Patterns by Type: Creational, Structural, and Behavioral

17.3.1 Creational Design Patterns

17.3.2 Structural Design Patterns

17.3.3 Behavioral Design Patterns

17.4 Characteristics of Design Patterns: Viewpoints, Roles, and Levels

17.4.1 Two Viewpoints for Describing a Pattern: Static and Dynamic

17.4.2 Two Layers of a Pattern: Abstract and Concrete

17.4.3 Three Roles Involved in Pattern Usage: Pattern Application, Client, and Setup

17.5 Selected Creational Design Patterns

17.5.1 Singleton

17.5.2 Abstract Factory

17.6 Selected Structural Design Patterns

17.6.1 Facade: Interfacing with a Collection of Classes

17.6.2 Adapter: Interfacing in a Flexible Manner

17.7 Selected Behavioral Design Patterns

17.7.1 Interpreter: Parsing Expressions

17.7.2 Observer

17.7.3 State

17.8 Design Pattern Forms: Delegation and Recursion

17.8.1 The Delegation Design Pattern Form

17.8.2 The Recursion Design Pattern Form

17.9 Summary

17.10 Exercises

Bibliography

Chapter 18: Software Architecture

18.1 A Categorization of Architectures

18.2 Software Architecture Alternatives and Their Class Models

18.2.1 Data Flow Architectures

18.2.2 Independent Components

18.2.3 Virtual Machines

18.2.4 Repository Architectures

18.2.5 Layered Architectures

18.2.6 Service-Oriented Architectures

18.2.7 Using Multiple Architectures within an Application

18.3 Trading Off Architecture Alternatives

18.4 Tools for Architectures

18.5 IEEE Standards for Expressing Designs

18.6 Effects of Architecture Selection on the Project Plan

18.7 Case Study: Preparing to Design Encounter (Student Project Guide continued)

18.8 Case Study: Software Design Document for the Role-Playing Video Game Framework

18.9 Case Study: Software Design Document for Encounter (Uses the Framework)

18.10 Case Study: Architecture of Eclipse

18.11 Case Study: OpenOffice Architecture

18.12 Summary

18.13 Exercises

Bibliography

Chapter 19: Detailed Design

19.1 Relating Use Cases, Architecture, and Detailed Design

19.2 A Typical Road Map for the “Detailed Design” Process

19.3 Object-Oriented Design Principles

19.4 Designing against Interfaces

19.5 Specifying Classes, Functions, and Algorithms

19.5.1 Preconditions, Postconditions, and Invariants

19.5.2 Expressing Algorithms with Activity Diagrams and Pseudocode

19.6 Reusing Components

19.7 Sequence and Data Flow Diagrams for Detailed Design

19.7.1 Detailed Sequence Diagrams

19.7.2 Detailed Data Flow Diagrams

19.8 Detailed Design and Agile Processes

19.9 Design in the Unified Development Process

19.10 IEEE Standard 890 for Detailed Design

19.11 Updating a Project with Detailed Design

19.12 Case Study: Detailed Design of Encounter

19.13 Case Study: Detailed Design of Eclipse

19.14 Summary

19.15 Exercises

Bibliography

Chapter 20: Design Quality and Metrics

20.1 Degree of Understandability, Cohesion, and Coupling

20.2 Degree of Sufficiency as a Quality Goal

20.3 Degree of Robustness as a Quality Goal

20.4 Degree of Flexibility as a Design Quality Goal

20.5 Degree of Reusability as a Design Quality Goal

20.6 Degree of Time Efficiency as a Design Quality Measure

20.7 Degree of Space Efficiency as a Design Quality Measure

20.8 Degree of Reliability as a Design Quality Measure

20.9 Degree of Security as a Design Quality Measure

20.10 Assessing Quality in Architecture Selection

20.10.1 Metrics for Architecture Quality

20.10.2 Choosing an Architecture among Alternatives

20.10.3 Verifying Architectures

20.11 Assessing the Quality of Detailed Designs

20.11.1 Techniques for Assessing the Quality of Detailed Designs

20.11.2 Metrics for Detailed Design

20.11.3 Inspection of Detailed Designs

20.12 Summary

20.13 Exercises

Bibliography

Chapter 21: Advanced and Emerging Methods in Software Design (Online Chapter)

PART VI: Implementation

Chapter 22: Principles of Implementation

22.1 Agile and Non-Agile Approaches to Implementation

22.2 Choosing a Programming Language

22.3 Identifying Classes

22.4 Defining Methods

22.5 Implementation Practices

22.5.1 Use Expressive Naming

22.5.2 Global Variables

22.5.3 Function Parameters

22.5.4 Explicit Numbers

22.5.5 Initialization and Declaration

22.5.6 Loops

22.6 Defensive Programming

22.6.1 Error Handling

22.6.2 Exception Handling

22.6.3 Buffer Overflow Prevention

22.6.4 “Enforce Intentions”

22.7 Coding Standards

22.7.1 Naming Conventions

22.7.2 Other Conventions

22.8 Comments

22.8.1 Documenting Attributes

22.9 Tools and Environments for Programming

22.10 Case Study: Encounter Implementation

22.11 Case Study: Eclipse

22.12 Case Study: OpenOffice

22.13 Student Team Guidance for Implementation

22.14 Summary

22.15 Code Listings Referred to in this Chapter

22.15.1 Code Listing for Video Rental Example

22.15.2 Code Listing for Encounter Character

22.16 Exercises

Bibliography

Chapter 23: Quality and Metrics in Implementation

23.1 Quality of Implementation

23.1.1 The Sufficiency of an Implementation

23.1.2 The Robustness of an Implementation

23.1.3 The Flexibility of an Implementation

23.1.4 The Reusability of an Implementation

23.1.5 The Efficiency of an Implementation

23.1.6 The Reliability of an Implementation

23.1.7 The Scalability of an Implementation

23.1.8 The Degree of Security of an Implementation

23.2 Code Inspections and Related Quality Procedures

23.2.1 Code Walkthroughs and Code Reviews

23.2.2 Pair Programming

23.3 Summary

23.4 Exercises

Chapter 24: Refactoring

24.1 Big Refactorings

24.2 Composing Methods

24.3 Moving Features between Objects

24.4 Organizing Data

24.5 Generalization

24.6 Introducing Modules

24.7 Refactoring in Projects

24.7.1 Refactoring in the Agile Project Life Cycle

24.7.2 Refactoring and Design Patterns

24.8 Summary

24.9 Exercises

Bibliography

PART VII: Testing and Maintenance

Chapter 25: Introduction to Software Testing

25.1 Testing Early and Often; and the Agile Connection

25.2 Retesting: Regression Testing

25.3 Black Box and White Box Testing

25.4 Unit Testing vs. Post-Unit Testing

25.5 Testing Object-Oriented Implementations

25.6 Documenting Tests

25.7 Test Planning

25.7.1 Organize “Unit” vs. Non-Unit Tests

25.7.2 Determine the Extent of Testing

25.7.3 Decide How Tests Will Be Documented

25.7.4 Decide How and Where to Get Test Input

25.7.5 Decide Who Will Be Involved in Testing

25.7.6 Estimate the Resources Required

25.7.7 Arrange to Track Metrics

25.8 Testing Test Suites by Fault Injection

25.9 Summary

25.10 Exercises

Chapter 26: Unit Testing

26.1 The Sources of Units for Unit Testing

26.2 Unit Test Methods

26.2.1 Statement Coverage

26.2.2 Branch Coverage

26.2.3 Path Coverage

26.2.4 Equivalence Partitioning

26.2.5 Boundary Value Analysis

26.3 Testing Methods

26.3.1 Checklist for Testing Methods

26.3.2 Organizing Test Cases

26.3.3 Stubs

26.3.4 Example of a Method-Level Unit Test

26.4 Test-Driven Development

26.4.1 Using JUnit for Unit Testing

26.5 Case Study: Encounter Video Game

26.5.1 Code Listing for EncounterCharacter Class

26.5.2 Unit Tests for the EncounterCharacter Class

26.6 Summary

26.7 Exercises

Bibliography

Chapter 27: Module and Integration Testing

27.1 Stubs and Drivers

27.2 Testing a Class

27.2.1 Example of a Class Test

27.2.2 Attribute-Oriented Tests

27.2.3 Testing Class Invariants

27.2.4 State-Based Tests

27.3 Integration

27.3.1 Big Bang Integration

27.3.2 Incremental Integration

27.3.3 Bottom-Up Integration

27.3.4 Top-Down Integration

27.3.5 Sandwich Integration

27.3.6 Continuous Integration

27.4 Daily Builds

27.5 Interface Testing

27.6 Module Integration

27.7 Case Study: Class Test for Encounter

27.8 Case Study: Encounter Integration Plan

27.9 Summary

27.10 Exercises

Bibliography

Chapter 28: Testing at the System Level

28.1 Functional Testing

28.2 Nonfunctional Testing

28.2.1 Performance Testing

28.2.2 Load/Stress Event Testing

28.2.3 Reliability and Availability Testing

28.2.4 Recoverability Testing

28.2.5 Usability Testing

28.2.6 Security Testing

28.2.7 Compatibility Testing

28.2.8 Installation and Installability Testing

28.2.9 Serviceability Testing

28.3 Testing with Lightweight Requirements

28.3.1 Testing in the Absence of Requirements

28.3.2 Models for Software Testing

28.3.3 Constructing Directed Graphs for Black Box Testing

28.3.4 Using Directed Graphs in Testing

28.3.5 Testing for Agile Processes

28.3.6 Qualities of a Good Tester

28.4 Testing Shortly Before Release

28.4.1 Soak Testing

28.4.2 Acceptance Testing

28.4.3 Alpha and Beta Releases

28.5 Case Study: Encounter Software Test Documentation

28.6 Case Study: Eclipse

28.7 Case Study: OpenOffice

28.7.1 Open Contribution to Quality Assurance

28.7.2 Smoke Tests

28.7.3 OpenOffice QA Priorities

28.7.4 Automated Product Source Code QA

28.7.5 Automated GUI Testing

28.8 Summary

28.9 Exercises

Bibliography

Chapter 29: Software Maintenance

29.1 Types of Software Maintenance

29.1.1 Maintenance Requests

29.1.2 Corrective Maintenance

29.1.3 Adaptive Maintenance

29.1.4 Perfective Maintenance

29.1.5 Preventive Maintenance

29.2 Issues of Software Maintenance

29.2.1 Management Challenges

29.2.2 Process Challenges

29.2.3 Technical Issues

29.3 Maintenance Process

29.3.1 Root-Cause Analysis

29.3.2 Patch Releases

29.3.3 Software Trouble Reports, Maintenance Requests, and Correction Reports

29.4 IEEE Maintenance Standards

29.4.1 Maintenance Problem Identification

29.4.2 Maintenance Problem Analysis

29.4.3 Designing for a Maintenance Request

29.4.4 Implementing a Maintenance Request

29.5 Software Evolution

29.5.1 Reverse Engineering

29.5.2 Reengineering

29.6 Maintenance Metrics

29.7 Case Study

29.8 Summary

29.9 Exercises