Machine generated contents note: ch. 1 Software And Software Engineering -- 1.1.The Nature of Software -- 1.1.1.Defining Software -- 1.1.2.Software Application Domains -- 1.1.3.Legacy Software -- 1.2.Defining the Discipline -- 1.3.The Software Process -- 1.3.1.The. Process Framework -- 1.3.2.Umbrella Activities -- 1.3.3.Process Adaptation -- 1.4.Software Engineering Practice -- 1.4.1.The Essence of Practice -- 1.4.2.General Principles -- 1.5.How It All Starts -- 1.6.Summary -- ch. 2 Process Models -- 2.1.A Generic Process Model -- 2.2.Defining a Framework Activity -- 2.3.Identifying a Task Set -- 2.4.Process Assessment and Improvement -- 2.5.Prescriptive Process Models -- 2.5.1.The Waterfall Model -- 2.5.2.Prototyping Process Model -- 2.5.3.Evolutionary Process Model -- 2.5.4.Unified Process Model -- 2.6.Product and Process -- 2.7.Summary -- ch. 3 Agility And Process -- 3.1.What Is Agility? -- 3.2.Agility and the Cost of Change -- 3.3.What Is an Agile Process? --

Note continued: 3.3.1.Agility Principles -- 3.3.2.The Politics of Agile Development -- 3.4.Scrum -- 3.4.1.Scrum Teams and Artifacts -- 3.4.2.Sprint Planning Meeting -- 3.4.3.Daily Scrum Meeting -- 3.4.4.Sprint Review Meeting -- 3.4.5.Sprint Retrospective -- 3.5.Other Agile Frameworks -- 3.5.1.The XP Framework -- 3.5.2.Kanban -- 3.5.3.DevOps -- 3.6.Summary -- ch. 4 Recommended Process Model -- 4.1.Requirements Definition -- 4.2.Preliminary Architectural Design -- 4.3.Resource Estimation -- 4.4.First Prototype Construction -- 4.5.Prototype Evaluation -- 4.6.Go, No-Go Decision -- 4.7.Prototype Evolution -- 4.7.1.New Prototype Scope -- 4.7.2.Constructing New Prototypes -- 4.7.3.Testing New Prototypes -- 4.8.Prototype Release -- 4.9.Maintain Release Software -- 4.10.Summary -- ch. 5 Human Aspects Of Software Engineering -- 5.1.Characteristics of a Software Engineer -- 5.2.The Psychology of Software Engineering -- 5.3.The Software Team -- 5.4.Team Structures --

Note continued: 5.5.The Impact of Social Media -- 5.6.Global Teams -- 5.7.Summary -- ch. 6 Principles That Guide Practice -- 6.1.Core Principles -- 6.1.1.Principles That Guide Process -- 6.1.2.Principles That Guide Practice -- 6.2.Principles, That Guide Each Framework Activity -- 6.2.1.Communication Principles -- 6.2.2.Planning Principles -- 6.2.3.Modeling Principles -- 6.2.4.Construction Principles -- 6.2.5.Deployment Principles -- 6.3.Summary -- ch. 7 Understanding Requirements -- 7.1.Requirements Engineering -- 7.1.1.Inception -- 7.1.2.Elicitation -- 7.1.3.Elaboration -- 7.1.4.Negotiation -- 7.1.5.Specification -- 7.1.6.Validation -- 7.1.7.Requirements Management -- 7.2.Establishing the Groundwork -- 7.2.1.Identifying Stakeholders -- 7.2.2.Recognizing Multiple Viewpoints -- 7.2.3.Working Toward Collaboration -- 7.2.4.Asking the First Questions -- 7.2.5.Nonfunctional Requirements -- 7.2.6.Traceability -- 7.3.Requirements Gathering --

