π Lecture 30 β Software Process Benchmarks
π Overview: This lecture defines software benchmarks and baselines, detailing their role in comparing organizational performance against industry norms and internal historical data. It explores various types of benchmarks, how they are conducted, and their critical importance as a precursor to effective software process improvement initiatives. Understanding benchmarks is essential because they provide tangible, quantitative data that executives can understand and act upon, making the case for process improvement clearer than abstract maturity models.
ποΈ Topics Covered
This lecture begins by defining the fundamental concept of a benchmark as a standard, yardstick, or point of reference. It then categorizes different types of software benchmarks, including macroeconomic, economic, corporate IT, customer satisfaction, and project-level benchmarks. The discussion extends to how benchmark studies are conducted, the goal of a software benchmark analysis, and a basic sequence for performing them. The lecture concludes by contrasting benchmarks with software baselines, explaining that baselines compare a company against its own past performance and highlighting the significant challenges in creating accurate baselines.
π Lecture Summary
Benchmarks
Software benchmarks are formal comparisons of a companyβs methods and results against those of other organizations. The lecture begins by defining a benchmark as a standard, yardstick, target, scale, or point of reference.
π Definition β Benchmark: A formal comparison of a companyβs software methods and results against those of other organizations, primarily to compare against industry norms.
π Example: The text provides an example where moving up from an SEI CMMI level 1 to a level 3 might be abstract, but the need to improve productivity rates from five function points per staff month to ten to reach industry norms is a fairly unambiguous goal driven by benchmark data.
Macroeconomic Benchmarks
Macroeconomic benchmarks are concerned with very large-scale issues such as the impact of computers and information technology on the economic health of nations and industries. These benchmarks are usually performed by national governments and sometimes by economists or universities.
Economic Benchmarks
Economic benchmarks are concerned with topics such as whether investments in computers, software, factory automation, or process improvement benefit the profitability and market shares of companies that spend more than others, a concept related to the productivity paradox. These are performed by economists, universities, and management consulting groups.
Corporate IT Benchmarks
Corporate information technology benchmarks deal with comparisons among companies on topics like the percent of corporate employees in IT, number of users supported per IT staff member, annual corporate spending for computer hardware, and revenues per IT employee. These benchmarks are produced by universities, consulting organizations, and sometimes by software journals.
Customer Satisfaction Benchmarks
Customer satisfaction benchmarks predate the computer era. In the context of software, customer satisfaction surveys for specific products are often carried out by the vendors themselves, while comparative benchmarks between classes of similar products require more extensive data.
Project-Level Benchmarks
Project-level benchmarks for software have been carried out since the 1970s. They require a great deal of care to ensure an βapples-to-applesβ comparison, but can generate very useful information.
Benchmark studies
Benchmark studies can be carried out in several ways, including:
- Blind studies in which none of the participating companies are identified.
- Hybrid studies with a mix of named and unnamed participants.
- Open studies in which all participants are aware of one another.
- Targeted studies between two specific companies.
- General studies between one company and industry averages.
These studies can be conducted using mailed/e-mailed survey instruments, telephone surveys, or on-site interviews.
Software Benchmark Analysis
The goal of a software benchmark analysis is to show clients exactly where they stand in the context of their own industry. A good benchmark should uncover information on why the results are the way they are and indicate some of the steps that might be needed to improve the clientβs standing.
π‘ Why this matters: The lecture states that benchmarks are even more effective than assessments in causing companies to start software process improvement programs because they present tangible data that executives can understand easily, such as a need to improve productivity rates to reach industry norms.
π Example: Accurate benchmarking was difficult for many years due to problems with the LOC software metric, which was unreliable for studies involving multiple programming languages. The advent of the function point metric has opened a door to more accurate benchmark studies.
Most FAQs
The most frequent questions in software benchmarking are related to best-in-class results, such as:
- What are best-in-class productivity rates in our industry?
- What are best-in-class development costs per function point?
- What are best-in-class quality levels?
The lecture emphasizes that for benchmarks to be useful, the projects being compared must be similar in size and nature; it is not a normal practice to compare unlike software applications, such as a small Web applet with a large military system.
Software Baselines
A baseline is a milestone in the development of software. While benchmarks compare a company against industry norms, baselines compare a company against its own history for several years in the past.
π Definition β Baseline: A starting point in a process improvement program that provides a firm quantitative basis for productivity, schedules, costs, quality, and user satisfaction to judge the rate of improvement.
π Example: The lecture explains that if a software organizationβs actual productivity is 5.0 FPs per staff month but their cost tracking system only captures low-level design, coding, and testing costs, their apparent productivity might look like 15.0 FPs per staff month. This makes initial baselines often very unrealistic due to leakage of costs (e.g., unpaid overtime, client work, omitted activities like requirements and project management).
β Key Takeaways
A student must remember that software benchmarks are formal comparisons against industry norms, used to identify best-in-class practices and gaps in performance, while software baselines are internal comparisons against an organizationβs own historical data to measure improvement over time. The key distinction is that benchmarks are external and baselines are internal. Benchmarks are highly effective for motivating process improvement because they provide tangible, quantitative data like productivity and quality rates, which are more compelling to executives than abstract maturity levels. A primary challenge in creating accurate baselines is the prevalence of "leakage" β the failure to track all costs and effort, such as unpaid overtime, client work, and activities outside core development, leading to unrealistic initial data. Finally, for any benchmark or baseline to be valid and useful, the data must be collected using a reliable metric like function points, and the projects and activities being compared must be similar in nature and scope to ensure an "apples-to-apples" comparison.
π§ Quick Revision Questions
- What is the primary difference between a software benchmark and a software baseline?
- What is "leakage" in the context of software baselines, and why does it make baselines challenging to create?
- Name at least three of the seven types of benchmarks discussed in the lecture (Macroeconomic, Economic, Corporate IT, Customer Satisfaction, Project-Level, Assessment Studies, Assessment vs. Benchmarks).
- What is the goal of a software benchmark analysis, and why is it more effective than assessments in motivating process improvement?
- What question does the "productivity paradox" address in the context of economic benchmarks?
π Lecture 31 β Agile Software Process
π Overview: This lecture introduces the philosophy and key principles of Agile software development, contrasting it with traditional plan-driven methods like the waterfall model. It explores the Agile Manifesto, various agile methods, and critically examines how agility can be applied to Software Process Improvement (SPI), arguing for a balanced, human-centric approach that is responsive to change.
ποΈ Topics Covered
The lecture covers the philosophy and development guidelines of Agile software engineering, listing key agile process models. It details the four values of the Agile Manifesto and its twelve underlying principles. The lecture then discusses the diversity among agile methods and their key messages for SPI. It applies agility to process improvement itself, reinterpreting agile principles for SPI, and concludes by presenting a model for an agile SPI method and the factors necessary for a successful SPI program.
π Lecture Summary
Agile Software Process
Agile software engineering combines a philosophy and a set of development guidelines. The philosophy encourages customer satisfaction, early incremental delivery, small motivated teams, informal methods, minimal work products, and overall simplicity. The guidelines stress delivery over analysis and design, and active communication. There are several agile process models, including Adaptive Software Development, Extreme Programming (XP), Feature-Driven Development, SCRUM, Agile Modeling, and Crystal. A key feature of these methods is that they accept change (in requirements and technology) and try to work with human nature. A consequence of this is creating less documentation, actively avoiding it for its own sake.
π Definition β Agile Software Engineering: A philosophy and set of development guidelines that prioritize customer satisfaction, early delivery, motivated teams, and simplicity, while actively embracing and managing change.
The Agile Manifesto
The Agile Manifesto states that the authors have come to value:
- Individuals and interactions over process and tools
- Working software over comprehensive documentation
- Customer collaboration over contract negotiation
- Responding to change over following a plan The manifesto explicitly notes that while there is value in the items on the right (process, documentation, contract, plan), they value the items on the left more.
Agile Principles
The Agile Manifesto is based on twelve principles. These include: highest priority is satisfying the customer through early and continuous delivery; welcoming changing requirements even late in development; delivering working software frequently (weeks to months); business people and developers working together daily; building projects around motivated individuals and trusting them; using face-to-face conversation as the most efficient method; having working software as the primary measure of progress; promoting sustainable development; continuous attention to technical excellence; simplicity (maximizing work not done); allowing the best designs to emerge from self-organizing teams; and having the team regularly reflect and adjust its behavior.
Agile Methods
Not all agile methods are the same; for example, XP focuses on design, coding, and testing, while Crystal focuses on scalability. In general, agile methods focus on overall approaches to programming, testing, documentation, planning, and team interaction rather than detailed procedures like configuration management. The key high-level messages are: don't assume the waterfall life cycle is the only approach; work with customers and users; accept and manage change; and don't be more rigorous than the situation demands. While agile methods emphasize process improvement, they are sometimes seen as the antithesis of capability maturity models like CMM/CMMI. However, the lecture argues that agile methods are entirely consistent with the process improvement requirements of ISO 9001:2000/2008.
π‘ Why this matters: This reconciles the apparent conflict between agile's flexible, people-focused approach and formal, model-based SPI standards, showing that they can coexist.
Agility Applied to Process Improvement
Agility can be applied to SPI activities themselves by adapting agile principles. For example: highest priority is to satisfy the user through early and continuous delivery of valuable productivity aids; software developers and process improvers must work closely; recognize motivated individuals; simplicity is essential; and teams should regularly reflect and adjust. Process improvement should be carried out in an agile, iterative manner. An "agile process improvement" approach may need to challenge the unyielding link between measurement and improvement, instead seeing quantitative data as a valuable bonus, not an absolute prerequisite. The lecture advocates for a practical, informed approach: if people believe something is needed, do it; if an approach looks good, try it; collect data cost-effectively if possible, but don't hold your breath; justify large expenditures rationally; and don't use this as an excuse to avoid methodical estimating.
A Model of an Agile SPI Method
An agile approach to SPI should be responsive, flexible, encourage innovation, build projects around motivated people, encourage self-organizing teams, and promote sustainable process development. A model of an agile SPI method conceptualizes the features needed to support this.
Factors in Ensuring a Successful SPI Program
Several factors are critical for a successful SPI program. Changes must align with business strategy and priorities. Commitment and investment must come from the top. SPI requires consensus and ownership from all stakeholders. Current processes must be understood. Change must be continuous. An improvement infrastructure is needed to manage changes. Results should be monitored. The philosophy must shift from process stability to being adaptive and flexible. The goal should be a successful product, not just following a predefined methodology. The primary means for adjusting the process is learning from practice, which requires encouraging innovation. The Software Engineering Process Group (SEPG) can be adapted to support this emergent view, acting as a facilitating group rather than the sole identifier of process areas, supporting through training and resources and acting as a research group for boundary scanning. Finally, good people can produce good work in an "immature" organization, but good processes without good people will achieve very little.
β Key Takeaways
The Agile Manifesto prioritizes individuals, working software, customer collaboration, and responding to change over rigid processes, documentation, contracts, and plans. These values are supported by twelve principles that emphasize early delivery, welcoming change, motivated teams, face-to-face communication, and simplicity. Agility can and should be applied to Software Process Improvement itself, advocating for an iterative, people-centric, and pragmatic approach where quantitative data is a bonus, not a prerequisite. The success of an agile SPI program depends on alignment with business strategy, top-down commitment, stakeholder ownership, continuous learning from practice, and a supportive infrastructure, with the SEPG acting as a facilitator. Ultimately, good people are more critical to success than good processes alone.
π§ Quick Revision Questions
- What are the four values of the Agile Manifesto?
- List three of the twelve Agile Principles.
- How does the lecture reconcile agile methods with formal process improvement models like CMMI and ISO 9001?
- What does it mean to "challenge the inexorable link between measurement and process improvement"?
- What are two key factors for ensuring a successful SPI program according to this lecture?
π Lecture 32 β Process Patterns
π Overview: This lecture introduces the concept of process patterns as reusable building blocks for tailoring a mature software process. It explains the three types of process patternsβtask, stage, and phaseβand provides detailed examples of each, including the Technical Review task pattern, Program stage pattern, and Construct phase pattern. The lecture emphasizes how these proven approaches help organizations improve software quality, maintainability, and extensibility while avoiding ineffective anti-patterns.
ποΈ Topics Covered
The lecture begins by defining the core concepts of process and patterns, then explains process patterns as collections of general techniques for developing software. It categorizes process patterns into three types: task process patterns (detailed steps for specific tasks), stage process patterns (iterative steps for a project stage), and phase process patterns (interactions between stage patterns). The lecture covers a standard format for documenting process patterns (Name, Forces, Initial Context, Solution, Resulting Context, Related Patterns, Known Uses) and provides concrete examples: the Technical Review task pattern, the Program stage pattern, and the Construct phase pattern. Finally, it introduces process anti-patterns and discusses the Object-Oriented Software Process (OOSP) framework.
π Lecture Summary
Process
A series of actions in which one or more inputs are used to produce one or more outputs.
π Definition β Process: A series of actions where inputs produce outputs.
Patterns
A general solution to a common (recurring) problem or issue, one from which a specific solution may be derived. Patterns can exist at all scales, as noted by Christopher Alexander.
Process Patterns
A process pattern is a collection of general techniques, actions, and/or tasks (activities) for developing software. A process pattern describes what you should do but not the exact details of how you should do something. When applied together in an organized manner, process patterns can be used to construct a software process for your organization. Since process patterns do not specify how to perform a given task, they can be used as reusable building blocks from which you may tailor a software process that meets the specific needs of your organization.
Software development patterns come in many flavors, including analysis patterns, design patterns, organizational patterns, and process patterns. A process pattern describes a proven, successful approach and/or series of actions for developing software. It can be argued that process patterns and organizational patterns go hand in hand. Organizational patterns describe common management techniques or organizational structures and describe proven, successful approaches for organizing and managing people involved with the software process.
An important feature of process patterns is that it is possible to develop them for all aspects of development. The scope of a single process pattern may range from a high-level view of how applications are developed to a more-detailed view of a specific portion of the software process.
There are at least three types of process patterns:
- Task process patterns: Depict the detailed steps to perform a specific task, such as the Technical Review and Reuse First process patterns.
- Stage process patterns: Depict the steps, which are often performed iteratively, of a single project stage. A project stage is a higher-level form of process pattern, one that is often composed of several task process patterns. A stage process pattern is presented for each project stage such as the Program and Rework stages.
- Phase process patterns: Depict the interactions between the stage process patterns for a single project phase, such as Initiate and Delivery phases. A phase process pattern is a collection of two or more stage process patterns. Project phases are performed in a serial manner; phase process patterns are performed in serial order, made up of stage process patterns which are performed iteratively.
π Definition β Process Pattern: A collection of general techniques, actions, and/or tasks (activities) for developing software that describes what to do but not exactly how to do it.
π Definition β Task Process Pattern: A process pattern that depicts the detailed steps to perform a specific task.
π Definition β Stage Process Pattern: A process pattern that depicts the iterative steps of a single project stage, often composed of several task process patterns.
π Definition β Phase Process Pattern: A process pattern that depicts the interactions between stage process patterns for a single project phase, performed in serial order.
Documenting Process Patterns
We can combine the existing work in process patterns with that of the existing process improvement community. The implication is the need for a format/template that both communities understand and agree to.
Process Patterns Format
- Name: Provide a concise, strong name for the pattern, such as Program or Reuse First.
- Forces: Applicable forces motivating the process pattern.
- Initial context/Entry conditions: Indicate the situation to which the pattern solution applies, and if applicable the entry conditions that must be true before the process may begin.
- Solution: Describe in detail how to perform the steps/activities of the process pattern. You may also choose, particularly for phase and stage process patterns, to describe management, quality assurance, and risk management issues, as well as indicate potential metrics to collect when working the process.
- Resulting context/Exit conditions: Indicate the situation/context which will result from performing the process pattern solution, including if applicable the conditions that must be true for the process to be considered complete.
- Related Patterns: Indicate other patterns that this pattern is composed of, is a part of, or is associated to.
- Known Uses/Examples: Indicate where/how the process pattern has been applied in use. For example, the Technical Review task process pattern can be applied to the management of peer reviews, code reviews, model reviews, and management reviews.
π‘ Why this matters: The structured format ensures consistency and clarity when documenting process patterns, making them easier to understand, reuse, and adapt across different projects and organizations.
Example of a Task Process Pattern: Technical Review
The Technical Review task process pattern describes how to organize, conduct, and follow through on the review of one or more deliverables.
Forces:
- First, the deliverables (models, prototypes, documents, source code, etc.) produced during the development process help to define the software and related products to be released to your user community, therefore you should validate that each deliverable is of sufficient quality before building on it.
- Second, because the cost of fixing defects increases the later they are detected in the development life cycle as a result of the error snowballing throughout your work, you want to detect defects as early as possible so you may fix them early (and inexpensively).
- Third, because it is difficult to review your own work you want "a second set of eyes" to review a deliverable.
- Fourth, you want to communicate your work to others, and one way to do that is to have your teammates review the deliverables that you produce.
Initial Context: There are one or more deliverables to be reviewed, the deliverables are ready to be reviewed, and the development team is ready to have the deliverables reviewed.
Solution: There are six basic steps to technical reviews process pattern (model reviews, document reviews, prototype reviews, requirement reviews, and code inspections are all specific processes that follow the Technical Review process pattern).
- Prepare for review: The item(s) that are to be reviewed are gathered, organized appropriately, and packaged so that they may be presented to the reviewers.
- Indicate readiness for review: The development team must inform the review manager, often a member of quality assurance, when they are ready to have their work reviewed as well as what they intend to have reviewed.
- Perform cursory inspection: The first thing that the review manager must do is determine if the development team has produced work that is ready to be reviewed. The manager will probably discuss the development team's work with the team leader and do a quick rundown of what they have produced. The main goal is to ensure that the work to be reviewed is good enough to warrant getting a review team together.
- Organize review: The review manager must schedule a review room and any equipment needed for the review, invite the proper people, and distribute any materials ahead of time that are needed for the review.
- Hold review: Technical reviews should take about two hours so as not to overwhelm the people involved. The entire development team should attend, or at least the people responsible for what is being reviewed, to answer questions and to explain/clarify their work. There are typically between three to five reviewers, as well as the review manager, all of whom are responsible for doing the review. It is important that all material is reviewed. It is too easy to look at something quickly and assume that it is right. It is the job of the review facilitator to ensure that everything is looked at, that everything is questioned.
- Act on review results: A document is produced during the review describing both the strengths and weaknesses of the work being reviewed. This document should provide both a description of any weakness, why it is a weakness, and provide an indication of what needs to be addressed to fix the weakness. This document will be given to the development team so that they can act on it, and to the review manager to be used in follow-up reviews in which the work is inspected again to verify that the weaknesses were addressed.
π Definition β Error Snowballing: The phenomenon where the cost of fixing defects increases the later they are detected in the development life cycle.
π Definition β Review Facilitator: The person whose job is to ensure that all material is looked at and questioned during a technical review.
Resulting Context:
- Senior management is assured that the development team has produced quality deliverables that meet the needs of their user community.
- The development team, and the reviewers, have a better understanding of the deliverables that they are building and how their work fits into the overall software project.
- Individual team members and reviewers are likely to learn new techniques during the review, either techniques applied to the deliverable itself, management techniques applied during the review, or development techniques suggested during the review to improve the deliverable.
π Example: The Technical Review task process pattern can be applied to model reviews, document reviews, prototype reviews, requirement reviews, and code inspections.
Example of a Stage Process Pattern: Program
An important aspect of software development is the actual development of the source code. As experienced developers know, there is far more to programming than just sitting down at a computer and typing in source code. The Program stage process pattern describes the iterative tasks/activities of programming.
Forces:
- Programmers need to develop software that meets the needs of their user communities, needs that have been reflected in the form of models and documents developed during the Model stage and the Define and Validate Initial Requirements stage.
- The developed source code should reflect the information contained in these deliverables, yet at the same time may drive changes to them as programmers gain a detailed understanding of the domain.
- Furthermore, most organizations want software to be developed in a timely and efficient manner but at the same time want it to be maintainable and extensible so that changes in the future may be made efficiently and quickly.
Initial Context/Entry Conditions: Several conditions must be met before coding may begin:
- First, your design models should be in place for the code that you intend to write.
- Second, your project infrastructure should be in place, defined during the Define Infrastructure stage of the Initiate phase. The infrastructure includes the development and supporting tools that your programmers will use as well as the standards and guidelines that they will follow.
- Third, programmers must be available to do the work.
Solution: The Program process pattern shows that there is more to this stage than simply writing source code: you need to understand the models, then seek out reusable artifacts to reduce your work load, then document what you are going to write, then write the code, then inspect and improve it, then test and fix it, and then finally package it.
Resulting Context/Exit Conditions:
- First, your code should have passed inspection.
- Second, the code should work (it passed testing).
- Third, the code should have been optimized sufficiently.
- Fourth, if applicable the software should be integrated and packaged for delivery.
Example of a Phase Process Pattern: Construct Phase
The main goal of the Construct phase is to build working software that is ready to be tested and delivered to your user community. This software will be accompanied by the models and source code that was used to develop it, a test plan to verify that the software works, any reusable artifacts that can be used on future projects, and the initial documentation and training plans supporting the software.
Forces: There are several forces applicable to the Construct Phase, including a lack of understanding of how to work the phase by both senior management and by developers; an unwarranted focus on programming to the neglect of modeling, testing, and generalization; and a penchant by everyone involved to cut corners and take shortcuts that more often than not result in poor quality software that is late and over budget anyway.
Initial Context/Existing Conditions: The Construct phase can be entered two different ways, either from the Initiate phase or from the Maintain and Support phase. Regardless, there are several conditions that must be met before the Construct phase may begin:
- First, the key project management documents (project plan, estimate, schedule, risk assessment, etc.) should be available and up-to-date.
- Second, the project infrastructure should be defined, or at least a good portion of it is defined, so that the tools, processes, and standards are available to your development team.
- Third, the high-level requirements for your software should be in place as well as the project charter for your team.
- Fourth, maintenance changes applicable to the software you are constructing should be allocated to the release that you are working on (this is applicable only for existing software that is being updated).
- Finally, your development team should be selected and made available (as best as possible) for when they are needed by your project.
Solution: An important point is that you are not starting from scratch when you enter the Construct phaseβimportant management documents such as the project plan and initial risk assessment have been defined, the initial requirements for your application should have been defined, the project infrastructure is (mostly) defined, and the funding and charter for the project have been obtained.
The four iterative stages of the Construct phase are highly interrelated:
- The Model stage concentrates on the abstraction of the technical and/or problem domain via the use of diagrams, documents, and prototypes.
- The Program stage focuses on the development and documentation of program source code.
- The Generalize stage is critical to your organization's reuse efforts as it focuses on identifying reusable items, or items that may become reusable once modified, from a software project. This is effectively "opportunistic reuse" because you attempt to develop reusable items by harvesting your work after the fact, instead of "systematic reuse" in which you design software during modeling to be reusable.
- The goal of the Test In The Small stage is to verify and validate the deliverables developed by the other stages of the Construct Phase. In many ways this stage is the equivalent of unit testing from the structured world combined with quality assurance techniques such as code inspections and technical reviews.
π Definition β Opportunistic Reuse: Developing reusable items by harvesting work after the fact, instead of designing specifically for reuse.
π Definition β Systematic Reuse: Designing software during modeling to be reusable from the start.
Resulting Context/Exit Conditions: The Construct phase effectively ends when a code/development freeze has been declared. For a code/development freeze to be official, the following deliverables must be in place (when applicable): Models (Class Model, Use-Case Model, Sequence Diagrams, etc.), Requirements Allocation Matrix (RAM), Source code, Master Test/QA Plan, User Documentation, Operations Documentation, Support Documentation, the software itself, Training Plan, Release Plan, and Lessons Learned. At this point your software is ready to move on to the Deliver phase where it will be tested in the large, reworked as needed, and released to your user community.
π Definition β Code/Development Freeze: The point where development stops, and deliverables must be in place before moving to the Deliver phase.
Why Process Patterns?
- They are an excellent mechanism for communicating approaches to software development that have proven to be effective in practice.
- They are reusable building blocks from which an organization may tailor a mature software process.
The Object-Oriented Software Process (OOSP)
There are four project phases within the OOSP β Initiate, Construct, Deliver, and Maintain and Support β each of which is described by a phase process pattern. There are 14 project stages in the OOSP β Justify, Define and Validate Initial Requirements, Define Initial Management Documents, Define Infrastructure, Model, Program, Test In The Small, Generalize, Test In The Large, Rework, Release, Assess, Support, and Identify Defects and Enhancements β each of which is described by a stage process pattern. Project stages are performed in an iterative manner within the scope of a single project phase. Project phases, on the other hand, are performed in a serial manner within the OOSP.
Process patterns are a key enabler for tailoring/defining a mature software process for your organization. The reality of process improvement, however, is that you cannot make all of the changes that you want to immediately; it is simply too great a change for your organization to absorb at once. Software process improvement promoters suggest that you prioritize the process improvements that your organization needs to make, expect that it will take several years to make the needed changes, and expect that you will experience difficulties while doing so. Experience shows that organizations that try to make immediate, large-scale process changes are likely to fail doing so.
Process Anti-Patterns
Process anti-patterns are approaches to software development that are proven to be ineffective in practice, such as hacking.
π Definition β Process Anti-Pattern: Approaches to software development that are proven to be ineffective in practice.
β Key Takeaways
Process patterns are reusable building blocks that describe proven, successful approaches to software development without specifying exact implementation details, allowing organizations to tailor a mature process to their specific needs. There are three types of process patternsβtask patterns (detailed steps for specific tasks like technical reviews), stage patterns (iterative steps for a project stage like programming), and phase patterns (serial interactions between stages like the Construct phase). Each process pattern is documented using a standard format including Name, Forces, Initial Context, Solution, Resulting Context, Related Patterns, and Known Uses. The Technical Review task pattern exemplifies how to conduct reviews with six basic steps, while the Program stage pattern and Construct phase pattern show how larger processes are composed of smaller, iterative patterns. Finally, process anti-patterns (like hacking) represent proven ineffective approaches that should be avoided, and process improvement must be done incrementally rather than through large-scale changes.
π§ Quick Revision Questions
- What are the three types of process patterns, and how do they differ in scope and what they describe?
- List the six components of the standard process pattern documentation format and briefly explain what each component contains.
- What are the six basic steps of the Technical Review task process pattern, and what is the role of the review facilitator?
- What are the four entry conditions that must be met before the Program stage process pattern can begin?
- What is the difference between "opportunistic reuse" and "systematic reuse" as described in the Generalize stage of the Construct phase?