Machine generated contents note: ch. 1 The Nature Of Software -- 1.1.The Nature of Software -- 1.1.1.Defining Software -- 1.1.2.Software Application Domains -- 1.1.3.Legacy Software -- 1.2.The Changing Nature of Software -- 1.2.1.WebApps -- 1.2.2.Mobile Applications -- 1.2.3.Cloud Computing -- 1.2.4.Product Line Software -- 1.3.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 2 Software Engineering -- 2.1.Defining the Discipline -- 2.2.The Software Process -- 2.2.1.The Process Framework -- 2.2.2.Umbrella Activities -- 2.2.3.Process Adaptation -- 2.3.Software Engineering Practice -- 2.3.1.The Essence of Practice -- 2.3.2.General Principles -- 2.4.Software Development Myths -- 2.5.How It All Starts -- 2.6.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 3 Software Process Structure -- 3.1.A Generic Process Model -- 3.2.Defining a Framework Activity -- 3.3.Identifying a Task Set -- 3.4.Process Patterns -- 3.5.Process Assessment and Improvement -- 3.6.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 4 Process Models -- 4.1.Prescriptive Process Models -- 4.1.1.The Waterfall Model -- 4.1.2.Incremental Process Models -- 4.1.3.Evolutionary Process Models -- 4.1.4.Concurrent Models -- 4.1.5.A Final Word on Evolutionary Processes -- 4.2.Specialized Process Models -- 4.2.1.Component-Based Development -- 4.2.2.The Formal Methods Model -- 4.2.3.Aspect-Oriented Software Development -- 4.3.The Unified Process -- 4.3.1.A Bripf History -- 4.3.2.Phases of the Unified Process -- 4.4.Personal and Team Process Models -- 4.4.1.Personal Software Process -- 4.4.2.Team Software Process -- 4.5.Process Technology -- 4.6.Product and Process -- 4.7.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 5 Agile Development -- 5.1.What Is Agility? -- 5.2.Agility and the Cost of Change -- 5.3.What Is an Agile Process? -- 5.3.1.Agility Principles -- 5.3.2.The Politics of Agile Development -- 5.4.Extreme Programming -- 5.4.1.The XP Process -- 5.4.2.Industrial XP -- 5.5.Other Agile Process Models -- 5.5.1.Scrum -- 5.5.2.Dynamic Systems Development Method -- 5.5.3.Agile Modeling -- 5.5.4.Agile Unified Process -- 5.6.A Tool Set for the Agile Process -- 5.7.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 6 Human Aspects Of Software Engineering -- 6.1.Characteristics of a Software Engineer -- 6.2.The Psychology of Software Engineering -- 6.3.The Software Team -- 6.4.Team Structures -- 6.5.Agile Teams -- 6.5.1.The Generic Agile Team -- 6.5.2.The XP Team -- 6.6.The Impact of Social Media -- 6.7.Software Engineering Using the Cloud -- 6.8.Collaboration Tools -- 6.9.Global Teams -- 6.10.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 7 Principles That Guide Practice -- 7.1.Software Engineering Knowledge -- 7.2.Core Principles -- 7.2.1.Principles That Guide Process -- 7.2.2.Principles That Guide Practice -- 7.3.Principles That Guide Each Framework Activity -- 7.3.1.Communication Principles -- 7.3.2.Planning Principles -- 7.3.3.Modeling Principles -- 7.3.4.Construction Principles -- 7.3.5.Deployment Principles -- 7.4.Work Practices -- 7.5.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 8 Understanding Requirements -- 8.1.Requirements Engineering -- 8.2.Establishing the Groundwork -- 8.2.1.Identifying Stakeholders -- 8.2.2.Recognizing Multiple Viewpoints -- 8.2.3.Working toward Collaboration -- 8.2.4.Asking the First Questions -- 8.2.5.Nonfunctional Requirements -- 8.2.6.Traceability -- 8.3.Eliciting Requirements -- 8.3.1.Collaborative Requirements Gathering -- 8.3.2.Quality Function Deployment -- 8.3.3.Usage Scenarios -- 8.3.4.Elicitation Work Products -- 8.3.5.Agile Requirements Elicitation -- 8.3.6.Service-Oriented Methods -- 8.4.Developing Use Cases -- 8.5.Building the Analysis Model -- 8.5.1.Elements of the Analysis Model -- 8.5.2.Analysis Patterns -- 8.5.3.Agile Requirements Engineering -- 8.5.4.Requirements for Self-Adaptive Systems -- 8.6.Negotiating Requirements -- 8.7.Requirements Monitoring -- 8.8.Validating Requirements -- 8.9.Avoiding Common Mistakes -- 8.10.Summary -- Problems And Points To Ponder -- Further Readings And Other Information Sources -- ch. 9 Requirements Modeling: Scenario-Based Methods -- 9.1.Requirements Analysis -- 9.1.1.Overall Objectives and Philosophy -- 9.1.2.Analysis Rules of Thumb -- 9.1.3.Domain Analysis -- 9.1.4.Requirements Modeling Approaches -- 9.2.Scenario-Based Modeling -- 9.2.1.Creating a Preliminary Use Case -- 9.2.2.Refining a Preliminary Use Case -- 9.2.3.Writing a Formal Use Case -- 9.3.UML Models That Supplement the Use Case -- 9.3.1.Developing an Activity Diagram -- 9.3.2.Swimlane Diagrams -- 9.4.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 10 Requirements Modeling: Class-Based Methods -- 10.1.Identifying Analysis Classes -- 10.2.Specifying Attributes -- 10.3.Defining Operations -- 10.4.Class-Responsibility-Collaborator Modeling -- 10.5.Associations and Dependencies -- 10.6.Analysis Packages -- 10.7.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 11 Requirements Modeling: Behavior, Patterns, And Web/Mobile Apps -- 11.1.Creating a Behavioral Model -- 11.2.Identifying Events with the Use Case -- 11.3.State Representations -- 11.4.Patterns for Requirements Modeling -- 11.4.1.Discovering Analysis Patterns -- 11.4.2.A Requirements Pattern Example: Actuator-Sensor -- 11.5.Requirements Modeling for Web and Mobile Apps -- 11.5.1.How Much Analysis Is Enough? -- 11.5.2.Requirements Modeling Input -- 11.5.3.Requirements Modeling Output -- 11.5.4.Content Model -- 11.5.5.Interaction Model for Web and Mobile Apps -- 11.5.6.Functional Model -- 11.5.7.Configuration Models for WebApps -- 11.5.8.Navigation Modeling -- 11.6.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 12 Design Concepts -- 12.1.Design within the Context of Software Engineering -- 12.2.The Design Process -- 12.2.1.Software Quality Guidelines and Attributes -- 12.2.2.The Evolution of Software Design -- 12.3.Design Concepts -- 12.3.1.Abstraction -- 12.3.2.Architecture -- 12.3.3.Patterns -- 12.3.4.Separation of Concerns -- 12.3.5.Modularity -- 12.3.6.Information Hiding -- 12.3.7.Functional Independence -- 12.3.8.Refinement -- 12.3.9.Aspects -- 12.3.10.Refactoring -- 12.3.11.Object-Oriented Design Concepts -- 12.3.12.Design Classes -- 12.3.13.Dependency Inversion -- 12.3.14.Design for Test -- 12.4.The Design Model -- 12.4.1.Data Design Elements -- 12.4.2.Architectural Design Elements -- 12.4.3.Interface Design Elements -- 12.4.4.Component-Level Design Elements -- 12.4.5.Deployment-Level Design Elements -- 12.5.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 13 Architectural Design -- 13.1.Software Architecture -- 13.1.1.What Is Architecture? -- 13.1.2.Why Is Architecture Important? -- 13.1.3.Architectural Descriptions -- 13.1.4.Architectural Decisions -- 13.2.Architectural Genres -- 13.3.Architectural Styles -- 13.3.1.A Brief Taxonomy of Architectural Styles -- 13.3.2.Architectural Patterns -- 13.3.3.Organization and Refinement -- 13.4.Architectural Considerations -- 13.5.Architectural Decisions -- 13.6.Architectural Design -- 13.6.1.Representing the System in Context -- 13.6.2.Defining Archetypes -- 13.6.3.Refining the Architecture into Components -- 13.6.4.Describing Instantiations of the System -- 13.6.5.Architectural Design for Web Apps -- 13.6.6.Architectural Design for Mobile Apps -- 13.7.Assessing Alternative Architectural Designs -- 13.7.1.Architectural Description Languages -- 13.7.2.Architectural Reviews -- 13.8.lessons Learned -- 13.9.Pattern-based Architecture Review -- 13.10.Architecture Conformance Checking -- 13.11.Agility and Architecture -- 13.12.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch.;Note continued: 16.1.1.Kinds of Patterns -- 16.1.2.Frameworks -- 16.1.3.Describing a Pattern -- 16.1.4.Pattern Languages and Repositories -- 16.2.Pattern-Based Software Design -- 16.2.1.Pattern-Based Design in Context -- 16.2.2.Thinking in Patterns -- 16.2.3.Design Tasks -- 16.2.4.Building a Pattern-Organizing Table -- 16.2.5.Common Design Mistakes -- 16.3.Architectural Patterns -- 16.4.Component-Level Design Patterns -- 16.5.User Interface Design Patterns -- 16.6.WebApp Design Patterns -- 16.6.1.Design Focus -- 16.6.2.Design Granularity -- 16.7.Patterns for Mobile Apps -- 16.8.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 17 WebApp Design -- 17.1.WebApp Design Quality -- 17.2.Design Goals -- 17.3.A Design Pyramid for WebApps -- 17.4.WebApp Interface Design -- 17.5.Aesthetic Design -- 17.5.1.Layout Issues -- 17.5.2.Graphic Design Issues -- 17.6.Content Design -- 17.6.1.Content Objects -- 17.6.2.Content Design Issues -- 17.7.Architecture Design -- 17.7.1.Content Architecture -- 17.7.2.WebApp Architecture -- 17.8.Navigation Design -- 17.8.1.Navigation Semantics -- 17.8.2.Navigation Syntax -- 17.9.Component-Level Design -- 17.10.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 18 MobileApp Design -- 18.1.The Challenges -- 18.1.1.Development Considerations -- 18.1.2.Technical Considerations -- 18.2.Developing MobileApps -- 18.2.1.MobileApp Quality -- 18.2.2.User Interface Design -- 18.2.3.Context-Aware Apps -- 18.2.4.Lessons Learned -- 18.3.MobileApp Design-Best Practices -- 18.4.Mobility Environments -- 18.5.The Cloud -- 18.6.The Applicability of Conventional Software Engineering -- 18.7.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 19 Quality Concepts -- 19.1.What Is Quality? -- 19.2.Software Quality -- 19.2.1.Garvin's Quality Dimensions -- 19.2.2.McCall's Quality Factors -- 19.2.3.ISO 9126 Quality Factors -- 19.2.4.Targeted Quality Factors -- 19.2.5.The Transition to a Quantitative View -- 19.3.The Software Quality Dilemma -- 19.3.1."Good Enough" Software -- 19.3.2.The Cost of Quality -- 19.3.3.Risks -- 19.3.4.Negligence and Liability -- 19.3.5.Quality and Security -- 19.3.6.The Impact of Management Actions -- 19.4.Achieving Software Quality -- 19.4.1.Software Engineering Methods -- 19.4.2.Project Management Techniques -- 19.4.3.Quality Control -- 19.4.4.Quality Assurance -- 19.5.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 20 Review Techniques -- 20.1.Cost Impact of Software Defects -- 20.2.Defect Amplification and Removal -- 20.3.Review Metrics and Their Use -- 20.3.1.Analyzing Metrics -- 20.3.2.Cost-Effectiveness of Reviews -- 20.4.Reviews: A Formality Spectrum -- 20.5.Informal Reviews -- 20.6.Formal Technical Reviews -- 20.6.1.The Review Meeting -- 20.6.2.Review Reporting and Record Keeping -- 20.6.3.Review Guidelines -- 20.6.4.Sample-Driven Reviews -- 20.7.Post-Mortem Evaluations -- 20.8.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 21 Software Quality Assurance -- 21.1.Background Issues -- 21.2.Elements of Software Quality Assurance -- 21.3.SQA Processes and Product Characteristics -- 21.4.SQA Tasks, Goals, and Metrics -- 21.4.1.SQA Tasks -- 21.4.2.Goals, Attributes, and Metrics -- 21.5.Formal Approaches to SQA -- 21.6.Statistical Software Quality Assurance -- 21.6.1.A Generic Example -- 21.6.2.Six Sigma for Software Engineering -- 21.7.Software Reliability -- 21.7.1.Measures of Reliability and Availability -- 21.7.2.Software Safety -- 21.8.The ISO 9000 Quality Standards -- 21.9.The SQA Plan -- 21.10.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 22 Software Testing Strategies -- 22.1.A Strategic Approach to Software Testing -- 22.1.1.Verification and Validation -- 22.1.2.Organizing for Software Testing -- 22.1.3.Software Testing Strategy-The Big Picture -- 22.1.4.Criteria for Completion of Testing -- 22.2.Strategic Issues -- 22.3.Test Strategies for Conventional Software -- 22.3.1.Unit Testing -- 22.3.2.Integration Testing -- 22.4.Test Strategies for Object-Oriented Software -- 22.4.1.Unit Testing in the OO Context -- 22.4.2.Integration Testing in the OO Context -- 22.5.Test Strategies for WebApps -- 22.6.Test Strategies for MobileApps -- 22.7.Validation Testing -- 22.7.1.Validation-Test Criteria -- 22.7.2.Configuration Review -- 22.7.3.Alpha and Beta Testing -- 22.8.System Testing -- 22.8.1.Recovery Testing -- 22.8.2.Security Testing -- 22.8.3.Stress Testing -- 22.8.4.Performance Testing -- 22.8.5.Deployment Testing -- 22.9.The Art of Debugging -- 22.9.1.The Debugging Process -- 22.9.2.Psychological Considerations -- 22.9.3.Debugging Strategies -- 22.9.4.Correcting the Error -- 22.10.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 23 Testing Conventional Applications -- 23.1.Software Testing Fundamentals -- 23.2.Internal and External Views of Testing -- 23.3.White-Box Testing -- 23.4.Basis Path Testing -- 23.4.1.Flow Graph Notation -- 23.4.2.Independent Program Paths -- 23.4.3.Deriving Test Cases -- 23.4.4.Graph Matrices -- 23.5.Control Structure Testing -- 23.6.Black-Box Testing -- 23.6.1.Graph-Based Testing Methods -- 23.6.2.Equivalence Partitioning -- 23.6.3.Boundary Value Analysis -- 23.6.4.Orthogonal Array Testing -- 23.7.Model-Based Testing -- 23.8.Testing Documentation and Help Facilities -- 23.9.Testing for Real-Time Systems -- 23.10.Patterns for Software Testing -- 23.11.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 24 Testing Object-Oriented Applications -- 24.1.Broadening the View of Testing -- 24.2.Testing OOA and OOD Models -- 24.2.1.Correctness of OOA and COD Models -- 24.2.2.Consistency of Object-Oriented Models -- 24.3.Object-Oriented Testing Strategies -- 24.3.1.Unit Testing in the OO Context -- 24.3.2.Integration Testing in the OO Context -- 24.3.3.Validation Testing in an OO Context -- 24.4.Object-Oriented Testing Methods -- 24.4.1.The Test-Case Design Implications of OO Concepts -- 24.4.2.Applicability of Conventional Test-Case Design Methods -- 24.4.3.Fault-Based Testing -- 24.4.4.Scenario-Based Test Design -- 24.5.Testing Methods Applicable at the Class Level -- 24.5.1.Random Testing for OO Classes -- 24.5.2.Partition Testing at the Class Level -- 24.6.Interclass Test-Case Design -- 24.6.1.Multiple Class Testing -- 24.6.2.Tests Derived from Behavior Models -- 24.7.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 25 Testing Web Applications -- 25.1.Testing Concepts for WebApps -- 25.1.1.Dimensions of Quality -- 25.1.2.Errors within a WebApp Environment -- 25.1.3.Testing Strategy -- 25.1.4.Test Planning -- 25.2.The Testing Process-An Overview -- 25.3.Content Testing -- 25.3.1.Content Testing Objectives -- 25.3.2.Database Testing -- 25.4.User Interface Testing -- 25.4.1.Interface Testing Strategy -- 25.4.2.Testing Interface Mechanisms -- 25.4.3.Testing Interface Semantics -- 25.4.4.Usability Tests -- 25.4.5.Compatibility Tests -- 25.5.Component-Level Testing -- 25.6.Navigation Testing -- 25.6.1.Testing Navigation Syntax -- 25.6.2.Testing Navigation Semantics -- 25.7.Configuration Testing -- 25.7.1.Server-Side Issues -- 25.7.2.Client-Side Issues -- 25.8.Security Testing -- 25.9.Performance Testing -- 25.9.1.Performance Testing Objectives -- 25.9.2.Load Testing -- 25.9.3.Stress Testing -- 25.10.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 26 Testing Mobileapps -- 26.1.Testing Guidelines -- 26.2.The Testing Strategies -- 26.2.1.Are Conventional Approaches Applicable? -- 26.2.2.The Need for Automation -- 26.2.3.Building a Test Matrix -- 26.2.4.Stress Testing -- 26.2.5.Testing in a Production Environment -- 26.3.Considering the Spectrum of User Interaction -- 26.3.1.Gesture Testing -- 26.3.2.Voice Input and Recognition -- 26.3.3.Virtual Key Board Input -- 26.3.4.Alerts and Extraordinary Conditions -- 26.4.Test Across Borders -- 26.5.Real-Time Testing Issues -- 26.6.Testing Tools and Environments -- 26.7.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch.;14 Component-Level Design -- 14.1.What Is a Component? -- 14.1.1.An Object-Oriented View -- 14.1.2.The Traditional View -- 14.1.3.A Process-Related View -- 14.2.Designing Class-Based Components -- 14.2.1.Basic Design Principles -- 14.2.2.Component-Level Design Guidelines -- 14.2.3.Cohesion -- 14.2.4.Coupling -- 14.3.Conducting Component-Level Design -- 14.4.Component-Level Design for WebApps -- 14.4.1.Content Design at the Component Level -- 14.4.2.Functional Design at the Component Level -- 14.5.Component-Level Design for Mobile Apps -- 14.6.Designing Traditional Components -- 14.7.Component-Based Development -- 14.7.1.Domain Engineering -- 14.7.2.Component Qualification, Adaptation, and Composition -- 14.7.3.Architectural Mismatch -- 14.7.4.Analysis and Design for Reuse -- 14.7.5.Classifying and Retrieving Components -- 14.8.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 15 User Interface Design -- 15.1.The Golden Rules -- 15.1.1.Place the User in Control -- 15.1.2.Reduce the User's Memory Load -- 15.1.3.Make the Interface Consistent -- 15.2.User Interface Analysis and Design -- 15.2.1.Interface Analysis and Design Models -- 15.2.2.The Process -- 15.3.Interface Analysis -- 15.3.1.User Analysis -- 15.3.2.Task Analysis and Modeling -- 15.3.3.Analysis of Display Content -- 15.3.4.Analysis of the Work Environment -- 15.4.Interface Design Steps -- 15.4.1.Applying Interface Design Steps -- 15.4.2.User Interface Design Patterns -- 15.4.3.Design Issues -- 15.5.WebApp and Mobile Interface Design -- 15.5.1.Interface Design Principles and Guidelines -- 15.5.2.Interface Design Workflow for Web and Mobile Apps -- 15.6.Design Evaluation -- 15.7.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 16 Pattern-Based Design -- 16.1.Design Patterns;Note continued: 29.3.The SCM Process -- 29.3.1.Identification of Objects in the Software Configuration -- 29.3.2.Version Control -- 29.3.3.Change Control -- 29.3.4.Impact Management -- 29.3.5.Configuration Audit -- 29.3.6.Status Reporting -- 29.4.Configuration Management for Web and MobileApps -- 29.4.1.Dominant Issues -- 29.4.2.Configuration Objects -- 29.4.3.Content Management -- 29.4.4.Change Management -- 29.4.5.Version Control -- 29.4.6.Auditing and Reporting -- 29.5.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 30 Product Metrics -- 30.1.A Framework for Product Metrics -- 30.1.1.Measures, Metrics, and Indicators -- 30.1.2.The Challenge of Product Metrics -- 30.1.3.Measurement Principles -- 30.1.4.Goal-Oriented Software Measurement -- 30.1.5.The Attributes of Effective Software Metrics -- 30.2.Metrics for the Requirements Model -- 30.2.1.Function-Based Metrics -- 30.2.2.Metrics for Specification Quality -- 30.3.Metrics for the Design Model -- 30.3.1.Architectural Design Metrics -- 30.3.2.Metrics for Object-Oriented Design -- 30.3.3.Class-Oriented Metrics-The CK Metrics Suite -- 30.3.4.Class-Oriented Metrics-The MOOD Metrics Suite -- 30.3.5.OO Metrics Proposed by Lorenz and Kidd -- 30.3.6.Component-Level Design Metrics -- 30.3.7.Operation-Oriented Metrics -- 30.3.8.User Interface Design Metrics -- 30.4.Design Metrics for Web and Mobile Apps -- 30.5.Metrics for Source Code -- 30.6.Metrics for Testing -- 30.6.1.Halstead Metrics Applied to Testing -- 30.6.2.Metrics for Object-Oriented Testing -- 30.7.Metrics for Maintenance -- 30.8.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 31 Project Management Concepts -- 31.1.The Management Spectrum -- 31.1.1.The People -- 31.1.2.The Product -- 31.1.3.The Process -- 31.1.4.The Project -- 31.2.People -- 31.2.1.The Stakeholders -- 31.2.2.Team Leaders -- 31.2.3.The Software Team -- 31.2.4.Agile Teams -- 31.2.5.Coordination and Communication Issues -- 31.3.The Product -- 31.3.1.Software Scope -- 31.3.2.Problem Decomposition -- 31.4.The Process -- 31.4.1.Melding the Product and the Process -- 31.4.2.Process Decomposition -- 31.5.The Project -- 31.6.The W5HH Principle -- 31.7.Critical Practices -- 31.8.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 32 Process And Project Metrics -- 32.1.Metrics in the Process and Project Domains -- 32.1.1.Process Metrics and Software Process Improvement -- 32.1.2.Project Metrics -- 32.2.Software Measurement -- 32.2.1.Size-Oriented Metrics -- 32.2.2.Function-Oriented Metrics -- 32.2.3.Reconciling LOC and FP Metrics -- 32.2.4.Object-Oriented Metrics -- 32.2.5.Use Case-Oriented Metrics -- 32.2.6.WebApp Project Metrics -- 32.3.Metrics for Software Quality -- 32.3.1.Measuring Quality -- 32.3.2.Defect Removal Efficiency -- 32.4.Integrating Metrics within the Software Process -- 32.4.1.Arguments for Software Metrics -- 32.4.2.Establishing a Baseline -- 32.4.3.Metrics Collection, Computation, and Evaluation -- 32.5.Metrics for Small Organizations -- 32.6.Establishing a Software Metrics Program -- 32.7.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 33 Estimation For Software Projects -- 33.1.Observations on Estimation -- 33.2.The Project Planning Process -- 33.3.Software Scope and Feasibility -- 33.4.Resources -- 33.4.1.Human Resources -- 33.4.2.Reusable Software Resources -- 33.4.3.Environmental Resources -- 33.5.Software Project Estimation -- 33.6.Decomposition Techniques -- 33.6.1.Software Sizing -- 33.6.2.Problem-Based Estimation -- 33.6.3.An Example of LOC-Based Estimation -- 33.6.4.An Example of FP-Based Estimation -- 33.6.5.Process-Based Estimation -- 33.6.6.An Example of Process-Based Estimation -- 33.6.7.Estimation with Use Cases -- 33.6.8.An Example of Estimation Using Use Case Points -- 33.6.9.Reconciling Estimates -- 33.7.Empirical Estimation Models -- 33.7.1.The Structure of Estimation Models -- 33.7.2.The COCOMO II Model -- 33.7.3.The Software Equation -- 33.8.Estimation for Object-Oriented Projects -- 33.9.Specialized Estimation Techniques -- 33.9.1.Estimation for Agile Development -- 33.9.2.Estimation for WebApp Projects -- 33.10.The Make/Buy Decision -- 33.10.1.Creating a Decision Tree -- 33.10.2.Outsourcing -- 33.11.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 34 Project Scheduling -- 34.1.Basic Concepts -- 34.2.Project Scheduling -- 34.2.1.Basic Principles -- 34.2.2.The Relationship between People and Effort -- 34.2.3.Effort Distribution -- 34.3.Defining a Task Set for the Software Project -- 34.3.1.A Task Set Example -- 34.3.2.Refinement of Major Tasks -- 34.4.Defining a Task Network -- 34.5.Scheduling -- 34.5.1.Time-Line Charts -- 34.5.2.Tracking the Schedule -- 34.5.3.Tracking Progress for an OO Project -- 34.5.4.Scheduling for WebApp and Mobile Projects -- 34.6.Earned Value Analysis -- 34.7.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 35 Risk Management -- 35.1.Reactive versus Proactive Risk Strategies -- 35.2.Software Risks -- 35.3.Risk Identification -- 35.3.1.Assessing Overall Project Risk -- 35.3.2.Risk Components and Drivers -- 35.4.Risk Projection -- 35.4.1.Developing a Risk Table -- 35.4.2.Assessing Risk Impact -- 35.5.Risk Refinement -- 35.6.Risk Mitigation, Monitoring, and Management -- 35.7.The RMMM Plan -- 35.8.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 36 Maintenance And Reengineering -- 36.1.Software Maintenance -- 36.2.Software Supportability -- 36.3.Reengineering -- 36.4.Business Process Reengineering -- 36.4.1.Business Processes -- 36.4.2.A BPR Model -- 36.5.Software Reengineering -- 36.5.1.A Software Reengineering Process Model -- 36.5.2.Software Reengineering Activities -- 36.6.Reverse Engineering -- 36.6.1.Reverse Engineering to Understand Data -- 36.6.2.Reverse Engineering to Understand Processing -- 36.6.3.Reverse Engineering User Interfaces -- 36.7.Restructuring -- 36.7.1.Code Restructuring -- 36.7.2.Data Restructuring -- 36.8.Forward Engineering -- 36.8.1.Forward Engineering for Client-Server Architectures -- 36.8.2.Forward Engineering for Object-Oriented Architectures -- 36.9.The Economics of Reengineering -- 36.10.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 37 Software Process Improvement -- 37.1.What Is SPI? -- 37.1.1.Approaches to SPI -- 37.1.2.Maturity Models -- 37.1.3.Is SPI for Everyone? -- 37.2.The SPI Process -- 37.2.1.Assessment and Gap Analysis -- 37.2.2.Education and Training -- 37.2.3.Selection and Justification -- 37.2.4.Installation/Migration -- 37.2.5.Evaluation -- 37.2.6.Risk Management for SPI -- 37.3.The CMMI -- 37.4.The People CMM -- 37.5.Other SPI Frameworks -- 37.6.SPI Return on Investment -- 37.7.SPI Trends -- 37.8.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 38 Emerging Trends In Software Engineering -- 38.1.Technology Evolution -- 38.2.Prospects for a True Engineering Discipline -- 38.3.Observing Software Engineering Trends -- 38.4.Identifying "Soft Trends" -- 38.4.1.Managing Complexity -- 38.4.2.Open-World Software -- 38.4.3.Emergent Requirements -- 38.4.4.The Talent Mix -- 38.4.5.Software Building Blocks -- 38.4.6.Changing Perceptions of "Value" -- 38.4.7.Open Source -- 38.5.Technology Directions -- 38.5.1.Process Trends -- 38.5.2.The Grand Challenge -- 38.5.3.Collaborative Development -- 38.5.4.Requirements Engineering -- 38.5.5.Model-Driven Software Development -- 38.5.6.Postmodern Design -- 38.5.7.Test-Driven Development -- 38.6.Tools-Related Trends -- 38.7.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 39 Concluding Comments -- 39.1.The Importance of Software-Revisited -- 39.2.People and the Way They Build Systems -- 39.3.New Modes for Representing Information -- 39.4.The Long View -- 39.5.The Software Engineer's Responsibility -- 39.6.A Final Comment from RSP.;27 Security Engineering -- 27.1.Analyzing Security Requirements -- 27.2.Security and Privacy in an Online World -- 27.2.1.Social Media -- 27.2.2.Mobile Applications -- 27.2.3.Cloud Computing -- 27.2.4.The Internet of Things -- 27.3.Security Engineering Analysis -- 27.3.1.Security Requirement Elicitation -- 27.3.2.Security Modeling -- 27.3.3.Measures Design -- 27.3.4.Correctness Checks -- 27.4.Security Assurance -- 27.4.1.The Security Assurance Process -- 27.4.2.Organization and Management -- 27.5.Security Risk Analysis -- 27.6.The Role of Conventional Software Engineering Activities -- 27.7.Verification of Trustworthy Systems -- 27.8.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 28 Formal Modeling And Verification -- 28.1.The Cleanroom Strategy -- 28.2.Functional Specification -- 28.2.1.Black-Box Specification -- 28.2.2.State-Box Specification -- 28.2.3.Clear-Box Specification -- 28.3.Cleanroom Design -- 28.3.1.Design Refinement -- 28.3.2.Design Verification -- 28.4.Cleanroom Testing -- 28.4.1.Statistical Use Testing -- 28.4.2.Certification -- 28.5.Rethinking Formal Methods -- 28.6.Formal Methods Concepts -- 28.7.Alternative Arguments -- 28.8.Summary -- Problems And Points To Ponder -- Further Readings And Information Sources -- ch. 29 Software Configuration Management -- 29.1.Software Configuration Management -- 29.1.1.An SCM Scenario -- 29.1.2.Elements of a Configuration Management System -- 29.1.3.Baselines -- 29.1.4.Software Configuration Items -- 29.1.5.Management of Dependencies and Changes -- 29.2.The SCM Repository -- 29.2.1.General Features and Content -- 29.2.2.SCM Features