Note continued: 7.3.1.Collaborative Requirements Gathering -- 7.3.2.Usage Scenarios -- 7.3.3.Elicitation Work Products -- 7.4.Developing Use Cases -- 7.5.Building the Analysis Model -- 7.5.1.Elements of the Analysis Model -- 7.5.2.Analysis Patterns -- 7.6.Negotiating Requirements -- 7.7.Requirements Monitoring -- 7.8.Validating Requirements -- 7.9.Summary -- ch. 8 Requirements Modeling-a Recommended Approach -- 8.1.Requirements Analysis -- 8.1.1.Overall Objectives and Philosophy -- 8.1.2.Analysis Rules of Thumb -- 8.1.3.Requirements Modeling Principles -- 8.2.Scenario-Based Modeling -- 8.2.1.Actors and User Profiles -- 8.2.2.Creating Use Cases -- 8.2.3.Documenting Use Cases -- 8.3.Class-Based Modeling -- 8.3.1.Identifying Analysis Classes -- 8.3.2.Defining Attributes and Operations -- 8.3.3.UML Class Models -- 8.3.4.Class-Responsibility-Collaborator Modeling -- 8.4.Functional Modeling -- 8.4.1.A Procedural View -- 8.4.2.UML Sequence Diagrams -- 8.5.Behavioral Modeling --

Note continued: 8.5.1.Identifying Events with the Use Case -- 8.5.2.UML State Diagrams -- 8.5.3.UML Activity Diagrams -- 8.6.Summary -- ch. 9 Design Concepts -- 9.1.Design Within the Context of Software Engineering -- 9.2.The Design Process -- 9.2.1.Software Quality Guidelines and Attributes -- 9.2.2.The Evolution of Software Design -- 9.3.Design Concepts -- 9.3.1.Abstraction -- 9.3.2.Architecture -- 9.3.3.Patterns -- 9.3.4.Separation of Concerns -- 9.3.5.Modularity -- 9.3.6.Information Hiding -- 9.3.7.Functional Independence -- 9.3.8.Stepwise Refinement -- 9.3.9.Refactoring -- 9.3.10.Design Classes -- 9.4.The Design Model -- 9.4.1.Design Modeling Principles -- 9.4.2.Data Design Elements -- 9.4.3.Architectural Design Elements -- 9.4.4.Interface Design Elements -- 9.4.5.Component-Level Design Elements -- 9.4.6.Deployment-Level Design Elements -- 9.5.Summary -- ch. 10 Architectural Design-a Recommended Approach -- 10.1.Software Architecture --

Note continued: 10.1.1.What Is Architecture? -- 10.1.2.Why Is Architecture Important? -- 10.1.3.Architectural Descriptions -- 10.1.4.Architectural Decisions -- 10.2.Agility and Architecture -- 10.3.Architectural Styles -- 10.3.1.A Brief Taxonomy of Architectural Styles -- 10.3.2.Architectural Patterns -- 10.3.3.Organization and Refinement -- 10.4.Architectural Considerations -- 10.5.Architectural Decisions -- 10.6.Architectural Design -- 10.6.1.Representing the System in Context -- 10.6.2.Defining Archetypes -- 10.6.3.Refining the Architecture into Components -- 10.6.4.Describing Instantiations of the System -- 10.7.Assessing Alternative Architectural Designs -- 10.7.1.Architectural Reviews -- 10.7.2.Pattern-Based Architecture Review -- 10.7.3.Architecture Conformance Checking -- 10.8.Summary -- ch. 11 Component-Level Design -- 11.1.What Is a Component? -- 11.1.1.An Object-Oriented View -- 11.1.2.The Traditional View -- 11.1.3.A Process-Related View --

