Software Engineering Process
Chapter 10: Software Engineering Process
Section titled “Chapter 10: Software Engineering Process”Acronyms
Section titled “Acronyms”| Acronym | Full Form |
|---|---|
| BPMN | Business Process Modeling Notation |
| CASE | Computer-Aided Software Engineering |
| CMM | Capability Maturity Model |
| CMMI | Capability Maturity Model Integration |
| GQM | Goal-Question-Metric |
| IDEFO | Integration Definition |
| KA | Knowledge Area |
| PDCA | Plan-Do-Check-Act |
| SLCM | Software Life Cycle Model |
| SLCP | Software Life Cycle Process |
| UML | Unified Modeling Language |
Introduction
Section titled “Introduction”This chapter examines the software engineering process, which involves the work activities software engineers use to build and operate software. An engineering process is a set of interrelated activities that transform inputs into outputs. Since its emergence, the software engineering discipline has continuously learned from and adapted processes from other engineering fields, focusing on design, manufacturing analogies, and operations.
A core understanding is that no single process is ideal. Software processes must be selected, adapted, and applied based on the specific project and organizational context, with a strong emphasis on empirical measurement to support management and decision-making.
Breakdown of Topics for the Software Engineering Process
Section titled “Breakdown of Topics for the Software Engineering Process”- Software Engineering Process Fundamentals
- Introduction
- Software Engineering Process Definition
- Life Cycles
- Life Cycle Definition, Process Categories, and Terminology
- Rationale for Life Cycles
- The Concepts of Process Models and Life Cycle Models
- Paradigms for Development Life Cycle Models
- Development Life Cycle Models and Their Engineering Dimension
- The Management of SLCPs
- Software Engineering Process Management
- Software Life Cycle Adaptation
- Practical Considerations
- Software Process Infrastructure, Tools, and Methods
- Software Engineering Process Monitoring
- Software Process Assessment and Improvement
- Overview of Software Process Assessment and Improvement
- Goal-Question-Metric (GQM)
- Framework-Based Methods
- Process Assessment and Improvement in Agile
1. Software Engineering Process Fundamentals
Section titled “1. Software Engineering Process Fundamentals”1.1 Introduction
Section titled “1.1 Introduction”Software engineering processes are the work activities used to build and operate software. They are modeled on general engineering processes, which transform inputs into outputs using a set of interrelated activities. While early software engineering borrowed concepts like design and manufacturing from other disciplines, it’s now understood that building software requires significant design and learning effort focused on both the product and the process itself.
1.2 Software Engineering Process Definition
Section titled “1.2 Software Engineering Process Definition”A process is a set of interrelated activities that transform inputs into outputs to deliver an intended result.
- An activity is a set of cohesive tasks within a process.
- A task is a specific action intended to achieve an outcome of a process.
The output of one process often serves as the input for another, highlighting their interconnected nature. These processes are also guided by controls (e.g., constraints) and enabled by mechanisms (e.g., tools, workforce).
2. Life Cycles
Section titled “2. Life Cycles”2.1 Life Cycle Definition, Process Categories, and Terminology
Section titled “2.1 Life Cycle Definition, Process Categories, and Terminology”A life cycle describes the evolution of a system, product, or service from its conception through retirement. The term development refers to the crucial stage of building or changing a software system. The complete software system life cycle includes all processes from ideation to retirement, covering production, operation, and evolution.
Life cycle processes are typically grouped into four main categories:
- Technical Processes: Engineering practices to build, operate, and retire software (e.g., requirements definition, architecture, design, implementation, integration, verification, validation, maintenance).
- Technical Management Processes: Activities for planning and control (e.g., project planning, risk management, configuration management, quality assurance).
- Organizational Project-Enabling Processes: Support processes at the organizational level (e.g., infrastructure management, human resources, quality management, knowledge management).
- Agreement Processes: Processes to support collective decision-making, acquisition, and supply.
2.2 Rationale for Life Cycles
Section titled “2.2 Rationale for Life Cycles”Defining a life cycle is a powerful tool for managing the complexity of software creation. Because software processes are highly interrelated (the output of one is often the input to another), a life cycle specification provides a clear, understandable framework for communication, management, and coordination.
2.3 The Concepts of Process Models and Life Cycle Models
Section titled “2.3 The Concepts of Process Models and Life Cycle Models”A Software Life Cycle Model (SLCM) is a framework that can be used to create a project-specific sequence of activities, known as a life cycle. Well-known SLCMs include the waterfall, V-model, incremental, spiral, and Agile models.
2.4 Paradigms for Development Life Cycle Models
Section titled “2.4 Paradigms for Development Life Cycle Models”Different life cycle models follow different paradigms:
- Predictive Life Cycle: The project’s scope, time, and cost are determined in an early phase. It assumes requirements are a closed set that will not change significantly.
- Iterative Life Cycle: The scope is generally determined early, but time and cost estimates are refined as the team’s understanding grows. The product is developed through a series of repeated cycles.
- Incremental Life Cycle: The deliverable is produced through a series of iterations that successively add functionality. The product is considered complete only after the final iteration.
- Evolutionary Life Cycle: The product changes over its lifetime, often because requirements are introduced in successive steps rather than all at once.
- Continuous Development: Practices that allow for frequent releases of new systems through the use of automated tools.
A key distinction is whether a life cycle is open to change. Predictive models typically freeze requirements early, whereas Agile models allow requirements to change at any point.
2.5 Development Life Cycle Models and Their Engineering Dimension
Section titled “2.5 Development Life Cycle Models and Their Engineering Dimension”Several specific models have shaped software engineering:
- Waterfall Model: A predictive model where development proceeds sequentially through phases (requirements, design, implementation, etc.). It is document-driven and was an early attempt to systematize software development. The V-model is a well-known variant.
- Spiral Model: An evolutionary model that is risk-driven, where activities are performed iteratively until the software is complete.
- Rapid Prototyping: Emphasizes developing prototypes early to get feedback and analysis.
- Unified Process: An iterative and incremental framework, with variants like the Rational Unified Process (RUP) and OpenUP.
- Agile: A mindset based on values and principles that prioritize communication, being open to change, and delivering value to the customer. It is not a single method but an umbrella for practices like Scrum and Extreme Programming. It advocates for small, incremental deliveries.
- DevOps: A set of principles and practices that enable better communication and collaboration between development and operations stakeholders, facilitating continuous improvement and frequent releases.
2.6 The Management of SLCPs
Section titled “2.6 The Management of SLCPs”A general software life cycle can be viewed as having several key stages, which are not necessarily sequential:
- Concept: Identifying stakeholder needs and exploring solutions.
- Development: Refining requirements and creating the system.
- Production: Producing and testing the system.
- Utilization: Operating the system to satisfy user needs.
- Support: Providing actions to ensure satisfactory operation.
- Retirement: Disposing of the system according to established procedures.
2.7 Software Engineering Process Management
Section titled “2.7 Software Engineering Process Management”Process management involves the direction, control, and coordination of work. It occurs at multiple levels:
- Technical Level: The core engineering processes.
- Technical Management Level: Project management processes.
- Executive Management Level: Organizational enabling processes like portfolio and knowledge management.
2.8 Software Life Cycle Adaptation
Section titled “2.8 Software Life Cycle Adaptation”Life cycles are not one-size-fits-all. They must be adapted for each project, considering the product’s characteristics, stakeholder needs, and relevant standards. This involves selecting an appropriate development strategy, defining stages and processes, and documenting the rationale.
2.9 Practical Considerations
Section titled “2.9 Practical Considerations”Defining a life cycle process requires addressing all four process categories (technical, organizational, management, and agreement). A key lesson learned in the industry is the importance of realistic estimations and measurements to reduce uncertainty. Working in large batches without intermediate deliverables increases risk, which is why continuous delivery and effective communication, as championed by the Agile mindset and DevOps, have become critical.
2.10 Software Process Infrastructure, Tools, and Methods
Section titled “2.10 Software Process Infrastructure, Tools, and Methods”Processes can be defined using various notations, such as natural language, UML activity diagrams, or BPMN. A software process infrastructure includes tools that support these processes. Modern software engineering relies on integrated tools—once called Computer-Aided Software Engineering (CASE)—to automate essential processes like configuration management, testing, and issue tracking.
2.11 Software Engineering Process Monitoring
Section titled “2.11 Software Engineering Process Monitoring”Process execution must be monitored to assess whether objectives are met and risks are managed. This requires a holistic approach that evaluates both the process and the product to ensure the final result meets stakeholder needs.
3. Software Process Assessment and Improvement
Section titled “3. Software Process Assessment and Improvement”3.1 Overview of Software Process Assessment and Improvement
Section titled “3.1 Overview of Software Process Assessment and Improvement”The idea that any process can be improved is fundamental and is captured in paradigms like the Plan-Do-Check-Act (PDCA) cycle. For software engineering, process assessment and improvement rely on gathering empirical evidence to make informed decisions about choosing, assessing, and improving a life cycle process.
3.2 Goal-Question-Metric (GQM)
Section titled “3.2 Goal-Question-Metric (GQM)”The GQM approach is a method for process improvement based on setting measurable goals. By defining goals, asking questions to clarify them, and using metrics to answer those questions, a team can evaluate the effect of a change and determine if an improvement has occurred.
3.3 Framework-Based Methods
Section titled “3.3 Framework-Based Methods”Some assessment methods use frameworks that include a process reference model and an assessment model. Prominent examples include:
- Capability Maturity Model (CMM) and Capability Maturity Model Integration (CMMI).
- ISO/IEC 33000 (also known as SPICE), which provides a framework for assessing process quality characteristics (like capability) and organizational maturity.
These frameworks are built on the concept of continuous improvement.
3.4 Process Assessment and Improvement in Agile
Section titled “3.4 Process Assessment and Improvement in Agile”Agile methods embed process improvement directly into the life cycle. For example, Scrum uses retrospectives at the end of each iteration. During a retrospective, the team analyzes what went well and what didn’t, identifies root causes, and defines actions for improvement, creating a continuous learning loop.