π Lecture 1 β Software Process Improvement
π Overview: This lecture introduces the foundational concepts of software process improvement, explaining what processes are and why they are essential for managing complexity and reusing knowledge. It explores the nature of software processes, their management through statistical control, process modeling, and the systematic steps required to improve software development practices.
ποΈ Topics Covered
The lecture covers the course objectives, defining processes and software processes with examples, explaining software problems as technical vs. systemic, detailing process management based on statistical process control and measurement, describing process models and their variations, and outlining process improvement objectives, planning, and the six-step improvement cycle.
π Lecture Summary
Objectives of This Course
The course aims to introduce students to the basics of software process and process improvement. It will teach activities and issues in software process engineering, different improvement approaches, the concept of measurements in processes, and advanced research topics. Students will also explore local industry to understand and suggest improvement strategies.
Processes
Processes are essential mechanisms for coping with complexity in all aspects of life. Descriptions of processes are very important because they allow knowledge to be reused.
What is a Process?
A process is a documented way to solve a problem, allowing others to reuse that solution. Once someone has worked out how to solve a problem, they can document the way in which that solution was derived as a process.
π Examples of Processes:
- An instruction manual for a kitchen dishwasher describes the process of using that machine to clean dishes.
- A cookery book describes processes to prepare and cook meals.
- A bank's procedures manual describes processes for agreeing to a personal loan or correcting errors.
- A quality manual for software development describes the processes to assure the quality of the software, including standards for quality checking.
Software Processes
Software Problems can be technical (needing a technical solution, easy to solve) or systemic (difficult to solve, needing a process/management solution).
Solution to Software Problems involves treating the software task as a process that can be controlled, measured, and improved. It requires relating tasks, tools, and methods with the skill, training, and motivation of the people involved.
Software Processes are the set of tools, methods, and practices that people use to produce software and associated products like project plans, design documents, code, test cases, and user manuals. π‘ Why this matters: Recognizing that people are the most important part of an organization is crucial for process success.
Characteristics of Software Processes include requiring creativity, interactions between a wide range of people, engineering judgment, background knowledge, and experience.
π Examples of Software Processes:
- Software engineering development process (SDLC)
- Requirements engineering process
- Quality assurance process
- Change management process
- Design process
Process Management
Basic Concepts: The objectives of software process management are to produce products according to plan while simultaneously improving the organization's capability to produce better products. The basic principles are those of statistical process control.
A process is stable or under statistical control if its future performance is predictable within established statistical limits. When a process is stable, repeating work in roughly the same way will produce roughly the same result. To obtain consistently better results, the process must be improved. If a process is not under control, sustained progress is impossible until it is.
The basic principle behind statistical control is measurement. Lord Kelvin stated that when you can measure and express things in numbers, you know something about it; without numbers, knowledge is meager.
However, numbers must properly represent the process and be well-defined. The mere act of measuring human processes changes them, so measurements must be limited to those with predefined use. Measurements are both expensive and disruptive, and overzealous measuring can degrade the process.
Process Models
A process model is a simplified description of a process presented from a particular perspective. There may be several different models of the same process, and no single model gives a complete understanding of the process being modeled.
Variations in Process Models are produced based on anticipated need:
- To help explain how process information has been organized.
- To help understand and improve a process.
- To satisfy some quality management standard.
Types of Process Model:
- Coarse-grain activity models: Provide an overall picture of the process, describing the context of different activities but not how to enact the process.
- Fine-grain activity models: More detailed models of a specific process, used for understanding and improving existing processes.
Enactment of Processes: Different people usually enact the same process in different ways due to different backgrounds and experience. Experienced people may change the order of stages, while inexperienced people follow the stages as described.
Process Improvement
Process Improvement Objectives include quality improvement, schedule reduction, and resource reduction.
Process Improvements Planning requires asking:
- What are the improvement goals?
- How can we introduce process improvements to achieve these goals?
- How should improvements be controlled and managed?
Six Steps to Software Improvements:
- Understand the current status of development processes.
- Develop a vision for the desired process.
- Establish a list of required process improvement actions in order of priority.
- Produce a plan to accomplish the required actions.
- Commit the resources to execute the plan.
- Start over at step 1.
Process Maturity Levels are: Initial, Repeatable, Defined, Managed, and Optimizing.
β Key Takeaways
The most critical concept is that treating software development as a measurable, controllable process is essential for systematic improvement. Statistical process control requires a stable process before improvement can occur, and measurement is the foundation for this control. Different stakeholders may need different process models (coarse-grain vs. fine-grain), and process enactment varies based on individual experience. Finally, the six-step improvement cycle emphasizes that process improvement is a continuous, iterative activity that must be planned and managed.
π§ Quick Revision Questions
- What is the fundamental difference between a technical software problem and a systemic software problem?
- According to the lecture, why is measurement considered the basic principle behind statistical process control?
- What is a process model, and why might multiple models of the same process be necessary?
- What is the difference between a coarse-grain activity model and a fine-grain activity model?
- List the six steps involved in the software process improvement cycle.
π Lecture 2 β Software Quality Assurance
π Overview: This lecture defines software quality and explains why it is critical for business success. It introduces the Software Quality Assurance (SQA) group, its goals, skills, responsibilities, and the formal technical review process used to ensure quality. The lecture concludes with guidance on proper reporting structures for SQA to maintain its independence and effectiveness.
ποΈ Topics Covered
The lecture begins by defining software quality and its business importance, including the escalating cost of finding defects late. It then introduces the SQA group, its goals, pictorial process, required skills, and role as an independent monitor. Key pitfalls for SQA are listed, followed by specific SQA responsibilities. The core of the lecture details the formal technical review (FTR) process: its objectives, what it is not, participant roles, and the five-step review lifecycle (planning, meeting, report, rework, follow-up). Finally, the correct SQA reporting structure is emphasized.
π Lecture Summary
Quality and its need
Software quality is defined by low levels of defects when deployed (ideally approaching zero) and high reliability (running without crashes or strange results). The need for quality is driven by several business benefits: it reduces time to market for new products, enhances market share, minimizes βscrap and reworkβ expenses, attracts and keeps top-gun personnel, and minimizes the risks of serious litigation, operating failures, delays, or even bankruptcy. π‘ Why this matters: The lecture graphically shows that the cost to find and fix a defect escalates dramatically as you move from requirements (cheapest) to operations (most expensive), making early quality efforts a critical economic decision.
π Definition β Software Quality Assurance (SQA): An active and independent group within every organization devoted to assuring the quality of software products.
π Key Concept β Cost to Find and Fix a Defect: The earlier a defect is found in the software lifecycle, the cheaper it is to fix. Finding a defect during operations is exponentially more expensive than finding it during requirements.
SQA tasks
The goals of SQA are: (1) to improve software quality by appropriately monitoring both the software and the development process that produces it, (2) to ensure full compliance with established standards and procedures, and (3) to ensure any inadequacies in the product, process, or standards are brought to managementβs attention so they can be fixed. The SQA process is depicted as taking inputs from standards and development, processing them with SQA, and producing outputs that feed back into management and development.
For SQA tasks, the group must review all development and quality plans for completeness, participate as inspection moderators in design and code inspections, review all test plans for adherence to standards, review a significant sample of all test results, periodically audit SCM (Software Configuration Management) performance, and participate in all project quarterly and phase reviews, registering non-concurrence if standards are not met.
SQA group skills and responsibilities
The skills of an SQA group member include knowledge of statistical methods, quality control principles, the software process, and an ability to deal effectively with people in contentious situations.
The role of SQA is not to make quality themselves, but to monitor how the software project groups perform their quality responsibilities. The people responsible for the software projects are the only ones who can be held responsible for software quality. The lecture warns of key pitfalls: (1) It is a mistake to assume SQA people themselves can do anything about quality; (2) an SQA group does not ensure standards are followed; (3) SQA will be ineffective unless management periodically demonstrates support; (4) SQA and development will not work together unless line management requires SQA to resolve issues with project management before escalation.
SQA Reviews
A review is defined by IEEE Std. 610.12-1990 as a process or meeting during which a work product is presented to project personnel, managers, users, or other interested parties for comment or approval. Types include code review, design review, formal qualification review, requirements review, and test readiness review.
The objectives of Formal Technical Reviews (FTRs) are: uncover errors in function, logic, or implementation; verify the software meets its requirements; ensure representation according to predefined standards; achieve uniform development; make projects more manageable; transfer ownership from individual to group; serve as a training ground for junior engineers; and serve as a means of corporate backup.
π‘ Why this matters: Technical reviews are not a project budget summary, scheduling assessment, overall progress report, or a mechanism for reprisal or political intrigue. They are strictly focused on the technical quality of the work product.
Review Roles include the Facilitator, Author, Recorder, Reviewer, and Observer. The Facilitator provides background, encourages participation, keeps the meeting focused, and gains consensus on problems. The Author is responsible for the readiness and distribution of material, schedules the review, selects participants, determines entry criteria, and provides information to clarify issues. The Recorder collects and records each defect, develops an issues list, records meeting decisions, prepares and publishes minutes, and tracks action items. The Reviewer spends time prior to the meeting reviewing information, makes notes of defects, identifies strengths, and insists on clarifying issues. The Observer is a new member who learns the product and observes techniques.
The Review Activities follow a five-step process:
- Review Planning: Distribute the review package one week in advance, including the document, agenda, roles, exit/entrance criteria, objective, names of attendees, location, date/time, classification list (defect type, origin, severity), and handling procedures.
- Review Meeting: The facilitator begins with an introduction. The author explains materials while reviewers raise issues. Valid problems are classified and recorded with names of responsible individuals and timelines. Guidelines for reviewers include: be prepared, review the product not the producer, keep tone mild, stick to the agenda, raise issues donβt resolve them, and avoid style discussions. At the end, attendees decide to accept the product, reject it, accept it provisionally, or hold a follow-up review.
- Review Report: Published by the recorder within a week, it includes the elements reviewed, participant names, specific inputs, unresolved items, escalation items, action items/ownership/status, and suggested recommendations.
- Rework: The project manager ensures all defects identified are fixed and retested.
- Follow-up: All discrepancies are confirmed resolved, exit criteria are met, and lessons learned are documented.
π Definition β Review: A process or meeting during which a work product is presented for comment or approval (IEEE Std. 610.12-1990). π Definition β Formal Technical Review (FTR): A specific type of review focused on uncovering errors and ensuring quality.
SQA Reporting
The SQA group must have a clear and independent SQA reporting structure to be effective. SQA should not report to the project manager. It should report somewhere within the local office and division office, with typically no more than one management position between SQA and the senior location manager. SQA should always have a βdotted-lineβ relationship to a senior corporate quality executive. Whenever possible, SQA should report to someone with a vested interest in software quality, like the staff head responsible for field service.
β Key Takeaways
The primary purpose of the SQA group is to monitor the development process and ensure compliance with standards, not to directly improve quality themselves. Formal Technical Reviews are a cornerstone of quality assurance, with a structured process of planning, meeting, reporting, rework, and follow-up, and distinct roles for facilitator, author, recorder, reviewer, and observer. The most critical skill for reviewers is to review the product, not the producer, focusing on technical correctness rather than style. Proper SQA independence is crucial; SQA must report outside the project management chain, ideally to a senior location or corporate quality executive. Finally, the cost of finding and fixing a defect increases exponentially as it moves through the lifecycle, making early quality activities economically vital.
π§ Quick Revision Questions
- What are the three main goals of the Software Quality Assurance (SQA) group?
- List the five distinct participant roles in a Formal Technical Review (FTR) and name one primary responsibility of the Recorder.
- Explain the difference between the role of SQA and the role of the software project teams in achieving software quality.
- What should be the proper reporting structure for an SQA group to ensure its independence and effectiveness?
- Name the five sequential activities of a Formal Technical Review (FTR).
π Lecture 3 β Configuration Management
π Overview: This lecture introduces software configuration management (SCM) as the art of coordinating software development to minimize confusion caused by inevitable changes. It explains why change happens, how it creates chaos if uncontrolled, and presents the five core SCM functionsβidentification, version control, change control, configuration audit, and status accountingβthat together provide visibility, control, and traceability throughout the software process.
ποΈ Topics Covered
The lecture begins by discussing change as an inevitable part of software development and its sources, then defines confusion that arises from uncontrolled change. It introduces configuration management and software configuration management (SCM), explains the purpose of SCM activities, and defines the concept of a software configuration and baseline. The five SCM functions are then explained in detail: identification, version control, change control (including the formal change control process, change control authority/board, engineering change orders, access and synchronization control), configuration audit, and status accounting/reporting. The lecture concludes with an overview of SCM and the importance of management commitment.
π Lecture Summary
Change
Changes will happen in all work products and during all processes during software development and maintenance. Change increases the level of confusion among software engineers who are working on a software project.
Sources of Change:
- New business or market conditions dictate changes in product requirements or business rules
- New customer needs demand modification of data produced by information systems, functionality delivered by products, or services delivered by computer-based system
- Reorganization or business growth/downsizing causes changes in project priorities or software engineering team structure
- Budgetary or scheduling constraints cause a redefinition of the system or product
Why All This Modification? As time passes, all constituencies know more about what they need, which approach would be best, and how to get it done and still make money. Most changes are justified.
Confusion
Confusion arises when changes are not:
- Analyzed before they are made
- Recorded before they are implemented
- Reported to those who need to know
- Controlled in a manner that will improve quality and reduce errors
We need to minimize this confusion, or else our projects will get out of control.
Configuration Management
The art of coordinating software development to minimize confusion is called configuration management. The goal is to maximize productivity by minimizing mistakes.
Software Configuration Management
SCM is a set of activities designed to control change by:
- Identifying the work products that are likely to change
- Establishing relationships among them
- Defining mechanisms for managing different versions of these work products
- Controlling the changes imposed
- Auditing and reporting on the changes
π‘ Why this matters: SCM is an umbrella activity applied throughout the entire software process, not just at the end.
Purpose of SCM Activities:
- Identify change
- Control change
- Ensure that the change is being properly implemented
- Report changes to others who may be interested
SCM Provides Cover Against:
- Lack of visibility
- Lack of control
- Lack of traceability
- Lack of monitoring
- Uncontrolled change
Software Configuration: The items that comprise all information produced as part of the software process are collectively called a software configuration. These include:
- Computer programs (source and executable)
- Documents that describe the computer programs
- Data
Software configuration items will grow. You must baseline every software configuration item.
Baseline every Software Configuration Item
How to Manage Change? A baseline is a software configuration management concept that helps us to control change without seriously impeding justifiable change.
π Definition β Baseline (IEEE Std. No. 610.12-1990): A specification or product that has been formally reviewed and agreed upon, that thereafter serves as the basis for further development, and that can be changed only through formal change control procedures.
Before a software configuration item becomes a baseline, changes may be made quickly and informally. However, once a baseline is established, changes can be made, but a specific, formal procedure must be applied to evaluate and verify each change request. In the context of software engineering, a baseline is a milestone in the development of software that is marked by the delivery of one or more software configuration items and approval of these software configuration items is obtained through a formal technical review or inspection.
Typical work products that are base-lined are:
- System specification
- Software requirements
- Design specification
- Source code
- Test plans/procedures/data
- Operational system
SCM Questions
- How does an organization identify and manage the many existing versions of a configuration item in a manner that will enable change to be accommodated efficiently?
- How does an organization control changes before and after software is released to a customer?
- Who has the responsibility for approving and ranking changes?
- How can we ensure that changes have been made properly?
- What mechanism is used to apprise others of changes that are made?
SCM Functions
The five SCM functions are:
- Identification of software configuration items
- Version control
- Change control
- Configuration audit
- Status accounting/reporting
SCM Function 1: Identification
To control and manage software configuration items, each item must be separately named or numbered. The identification scheme is documented in the software configuration management plan. The unique identification of each SCI helps in organization and retrieval of configuration items.
SCM Function 2: Version Control
Version control combines procedures and tools to manage different versions of configuration items that are created during the software process. The naming scheme for SCIs should incorporate the version number. Configuration management allows a user to specify alternative configurations of the software system through the selection of appropriate versions. This is supported by associating attributes with each software version, and then allowing a configuration to be specified (and constructed) by describing the set of attributes.
SCM Function 3: Change Control
Change control is vital. Too much change control and we create problems. Too little, and we create other problems. For large projects, uncontrolled change rapidly leads to chaos. For medium to large projects, change control combines human procedures and automated tools to provide a mechanism for the control of change.
Change Control Process: Proposed changes to software work-products are reviewed, then subjected to the agreement of project participants, and finally incorporated into the currently approved software configuration. This requires that a separate authority, which reviews and approves all change requests, be established for every project from among the project participants. This authority is known as Change Control Authority or Change Control Board (CCA/CCB). A CCA/CCB plays an active role in the project level change control and formal change control activities. Typically, a CCA consists of representatives from software, hardware, database engineering, support, and marketing, etc., depending on the size and nature of the project.
For every change request, the change control authority/board assesses the:
- Technical merit
- Potential side effects
- Overall impact on other configuration items and system functions
- Projected cost of the change
The CCA/CCB has the authority to approve or reject a change request. It can delay the request for consideration and inclusion in the next iteration also. For every approved change request, an Engineering Change Order (ECO) is generated, which describes:
- The change to be made
- The constraints that must be respected
- The criteria of review and audit
The formal change control process is very elaborate and comprehensive. The βcheck-inβ and βcheck-outβ activities implement two important elements of change control:
- Access control
- Synchronization control
The Change Control Process (Step-by-Step):
- Need for change is recognized
- Change request from user
- Developer evaluates
- Change report is generated
- Change control authority decides
- If approved: Request is queued for action β Assign people to SCIs β Check-out SCIs β Make the change β Review/audit the change β Establish a βbaselineβ for testing β Perform SQA and testing activities β Check-in the changed SCIs β Promote SCI for inclusion in next release β Rebuild appropriate version β Review/audit the change β Include all changes in release
- If rejected: Change request is denied, user is informed
Access and Synchronization Control: Access control governs which software engineers have the authority to access and modify a particular configuration item. Synchronization control helps to ensure that parallel changes, performed by two different people, donβt overwrite one another. We need to implement both.
π‘ Why this matters: The check-in/check-out mechanism is the practical implementation of change control, ensuring no work is lost when multiple developers work on the same files.
SCM Function 4: Configuration Audit
A software configuration audit complements the formal technical reviews/inspections by assessing a configuration item for characteristics that are generally not considered during review. The SCM audit is conducted by the quality assurance group.
Key questions addressed by the configuration audit:
- Has the change specified in the ECO been made? Have any additional modifications been incorporated?
- Has a formal technical review been conducted to assess technical correctness?
- Has the software process been followed and have software engineering standards been properly applied?
- Has the change been βhighlightedβ in the SCI? Have the change date and author been specified? Do the attributes of the configuration object reflect the change?
- Have SCM procedures for noting the change, recording it, and reporting it been followed?
- Have all related SCIs been properly updated?
SCM Function 5: Status Accounting/Reporting
The status accounting function provides a corporate memory of project events that supports accomplishment of other configuration management items. It answers:
- What happened?
- Who did it?
- When did it happen?
- What else will be affected?
Management Commitment for SCM
Successful SCM implementation requires management commitment. The lecture includes a visual showing that management commitment is needed for policies, process, and tools. The SCM process itself consists of establishing baselines, configuration status accounting, configuration identification, change control, and configuration auditing.
Summary
- Software configuration management is an umbrella activity that is applied throughout the software process
- SCM identifies, controls, audits, and reports modifications that invariably occur while software is being developed and after it has been released
- SCM saves a project from total chaos
β Key Takeaways
Students must remember that change is inevitable in software development and uncontrolled change leads to confusion and project chaos. Configuration management is the systematic art of minimizing this confusion through five core functions: identification, version control, change control (including the formal process with CCA/CCB and ECOs), configuration audit, and status accounting. The baseline is a critical conceptβa formally reviewed product that serves as a foundation for development and can only be changed through formal procedures. The check-in/check-out mechanism with access and synchronization control is the practical tool for implementing version and change control, preventing parallel edits from overwriting each other. Ultimately, SCM is an umbrella activity applied throughout the entire software life cycle that requires management commitment to succeed.
π§ Quick Revision Questions
- What are the five functions of software configuration management?
- Define a baseline according to the IEEE standard, and explain how the change process differs before and after a baseline is established.
- What is a Change Control Authority/Board (CCA/CCB) and what factors does it assess when evaluating a change request?
- What is the difference between access control and synchronization control in the context of SCM?
- What are the five sources of confusion that arise when changes are not properly managed?
π Lecture 4 β Introduction to Project Planning
π Overview: This lecture introduces the fundamental concepts of software project planning, explaining why planning is crucial for managing complexity and ensuring timely, quality delivery. It covers the logic, goals, and objectives of project planning, then details the key steps: defining software scope, estimation, risk management, scheduling, and control strategy. The lecture emphasizes that planning is an iterative process that refines estimates as requirements become clearer.
ποΈ Topics Covered
The lecture covers the logic of software project planning, its overarching goal and specific objectives, and the five core steps: software scope, estimation, risk, schedule, and control strategy. Within estimation, it details resource and cost estimation, including functional decomposition, estimation techniques, empirical models like COCOMO, and the importance of using multiple techniques. The lecture also addresses feasibility and provides guidance on understanding project scope.
π Lecture Summary
Logic of Software Project Planning
Software development is complex and requires careful planning to ensure resources are available at the right time. The plan starts by mapping a route from vague, initial requirements to accurate and precise ones. A conceptual design is developed as the basis for planning, defining the productβs breakdown into units, function allocation, and relationships. A poor conceptual design is almost impossible to recover from. As requirements are refined, resource projections, size estimates, and schedules are also refined. The plan provides the framework for negotiating time and resources throughout the project life-cycle.
π‘ Why this matters: Planning is not a one-time event but a continuous cycle of refinement that adapts as understanding of the project grows.
Goal of Project Planning
The overall goal of project planning is to establish a pragmatic strategy for controlling, tracking, and monitoring a complex technical project. The ultimate purpose is to ensure the end result gets done on time, with quality.
Objectives of Project Planning
The objective of software project planning is to provide a framework that enables the manager to make reasonable estimates of resources, cost, and schedule. These estimates are made within a limited time frame at the beginning of a project and must be updated regularly as the project progresses. Estimates should attempt to define best-case and worst-case scenarios so that project outcomes can be bounded.
Steps of Project Planning
The five core steps are: Software scope, Estimation, Risk, Schedule, and Control strategy.
Software Scope
Software scope describes the data and control to be processed, function, performance, constraints, interfaces, and reliability. It must be unambiguous and understandable at both management and technical levels. A statement of software scope must be bounded. Good and open communication between developers and the customer is required to define the scope. To understand scope, one must understand the customerβs needs, business context, project boundaries, customer motivation, and likely paths for change, while acknowledging that even with understanding, nothing is guaranteed.
π Definition β Software Scope: The description of the data and control to be processed, function, performance, constraints, interfaces, and reliability that unambiguously defines the work to be done.
Feasibility
Once scope is identified and agreed upon with the customer, it is reasonable to ask: βCan we build software to meet this scope? Is the project feasible?β Often this question is overlooked, leading to serious problems.
Estimation
Estimation involves determining: How much effort? How much time? Resource and time estimation.
π Definition β Estimation: The process of determining the effort and time required to complete a software project.
Cost Estimation
To perform cost estimation, project scope must be explicitly defined. Task and/or functional decomposition is necessary. Historical measures (metrics) are very helpful. At least two different techniques should be used. Uncertainty is inherent in all estimates.
π Definition β Cost Estimation: The process of predicting the resources, effort, and cost associated with a software project.
Project Resources
Project resources include people, reusable software components, and hardware/software tools. Software cost and effort estimation will never be an exact science due to too many variables β human, technical, environmental, and political β that can affect the ultimate cost.
Options for Reliable Cost and Effort Estimates
Options include: delaying estimation until late in the project; basing estimates on similar completed projects; using simple decomposition techniques (like functional decomposition, or βdivide and conquerβ); or using one or more empirical models for estimation.
Estimation Techniques
Estimation techniques include: past similar projects experience; conventional estimation techniques (e.g., task breakdown and effort estimates, size estimates like Function Points (FP), and tools like Checkpoint); and creating a Task Matrix.
Estimation based on Empirical Models
The general formula for empirical models is: d = f(vα΅’), where d is one of a number of estimated values (e.g., effort, cost, project duration) and vα΅’ are selected independent parameters (e.g., estimated Lines of Code (LOC) or Function Points (FP)).
π Formula: d = f(vα΅’) β Estimated value is a function of independent parameters like LOC or FP.
COCOMO model
The COCOMO model (Constructive Cost Model) is a specific empirical model used for estimation.
Risk
Risk analysis asks: What can go wrong? How can we avoid it? What can we do about it?
π Definition β Risk: An uncertain event or condition that, if it occurs, has a positive or negative effect on a projectβs objectives.
Schedule
Scheduling asks: How do we allocate resources along the time line? What are the milestones?
π Definition β Schedule: A timeline that allocates resources and defines milestones for project completion.
Control Strategy
Control strategy asks: How do we control quality? How do we control change?
π Example: A project team initially estimates a project will take 12 months and require 5 developers. After defining the software scope and using functional decomposition, they refine their estimate to 10 months and 4 developers. This new estimate is incorporated into the schedule, and a control strategy is put in place to track progress against milestones and manage any change requests.
β Key Takeaways
The core of project planning is creating a dynamic, iterative framework to manage complexity and uncertainty, not a static document. The five essential steps are scope, estimation, risk, schedule, and control strategy, which must be executed and refined continuously. Estimation is inherently uncertain, so itβs critical to use multiple techniques (e.g., decomposition and an empirical model like COCOMO), and to always define best-case and worst-case scenarios. A clear, bounded, and mutually understood software scope with the customer is the foundation for all subsequent planning, and feasibility must be explicitly assessed. Finally, the planβs ultimate goal is to provide a strategy for controlling, tracking, and monitoring the project to ensure on-time, quality delivery.
π§ Quick Revision Questions
- What is the overarching goal of software project planning, and why is it described as a continuous cycle rather than a single event?
- List the five core steps of project planning as presented in the lecture.
- What does it mean for a statement of software scope to be βbounded,β and why is this necessary at the beginning of a project?
- According to the lecture, what are the four options for generating reliable cost and effort estimates?
- In the context of empirical estimation models, what does the formula d = f(vα΅’) represent, and what are examples of d and vα΅’?
π Lecture 5 β Process Models
π Overview: This lecture explores the fundamental concepts of software processes, process models, and the balance between standardization and customization. It explains why defined processes are crucial for managing complex software development and introduces three distinct levels of process modelsβUniversal, Worldly, and Atomicβalong with their relationships to policies, procedures, and standards.
ποΈ Topics Covered
The lecture begins by establishing why a software process is needed, then defines what a software process is and acknowledges software engineering as an intellectual, non-routine activity. It discusses process trade-off factors and the conflicting needs for process standardization and customization, introducing the concept of a process architecture. Key definitions for software engineering process, process architecture, and process model are provided. The lecture categorizes software process models into three levels: Universal (U), Worldly (W), and Atomic (A), explaining each levelβs characteristics and problems. It details the relationships between these levels, mapping U models to policies, W models to procedures, and A models to standards/tools. Finally, it covers critical software process issues like quality, product technology, requirements instability, and complexity.
π Lecture Summary
Why Software Process?
Software development can be exceedingly complex, with many alternative ways to perform tasks. There is a need for an organized set of activities, which when performed accurately, will result in an orderly development effort.
Software Process
A defined process can help guide software professionals through tasks in an orderly way. This results in the establishment of a process definition they can understand. This enables professionals to better understand what they should do, what they expect from co-workers, and what they are expected to provide in return. This allows them to focus on their jobs and acts as a contract between co-workers. Operational definitions are "something everyone can communicate about and work to" β Deming. They provide organizations with a consistent working framework while permitting individual adjustments to unique needs.
Software Engineering
Software engineering is not a routine activity that can be structured like repetitive manufacturing. It is an intellectual process that must dynamically adjust to the creative needs of the professionals and their tasks; a trade-off is needed.
Process Trade-off Factors
Since software projects have differences, their software engineering processes must have differences as well. In the absence of a universal software engineering process, organizations and projects must define processes that meet their own unique needs. The process used for a given project must consider the experience level of the members, current product status, and the available tools and facilities.
Process Standardization
There is a need to balance standardization with individual creativity, as seen in examples like music and artistic painting. Process standardization helps to reduce the problems of training, review, and tool support. With standard methods, each project's experiences can contribute to overall process improvement. Process standards provide the basis for process and quality measurements. Since process definitions take time and effort to produce, it is impractical to produce new ones for each project.
Customization and Standardization
The conflicting needs for customization and standardization can be resolved by establishing a process architecture, which consists of a standard set of unit or "kernel" process steps with rules for describing and relating them. Customization is achieved through appropriate interconnections of these standard elements into tailored process models.
Software
The term software refers to a program and all the associated information and materials needed to support its installation, operation, repair, and enhancement.
Definitions
π Software Engineering Process: The total set of software engineering activities needed to transform a user's requirements into software. π Software Process Architecture: A framework within which project-specific software processes are defined. π Software Process Model: One specific embodiment of a software process architecture.
Software Processes
Software processes can be categorized according to the level of details organized in these processes. Some can be high-level (with little detail), while others can be low-level processes with lots of details. This analysis results in three levels of software process models: Universal or U Process Models, Atomic or A Process Models, and Worldly or W Process Models.
Universal or U Process Models
U process models provide high-level overviews. Traditional Waterfall, Spiral, and other later process models fall in this category and are typically task-oriented. The fundamental problem with simplistic U-level models is that they do not accurately represent what is really done. Traditional process models are extremely sensitive to task sequence, so simple adjustments can destroy the entire framework. For example, the waterfall model provides a very simplified view of activities, which can lead to inaccurate model development. π Example: The lecture includes a diagram of a "Version of Waterfall Model" which shows a linear sequence of steps. π Example: The lecture includes a diagram of a "Spiral model of the software process" which shows an iterative process with risk analysis at each cycle.
Problems with Universal Model
Problems arise from an over-emphasis on modeling tasks. It limits human flexibility and tends to arbitrarily impose rigidity. It becomes progressively less helpful as the number of possible task sequences increases. The model becomes very difficult to understand. Such process rigidity can cause serious problems for process automation, project management, or contract administration. The question is not "what is the right way to model the process?" but "what is the most appropriate way to model this process for this purpose?"
Worldly or W Process Models
W process models are most useful to practicing software engineers. They guide the sequence of their working tasks and define task prerequisites and results. They look like procedures and specify who does what when. Where appropriate, they reference the A level that specifies standard task definitions or tool usage. For each task, W models define the anticipated results, the appropriate measures, and the key checkpoints.
Atomic or A Process Models
A process models are enormously detailed. They are used to automate specific process activity or use a standardized method or procedure to guide execution of a task. Precise data definitions, algorithmic specifications, information flows, and user procedures are essential at this level. The amount of detail must be determined by their use. For example, an experienced developer repeating known tasks will not need as detailed a standard as a new trainee. When a task is to be automated, a great deal of detail is generally required. Atomic process definitions are often embodied in process standards and conventions, which can be treated as process abstractions in the higher level "W" or "U" process models.
Relations of Software Process Models
U process models embody policies; W process models embody procedures; and A process models embody standards and/or tools.
Policies
Policies establish a high-level framework and set of principles that guide the overall behavior of organizations. They are particularly helpful in unanticipated circumstances where no precedents have been established.
Policy-level Statements
Some policy-level statements include:
- All work will be subjected to an inspection before it is incorporated in a baseline.
- The quality of each product, at the time of new shipment, shall be better than its predecessor or leading competitor.
- All commitments for software cost or delivery will be supported by a documented and approved software engineering plan.
- Quality Assurance (QA) will review the software development process to assure senior management that the work is done according to established standards and procedures and in conformance with the intent of the stated policies.
βWβ-level, Procedures
At the "W"-level, procedures are established to implement the policies. This W-level process model refers to any available Atomic-level standards that define precisely how tasks are to be performed. At the W-level, a procedure might define the points at which Quality Assurance reviews are to be conducted and how resulting issues are to be handled. This might specify what percent of work is to be reviewed, how statistical samples are to be selected, and whether, when, and how SQA independently tests or monitors the software engineering work.
Atomic level standards
Atomic level standards serve as the basis for directing the work and for the SQA review. For example, a code inspection standard would specify what code is to be reviewed, when, the methods to be used, the reports to be produced, and the acceptable performance limits. The developers would use this standard to guide their actions, and the SQA people would review their actions and work products against this standard.
Critical Software Process Issues
The key issues include Quality, Product technology, Requirements instability (including unknown, unstable, or misunderstood requirements), and Complexity.
β Key Takeaways
The most critical concept from this lecture is the three-tiered structure of software process models: Universal (U) models for high-level policies, Worldly (W) models for detailed procedures guiding practitioners, and Atomic (A) models for precise standards and tool definitions. You must understand that a single universal model is inadequate because software development is an intellectual, non-routine activity that requires a balance between standardization and customization, achieved through a process architecture. Remember that policies provide guiding principles, procedures implement those policies by defining who does what when, and standards provide the precise, repeatable instructions for executing tasks. Finally, be aware that critical issues like requirements instability and complexity directly impact which process model level is most appropriate for a given project.
π§ Quick Revision Questions
- What are the three levels of software process models, and what is the primary concern of each level?
- Why are Universal (U) process models considered problematic for accurately representing real software development work?
- Explain the relationship between policies, procedures, and Atomic-level standards in the context of the three process model levels.
- How does a process architecture help resolve the conflicting needs for process standardization and customization?
- List the four critical software process issues mentioned in the lecture and explain one challenge associated with requirements instability.