Note continued: 11.2.Designing Class-Based Components -- 11.2.1.Basic Design Principles -- 11.2.2.Component-Level Design Guidelines -- 11.2.3.Cohesion -- 11.2.4.Coupling -- 11.3.Conducting Component-Level Design -- 11.4.Specialized Component-Level Design -- 11.4.1.Component-Level Design for WebApps -- 11.4.2.Component-Level Design for Mobile Apps -- 11.4.3.Designing Traditional Components -- 11.4.4.Component-Based Development -- 11.5.Component Refactoring -- 11.6.Summary -- ch. 12 User Experience Design -- 12.1.User Experience Design Elements -- 12.1.1.Information Architecture -- 12.1.2.User Interaction Design -- 12.1.3.Usability Engineering -- 12.1.4.Visual Design -- 12.2.The Golden Rules -- 12.2.1.Place the User in Control -- 12.2.2.Reduce the User's Memory Load -- 12.2.3.Make the Interface Consistent -- 12.3.User Interface Analysis and Design -- 12.3.1.Interface Analysis and Design Models -- 12.3.2.The Process -- 12.4.User Experience Analysis --

Note continued: 12.4.1.User Research -- 12.4.2.User Modeling -- 12.4.3.Task Analysis -- 12.4.4.Work Environment Analysis -- 12.5.User Experience Design -- 12.6.User Interface Design -- 12.6.1.Applying Interface Design Steps -- 12.6.2.User Interface Design Patterns -- 12.7.Design Evaluation -- 12.7.1.Prototype Review -- 12.7.2.User Testing -- 12.8.Usability and Accessibility -- 12.8.1.Usability Guidelines -- 12.8.2.Accessibility Guidelines -- 12.9.Conventional Software UX and Mobility -- 12.10.Summary -- ch. 13 Design For Mobility -- 13.1.The Challenges -- 13.1.1.Development Considerations -- 13.1.2.Technical Considerations -- 13.2.Mobile Development Life Cycle -- 13.2.1.User Interface Design -- 13.2.2.Lessons Learned -- 13.3.Mobile Architectures -- 13.4.Context-Aware Apps -- 13.5.Web Design Pyramid -- 13.5.1.WebApp Interface Design -- 13.5.2.Aesthetic Design -- 13.5.3.Content Design -- 13.5.4.Architecture Design -- 13.5.5.Navigation Design --

Note continued: 13.6.Component-Level Design -- 13.7.Mobility and Design Quality -- 13.8.Mobility Design Best Practices -- 13.9.Summary -- ch. 14 Pattern-Based Design -- 14.1.Design Patterns -- 14.1.1.Kinds of Patterns -- 14.1.2.Frameworks -- 14.1.3.Describing a Pattern -- 14.1.4.Machine Learning and Pattern Discovery -- 14.2.Pattern-Based Software Design -- 14.2.1.Pattern-Based Design in Context -- 14.2.2.Thinking in Patterns -- 14.2.3.Design Tasks -- 14.2.4.Building a Pattern-Organizing Table -- 14.2.5.Common Design Mistakes 29$ -- 14.3.Architectural Patterns -- 14.4.Component-Level Design Patterns -- 14.5.Anti-Patterns -- 14.6.User Interface Design Patterns -- 14.7.Mobility Design Patterns -- 14.8.Summary -- ch. 15 Quality Concepts -- 15.1.What Is Quality? -- 15.2.Software Quality -- 15.2.1.Quality Factors -- 15.2.2.Qualitative Quality Assessment -- 15.2.3.Quantitative Quality Assessment -- 15.3.The Software Quality Dilemma -- 15.3.1."Good Enough" Software --

Note continued: 15.3.2.The Cost of Quality -- 15.3.3.Risks -- 15.3.4.Negligence and Liability -- 15.3.5.Quality and Security -- 15.3.6.The Impact of Management Actions -- 15.4.Achieving Software Quality -- 15.4.1.Software Engineering Methods -- 15.4.2.Project Management Techniques -- 15.4.3.Machine Learning and Defect Prediction -- 15.4.4.Quality Control -- 15.4.5.Quality Assurance -- 15.5.Summary -- ch. 16 Reviews-A Recommended Approach -- 16.1.Cost Impact of Software Defects -- 16.2.Defect Amplification and Removal -- 16.3.Review Metrics and Their Use -- 16.4.Criteria for Types of Reviews -- 16.5.Informal Reviews -- 16.6.Formal Technical Reviews -- 16.6.1.The Review Meeting -- 16.6.2.Review Reporting and Record Keeping -- 16.6.3.Review Guidelines -- 16.7.Postmortem Evaluations -- 16.8.Agile Reviews -- 16.9.Summary -- ch. 17 Software Quality Assurance -- 17.1.Background Issues -- 17.2.Elements of Software Quality Assurance --

Note continued: 17.3.SQA Processes and Product Characteristics -- 17.4.SQA Tasks, Goals, and Metrics -- 17.4.1.SQA Tasks -- 17.4.2.Goals, Attributes, and Metrics -- 17.5.Formal Approaches to SQA -- 17.6.Statistical Software Quality Assurance -- 17.6.1.A Generic Example -- 17.6.2.Six Sigma for Software Engineering -- 17.7.Software Reliability -- 17.7.1.Measures of Reliability and Availability -- 17.7.2.Use of Al to Model Reliability -- 17.7.3.Software Safety -- 17.8.The ISO 9000 Quality Standards -- 17.9.The SQA Plan -- 17.10.Summary -- ch. 18 Software Security Engineering -- 18.1.Why Software Security Information Is Important -- 18.2.Security Life-Cycle Models -- 18.3.Secure Development Life-Cycle Activities -- 18.4.Security Requirements Engineering -- 18.4.1.SQUARE -- 18.4.2.The SQUARE Process -- 18.5.Misuse and Abuse Cases and Attack Patterns -- 18.6.Security Risk Analysis -- 18.7.Threat Modeling, Prioritization, and Mitigation -- 18.8.Attack Surface --

Note continued: 18.9.Secure Coding -- 18.10.Measurement -- 18.11.Security Process Improvement and Maturity Models -- 18.12.Summary -- ch. 19 Software Testing-component Level -- 19.1.A Strategic Approach to Software Testing -- 19.1.1.Verification and Validation -- 19.1.2.Organizing for Software Testing -- 19.1.3.The Big Picture -- 19.1.4.Criteria for "Done" -- 19.2.Planning and Recordkeeping -- 19.2.1.Role of Scaffolding -- 19.2.2.Cost-Effective Testing -- 19.3.Test-Case Design -- 19.3.1.Requirements and Use Cases -- 19.3.2.Traceability -- 19.4.White-Box Testing -- 19.4.1.Basis Path Testing -- 19.4.2.Control Structure Testing -- 19.5.Black-Box Testing -- 19.5.1.Interface Testing -- 19.5.2.Equivalence Partitioning -- 19.5.3.Boundary Value Analysis -- 19.6.Object-Oriented Testing -- 19.6.1.Class Testing -- 19.6.2.Behavioral Testing -- 19.7.Summary -- ch. 20 Software Testing-integration Level -- 20.1.Software Testing Fundamentals -- 20.1.1.Black-Box Testing --

Note continued: 20.1.2.White-Box Testing -- 20.2.Integration Testing -- 20.2.1.Top-Down Integration -- 20.2.2.Bottom-Up Integration -- 20.2.3.Continuous Integration -- 20.2.4.Integration Test Work Products -- 20.3.Artificial Intelligence and Regression Testing -- 20.4.Integration Testing in the OO Context -- 20.4.1.Fault-Based Test-Case Design -- 20.4.2.Scenario-Based Test-Case Design -- 20.5.Validation Testing -- 20.6.Testing Patterns -- 20.7.Summary -- ch. 21 Software Testing-specialized Testing For Mobility -- 21.1.Mobile Testing Guidelines -- 21.2.The Testing Strategies -- 21.3.User Experience Testing Issues -- 21.3.1.Gesture Testing -- 21.3.2.Virtual Keyboard Input -- 21.3.3.Voice Input and Recognition -- 21.3.4.Alerts and Extraordinary Conditions -- 21.4.Web Application Testing -- 21.5.Web Testing Strategies -- 21.5.1.Content Testing -- 21.5.2.Interface Testing -- 21.5.3.Navigation Testing -- 21.6.Internationalization -- 21.7.Security Testing --

Note continued: 21.8.Performance Testing -- 21.9.Real- Time Testing -- 21.10.Testing Al Systems -- 21.10.1.Static and Dynamic Testing -- 21.10.2.Model-Based Testing -- 21.11.Testing Virtual Environments -- 21.11.1.Usability Testing -- 21.11.2.Accessibility Testing -- 21.11.3.Playability Testing -- 21.12.Testing Documentation and Help Facilities -- 21.13.Summary -- ch. 22 Software Configuration Management -- 22.1.Software Configuration Management -- 22.1.1.An SCM Scenario -- 22.1.2.Elements of a Configuration Management System -- 22.1.3.Baselines -- 22.1.4.Software Configuration Items -- 22.1.5.Management of Dependencies and Changes -- 22.2.The SCM Repository -- 22.2.1.General Features and Content -- 22.2.2.SCM Features -- 22.3.Version Control Systems -- 22.4.Continuous Integration -- 22.5.The Change Management Process -- 22.5.1.Change Control -- 22.5.2.Impact Management -- 22.5.3.Configuration Audit -- 22.5.4.Status Reporting --

Note continued: 22.6.Mobility and Agile Change Management -- 22.6.1.e-Change Control -- 22.6.2.Content Management -- 22.6.3.Integration and Publishing -- 22.6.4.Version Control -- 22.6.5.Auditing and Reporting -- 22.7.Summary -- ch. 23 Software Metrics And Analytics -- 23.1.Software Measurement -- 23.1.1.Measures, Metrics, and Indicators -- 23.1.2.Attributes of Effective Software Metrics -- 23.2.Software Analytics -- 23.3.Product Metrics -- 23.3.1.Metrics for the Requirements Model -- 23.3.2.Design Metrics for Conventional Software -- 23.3.3.Design Metrics for Object-Oriented Software -- 23.3.4.User Interface Design Metrics -- 23.3.5.Metrics for Source Code -- 23.4.Metrics for Testing -- 23.5.Metrics for Maintenance -- 23.6.Process and Project Metrics -- 23.7.Software Measurement -- 23.8.Metrics for Software Quality -- 23.9.Establishing Software Metrics Programs -- 23.10.Summary -- ch. 24 Project Management Concepts -- 24.1.The Management Spectrum -- 24.1.1.The People --

Note continued: 24.1.2.The Product -- 24.1.3.The Process -- 24.1.4.The Project -- 24.2.People -- 24.2.1.The Stakeholders -- 24.2.2.Team Leaders -- 24.2.3.The Software Team -- 24.2.4.Coordination and Communications Issues -- 24.3.Product -- 24.3.1.Software Scope -- 24.3.2.Problem Decomposition -- 24.4.Process -- 24.4.1.Melding the Product and the Process -- 24.4.2.Process Decomposition -- 24.5.Project -- 24.6.The W5HH Principle -- 24.7.Critical Practices -- 24.8.Summary -- ch. 25 Creating A Viable Software Plan -- 25.1.Comments on Estimation -- 25.2.The Project Planning Process -- 25.3.Software Scope and Feasibility -- 25.4.Resources -- 25.4.1.Human Resources -- 25.4.2.Reusable Software Resources -- 25.4.3.Environmental Resources -- 25.5.Data Analytics and Software Project Estimation -- 25.6.Decomposition and Estimation Techniques -- 25.6.1.Software Sizing -- 25.6.2.Problem-Based Estimation -- 25.6.3.An Example of LOC-Based Estimation --

Note continued: 25.6.4.An Example of FP-Based Estimation -- 25.6.5.An Example of Process-Based Estimation -- 25.6.6.An Example of Estimation Using Use Case Points -- 25.6.7.Reconciling Estimates -- 25.6.8.Estimation for Agile Development -- 25.7.Project Scheduling -- 25.7.1.-Basic Principles -- 25.7.2.The Relationship Between People and Effort -- 25.8.Defining a Project Task Set -- 25.8.1.A Task Set Example -- 25.8.2.Refinement of Major Tasks -- 25.9.Defining a Task Network -- 25.10.Scheduling -- 25.10.1.Time-Line Charts -- 25.10.2.Tracking the Schedule -- 25.11.Summary -- ch. 26 Risk Management -- 26.1.Reactive Versus Proactive Risk Strategies -- 26.2.Software Risks -- 26.3.Risk Identification -- 26.3.1.Assessing Overall Project Risk -- 26.3.2.Risk Components and Drivers -- 26.4.Risk Projection -- 26.4.1.Developing a Risk Table -- 26.4.2.Assessing Risk Impact -- 26.5.Risk Refinement -- 26.6.Risk Mitigation, Monitoring, and Management -- 26.7.The RMMM Plan --

Note continued: 26.8.Summary -- ch. 27 A Strategy For Software Support -- 27.1.Software Support -- 27.2.Software Maintenance -- 27.2.1.Maintenance Types -- 27.2.2.Maintenance Tasks -- 27.2.3.Reverse Engineering -- 27.3.Proactive Software Support -- 27.3.1.Use of Software Analytics -- 27.3.2.Role of Social Media -- 27.3.3.Cost of Support -- 27.4.Refactoring -- 27.4.1.Data Refactoring -- 24.4.2.Code Refactoring -- 27.4.3.Architecture Refactoring -- 27.5.Software Evolution -- 27.5.1.Inventory Analysis -- 27.5.2.Document Restructuring -- 27.5.3.Reverse Engineering -- 27.5.4.Code Refactoring -- 27.7.5.Data Refactoring -- 27.5.6.Forward Engineering -- 27.6.Summary -- ch. 28 Software Process Improvement -- 28.1.What Is SPI? -- 28.1.1.Approaches to SPI -- 28.1.2.Maturity Models -- 28.1.3.Is SPI for Everyone? -- 28.2.The SPI Process -- 28.2.1.Assessment and GAP Analysis -- 28.2.2.Education and Training -- 28.2.3.Selection and Justification -- 28.2.4.Installation/Migration --

Note continued: 28.2.5.Evaluation -- 28.2.6.Risk Management for SPI -- 28.3.The CMMI -- 28.4.Other SPI Frameworks -- 28.4.1.SPICE -- 28.4.2.TickI T Plus -- 28.5.SPI Return on Investment -- 28.6.SPI Trends -- 28.7.Summary -- ch. 29 Emerging Trends In Software Engineering -- 29.1.Technology Evolution -- 29.2.Software Engineering as a Discipline -- 29.3.Observing Software Engineering Trends -- 29.4.Identifying "Soft Trends" -- 29.4.1.Managing Complexity -- 29.4.2.Open-World Software -- 29.4.3.Emergent Requirements -- 29.4.4.The Talent Mix -- 29.4.5.Software Building Blocks -- 29.4.6.Changing Perceptions of "Value" -- 29.4.7.Open Source -- 29.5.Technology Directions -- 29.5.1.Process Trends -- 29.5.2.The Grand Challenge -- 29.5.3.Collaborative Development -- 29.5.4.Requirements Engineering -- 29.5.5.Model-Driven Software Development -- 29.5.6.Search-Based Software Engineering -- 29.5.7.Test-Driven Development -- 29.6.Tools-Related Trends -- 29.7.Summary --

Note continued: ch. 30 Concluding Comments -- 30.1.The Importance of Software-Revisited -- 30.2.People and the Way They Build Systems -- 30.3.Knowledge Discovery -- 30.4.The Long View -- 30.5.The Software Engineer's Responsibility -- 30.6.A Final Comment from RSP.