π Lecture 43 β Process Metrics
π Overview: This lecture focuses on process metrics, which are used to improve software development and maintenance processes. It explains how to define, collect, store, and analyze data for measuring software quality, defects, and process effectiveness, emphasizing the importance of consistent terminology and well-planned data collection.
ποΈ Topics Covered
The lecture begins by discussing the difference between direct and indirect measures and the importance of GQM analysis for defining what to measure. It then covers software quality terminology, including faults, failures, and errors, followed by guidelines on how and when to collect data, and how to store and extract it using a DBMS. The main focus is on process metrics such as defect density, defect arrival rate, test effectiveness, defects by phase, defect removal effectiveness, and metrics for software maintenance.
π Lecture Summary
Back to defining data for collection
Deciding what to measure is the first step. We must specify which direct measures are needed and which indirect measures may be derived from them. Sometimes, from a GQM analysis, we determine the indirect measures we want and then work backward to find the required direct measures. Most organizations differ in business goals, cultures, and staff skills, so a GQM analysis may result in different metrics at different companies. This is why GQM is preferable to adopting a "one-size-fits-all" standard measurement set. Nevertheless, most organizations share similar interests in software quality, cost, and schedule, so most developers collect metrics about these aspects.
π‘ Why this matters: Understanding that metrics must be tailored to specific organizational goals through GQM prevents collecting irrelevant or misleading data.
The problem with problems
No software developer consistently produces perfect software the first time. It is important to measure different aspects of software quality to determine: how many problems have been found with a product; how effective are the prevention, detection, and removal processes; whether the product is ready for release; and how the current version compares in quality with previous or competing versions.
Software Quality Terminology
A fault occurs when a human error results in a mistake in some software product. The fault is the encoding of the human error. A failure is the departure of a system from its required behavior. Failures can be discovered both before and after system delivery. We need to use and understand terminology consistently, clearly defining terms like faults, errors, processing errors, anomalies, defects, bugs, failures, and crashes. We also need a clear way of describing what we do in reaction to problems. For example, if an investigation of a failure results in the detection of a fault, then we make a change (or changes) to the product to remove it. Whenever a problem is observed, we want to record its key elements: location, timing, symptom, end result, mechanism, cause, severity, and cost.
π Definition β Fault: a mistake in some software product resulting from a human error. π Definition β Failure: the departure of a system from its required behavior.
How to Collect Data?
Since software development is an intellectual activity, data collection requires human observation and reporting. Managers, analysts, programmers, testers, and users must record raw data on forms, which is subject to bias, error, omission, and delay. Automatic data capture is desirable, especially for recording execution time, but often there is no alternative to manual collection. To ensure data accuracy and completeness, we must plan our collection effort. Ideally, we should: keep procedures simple; avoid unnecessary recording; train staff; provide prompt and useful results feedback; and validate all data at a central collection point. The last point is critical, as studies show half the data collected can be corrupted.
Planning for data collection involves several steps. First, decide which products to measure based on your GQM analysis. The GQM analysis suggests which attributes and measures to evaluate. Once committed, you must decide exactly which attributes to measure and how indirect measures will be derived. Direct and indirect measures may be related by a measurement model. Once the set of metrics is clear, you must devise a scheme for identifying each entity (products, versions, failures, faults). This enables you to proceed to form design. Finally, establish procedures for handling forms, analyzing data, and reporting results. Define who fills in what, when, and where, and set up a central collection point. If no one person has responsibility for a given step, the data collection process will stop.
When to Collect Data
Data-collection planning must begin when project planning begins. Actual data collection takes place during many phases of development. Some data are collected at the start of the project, while other data collection is done later. Data about faults found by inspections and tests should be recorded consistently to determine the relative effectiveness of these activities. It is essential that data-collection activities become part of the regular development process. It is helpful to compare a model of the normal development process with a list of desired measurements and map measurements directly to the process model. If something needs to be measured and there is no obvious place to collect the data, the process can be modified to enable measurement.
How to Store and Extract Data
Raw software-engineering data should be stored on a database. A DBMS (Database Management System) is an automated tool for organizing, storing, and retrieving data, and it has many advantages over manual record-keeping.
Process Metrics
Process metrics are those that can be used for improving the software development and maintenance processes. Examples include the effectiveness of defect removal during development, the pattern of testing defect arrival, and the response time of the fix process. Compared to end-product quality metrics, process quality metrics are less formally defined, and their practices vary greatly among software developers.
Defect density
Defect density never follows a uniform distribution. It is an indication of defect injection in code or other software products. If a piece of code has higher testing defects, it could be due to more effective testing or higher latent defects. Defects per KLOC (thousand lines of code) or another denominator is a simple metric that is a good indicator of quality while the software is still under testing. It is especially useful for monitoring subsequent releases of the same product within the same organization, as release-to-release comparisons are not contaminated by extraneous factors.
π Definition β Defect density: the number of defects found per unit size (e.g., per KLOC) of a software product.
Defect arrival rate
The defect arrival rate is the number of defects found during testing measured at regular intervals over some period of time. A set of values is associated with this metric. When plotted on a graph, the data may rise (positive arrival rate), stay flat (constant rate), or decrease (negative arrival rate). Interpretation can be difficult. A negative rate might indicate the product is improving, but you must eliminate other possible causes, such as test effectiveness declining over time, or the test organization being understaffed.
π Formula: Defect arrival rate = Number of defects found during a specific time interval.
Test effectiveness
Test effectiveness measures how effective formal tests are at finding defects. It is calculated by dividing the number of defects found by formal tests (Dn) by the total number of formal tests (Tn). When calculated at regular intervals and plotted, test effectiveness can be observed over time. A rising graph may indicate improving test effectiveness, while a falling graph may indicate waning effectiveness.
π Formula: TE = Dn / Tn β Test effectiveness equals the number of defects found by formal tests divided by the total number of formal tests.
Defects by phase
The defects by phase metric is a variation of the defect arrival rate metric. At the conclusion of each discrete phase of the development process, a count of new defects is taken and plotted to observe a trend. It is much less expensive to eliminate defects early. If the graph is rising, it suggests that defect detection and removal methods in earlier phases are not effective. If the graph is falling, early defect detection and removal is effective. This can demonstrate the snowball effect, where defects found early prevent many more from being introduced later.
Defect removal effectiveness
Defect removal effectiveness (DRE) can be calculated by dividing the number of defects removed prior to release (Dr) by the sum of defects removed prior to release and the total number of defects that remain in the product at release (Dt). When multiplied by 100, this value can be expressed as a percentage.
π Formula: DRE = Dr / (Dr + Dt) β Defect removal effectiveness equals defects removed before release divided by the total defects before release (removed + remaining).
Metrics for Software Maintenance Process
When a software product is released, it enters the maintenance phase. During this phase, the defect arrivals by time interval and customer problem calls by time interval (which may or may not be defects) are the de facto metrics.
β Key Takeaways
The most critical points from this lecture are: first, data collection must be carefully planned using GQM analysis to align metrics with organizational goals, and all data must be validated at a central point to avoid corruption. Second, consistent terminology (e.g., fault vs. failure) is essential for accurate measurement and communication across the organization. Third, key process metrics include defect density, defect arrival rate, test effectiveness, defects by phase, and defect removal effectiveness, each providing different insights into quality and process efficiency. Fourth, data collection should be integrated into the regular development process, with measurements mapped directly to process activities. Finally, removing defects early in the lifecycle is significantly more cost-effective, and metrics like defects by phase and DRE help evaluate this effectiveness.
π§ Quick Revision Questions
- What is the difference between a direct measure and an indirect measure in software measurement?
- Why is it important to validate all data at a central collection point, and what problem does this address?
- What does a rising defect arrival rate graph potentially indicate about test effectiveness or product quality?
- How is Defect Removal Effectiveness (DRE) calculated, and what does a high DRE percentage signify?
- Why is it more valuable to use defects by phase metric rather than just a total defect count at the end of a project?
π Lecture 44 β Software Process Improvement: Your Mileage May Vary
π Overview: This lecture explores the critical metrics used in software maintenance to track defects and fix quality, then transitions to the strategic application of these metrics. It emphasizes the importance of distinguishing between private and public data to avoid using metrics punitively against individuals. Finally, it introduces the concept that every organizationβs process improvement journey is unique, encapsulated in the idea that "your mileage may vary."
ποΈ Topics Covered
The lecture covers key metrics in software maintenance, including defect backlog, backlog management index (BMI), fix response time, percent delinquent fixes, and defective fixes. It then discusses the strategic application of software metrics through sensitive usage of data, process improvement via defect analysis, and validation of best practices. A major focus is on the distinction between private and public data, and the roles of functional management, project management, and the project team in handling metrics. The lecture concludes with the βDefect Cubeβ for dissecting defects and the spiral model for process improvement adoption.
π Lecture Summary
Metrics in Software Maintenance
The lecture begins by stating that while the number of problem arrivals is largely determined by the development process before maintenance, what can be done during maintenance is to fix defects quickly and with excellent quality. This can improve customer satisfaction even if it doesn't improve the product's defect rate.
Key metrics in this phase include:
-
Defect backlog: A count of the number of defects in the product following its release that require a repair. It is usually measured at regular intervals for trend analysis. By itself, it provides little useful information (e.g., what does a count of 128 tell you?). A more useful representation is by defect severity.
-
Backlog management index (BMI): This metric tracks whether a team is gaining or losing ground on the defect backlog. If new defects exceed closed defects, the team is losing ground; if they close more than arrive, they are gaining ground.
π Definition β Backlog Management Index (BMI): Calculated by dividing the number of defects closed during some period (Dc) by the number of new defects that arrived during that same period (Dn).
π Formula: BMI = Dc / Dn
β Plain-English meaning: If the result is greater than 1, your team is closing defects faster than new ones are arriving, meaning they are "gaining ground."
π Example: If a team closes 30 defects in a week but 20 new defects arrive, the BMI is 30/20 = 1.5. This indicates the team is gaining ground on the backlog.
-
Fix response time: The average time it takes a team to fix a defect. It can be measured as elapsed time from discovery to unverified fix or from discovery to verified fix. A better alternative is to measure fix response time by severity.
-
Percent delinquent fixes: A fix is delinquent if it exceeds your established fix response time criteria (e.g., a 48-hour maximum).
π Definition β Percent Delinquent Fixes (PDF): The percentage of fixes that exceed the established fix response time criteria.
π Formula: PDF = (Fd / Fn) * 100
β Plain-English meaning: The number of delinquent fixes (Fd) divided by the number of non-delinquent fixes (Fn), multiplied by 100.
π Example: If a team has 5 delinquent fixes and 20 non-delinquent fixes in a month, the PDF is (5/20) * 100 = 25%.
- Defective fixes: A fix that is later found to be defective or creates additional problems. This metric (also known as fix quality) requires tracking reopened defects and new defects caused by a fix.
Strategic Application of Software Metrics
This section covers the sensitive and strategic use of metrics data for process improvement.
- Sensitive usage of metrics data: Use the concept of public and private data to drive decisions on how to collect and analyze data.
- Process improvement through defect analysis: Analyze defects to improve processes, not to blame people.
- Validation of best practices.
Private Data
Individuals prefer to keep defect data private. The goal is to analyze defects to improve processes. Private data becomes public at well-defined handoffs or transitions, introducing accountability.
- Inspections: Inspections are such transitions. If properly run, defects found here are less embarrassing than those found later. At this point, data is no longer private, and the focus of accountability shifts from the individual to the team.
- Project's Private Data: Includes time data. The principle of "Information Hiding" is applied during project review.
Public Data
Metrics for public data include calendar times, defect rates, project costs, and measure of functionality.
The lecture provides a detailed table showing the flow of data from private to public:
| Private (to individual) | Private (to project team) | Public (to team members) | Public (to company) |
|---|---|---|---|
| Defect rates (by individual) | Defect rates (by module) | Defect rates (under development) | Defect rates (by project) |
| Number of compiles | Defect rates (beyond individual) | Estimated NCSS/module | NCSS (by product) |
| NCSS/module | Number of re-inspections | Effort (by project) | |
| Defects/modules (pre-release) | Calendar times | ||
| Defects/module (post-release) | |||
| Effort/defect (average) |
π‘ Why this matters: A key lesson is to apply your best management sensitivity to interpretation and use; never use metrics to measure individuals.
Functional Management
- Don't allow anyone to use metrics to measure individuals.
- Set clear goals and let staff help define metrics for success.
- Understand the data your people take pride in reporting; never use it against them, not even hint at it.
- Don't emphasize one metric to the exclusion of others.
- Support your people when their reports are backed by useful data.
Project Management
- Don't try to measure individuals.
- Gain agreement with your team on metrics to track and define them in a project plan.
- Provide regular feedback to the team about the data they help collect.
- Know the strategic focus of your organization and emphasize supporting metrics.
Project Team
- Do your best to report accurate, timely data.
- Help managers focus project data on improving processes.
- Don't use metrics data to brag, or you will encourage others to show the opposite.
- Use software failure analysis to drive process improvement decisions and measure their impact.
Dissecting Software Defects
Defects are viewed from three perspectives: the customer's view, the development engineer's view, and the support engineer's view. This is illustrated by the Defect Cube.
Key Questions to Learn from Mistakes
- What development or maintenance process failed?
- How often do such failures occur?
- How expensive is it to fix such failures?
- Which components are most subject to failures?
- What process change will detect or eliminate these failures?
All software process changes must be evaluated in terms of measurable ROI.
Spiral Model for Process-Improvement Adoption
The lecture introduces the concept that βyour mileage may varyβ for process improvement. βMileageβ here refers to βsuccess rate.β The spiral model shows that software process improvement is an unending journey. While each improvement can be a tactical project, you must follow through with others to remain competitive. If unwrapped into a linear model, it shows a continuous cycle.
β Key Takeaways
The most critical concepts for a student to remember are the distinction between private and public data and the ethical imperative to never use metrics to evaluate individuals. Key formulas to memorize are the Backlog Management Index (BMI = Dc / Dn) and Percent Delinquent Fixes (PDF = (Fd / Fn) * 100) , as they provide concrete ways to measure maintenance team performance. For strategic use, the βDefect Cubeβ highlights that defects have different meanings for customers, developers, and support engineers, and analyzing failures is for process improvement, not blame. Finally, remember that process improvement is an unending journey, and every organizationβs success rate ("mileage") will vary.
π§ Quick Revision Questions
- What is the formula for the Backlog Management Index (BMI), and what does a value greater than 1 signify?
- What is the primary difference between βprivate dataβ for an individual and βpublic dataβ for a project team, according to the lecture?
- How is a βdelinquent fixβ defined, and what is the formula for calculating the βPercent Delinquent Fixesβ?
- According to the lecture, what is the single most important rule for Functional Management regarding the use of metrics?
- What does the phrase "your mileage may vary" mean in the context of software process improvement?
π Lecture 45 β The Software-Improvement Journey
π Overview: This lecture provides a comprehensive review of the software-improvement journey, covering how organizations move from their current state toward a desired future state while navigating roadblocks. It also introduces Team Software Process (TSP) as a key methodology for forming high-performance software engineering teams, and discusses the fundamental role of measurement in software engineering.
ποΈ Topics Covered
The lecture covers the software-improvement journey model with eleven strategies for improving "mileage" (success probability and speed), including understanding business needs, current state assessment, cost analysis, organizational readiness, force-field analysis, and resistance to change. It then transitions to a comprehensive review of software problems (technical vs. systemic), software processes, and an in-depth introduction to TSP including team definition, team structure paradigms, high-performance teams, toxic environments, TSP principles, teambuilding, the launch process, and the importance of software measurement.
π Lecture Summary
The Software-Improvement Journey
We start moving toward a desired future state from a current state. Almost always, we encounter roadblocks, but gradually we move ahead with solutions. An intermediate state represents an acknowledged success. We do not stop here; the dots represent other projects or later progressions from current to intermediate states for other spiral loops.
Define Process Improvement in Terms of the Strategic Future
Your starting point is very important, which is where you want to go. It represents your organization's strategic future, so the first way to improve your mileage (chances for, and speed of, success) is to define that clearly. The most succinct definition of a future desired state is a vision.
Improving Mileage #1
- Understand Business Needs Well: A process that adds structure and commitment to your organization's vision is the core-competence planning process. Its major contribution is that it elevates process-improvement thinking to a strategic level. It also expands top management's competitive view from a traditional product focus to include key abilities the organization needs to create those products. Ideally, the core-competence planning process is as strong as your business-planning process. Just as business planning isn't always ideal, core-competence planning isn't either. Think of core-competence planning as a spiral process also.
- Get a Clear Picture of Your Current State: Once you have a good picture of your desired future, there are three key methods by which to gain a similar understanding of your current state.
Improving Mileage #2
Understand Your Software Development Costs and Their Leverage Points: The software-improvement investment model gives you a simple way to model major development, rework, and knowledge recovery costs. It helps to: give your management a better understanding of how software developers work, change people's opinions of the relative importance of proposed improvements, and set realistic expectations for proposed cost savings. You get an even better picture of improvement opportunities when you also analyze your major defect sources. This information is especially powerful when you combine it with the investment-model information. It further clarifies costs, gives you an excellent way to evaluate the potential of proposed improvements, and gives you an effective way to track and communicate the successful changes that you make.
Improving Mileage #3
- Understand Your Organization's Readiness for Change: One way to get a clear picture of your current state is to do an assessment that is well matched to your organization's needs. Pick an assessment approach that matches your business needs, level of sponsorship, scope of needed change, and your best guess of organizational readiness. An assessment does three key things: gives you a reference point of current strengths and opportunities, motivates people to change, and models how to approach improvements. It isn't easy to get a clear picture of an organization's readiness for change; assessments help us in this regard.
- Avoid and Minimize Potential Roadblocks: Process-improvement projects face complex sociological issues not normally faced in product projects. Extra analysis and planning can go a long way in helping to avoid roadblocks.
Improving Mileage #4
Understand Your Business and Organizational Forces: A force-field analysis of management commitment gives you the best snapshot of potential varying "mileage." The force-field analysis helps you steer towards simple risk-minimizing strategies.
Improving Mileage #5
Understand the Origins of Resistance to Change: People develop reasonable beliefs based on experiences. Proposed changes can be dissimilar enough to their past experiences that when they try to draw analogies, the analogies won't reflect probable outcomes. One way to avoid being judgmental about such derived beliefs is to think of their resistance as a "standard reason" not to do things. This can help you open your viewpoint so you can think about both your and their ladders of inference. Resulting discussions will help you to create ways to remove roadblocks.
Improving Mileage #6
Strengthen Plans: More complex projects require better planning and risk management, and even the simplest process improvement isn't easy. Thus, you especially need to plan to motivate people and to optimize their working environment. Process improvements also more fully use the PDCA cycle. This requires activities that many team members aren't experienced with. These added risks mandate at least a minimal, written, process-improvement plan.
Improving Mileage #7
Communicate Solutions to Maximize Success: You will need to effectively describe your project and its benefits often. A good approach is to imagine its completion early and create a storyboard that envisions how that will appear. This is a powerful way to describe your project clearly as part of the organization's future desired state. Another useful tool that ensures strong ties to business goals is the goal/question/metric (GQM) process. These ties lead to more easily accepted communications.
Improving Mileage #8
Set Reasonable Expectations for Results: The first part of setting reasonable improvement expectations is to calculate cost savings. This is a double-edged sword. If you don't do these estimates or if the way you communicate them makes them seem low, your project is unlikely to be approved. If you estimate too high, your project may be cancelled because you aren't believed. Also, if your estimates are high and you are allowed to finish, your project may still be considered a failure. Doing a cost-savings analysis early in your planning forces you to document assumptions. This analysis enables you to make your intermediate steps and improvement gains clearer. These will generally be both believable and high enough.
Improving Mileage #9
Frame Expectations for Different Audiences: A key step in gaining and holding project sponsorship is to translate your cost savings into benefits.
Improving Mileage #10
Reinforce Success with Measured Results: There is nothing like quantified intermediate results to eliminate doubts and solidify support. By imagining how your results will look during your initial planning/storyboarding, you will ensure that you collect the right data to report successes confidently.
Your Improvement Future
The spiral model emphasizes looking toward a future desired state. As we continue to mature software engineering, improvement techniques will get even better, and we will understand our sociology better.
Review from Mid-Term to Final β Software Problems
- Technical: Need a technical solution; easy to understand and solve.
- Systemic: Need a process/management solution; difficult to understand and solve.
Solution to Software Problems
Treat the software task as a process that can be controlled, measured, and improved. Relate the required tasks, tools, methods with skill, training, and motivation of people involved.
Software Processes
Software engineering, as a discipline, has many processes. These processes help in performing different software engineering activities in an organized manner. The software process is the set of tools, methods, and practices that people use to produce (develop and maintain) software and associated products (e.g., project plans, design documents, code, test cases, and user manuals). Characteristics of software processes include: requires creativity, interactions between a wide range of different people, engineering judgment, background knowledge, and experience.
Introduction to TSP β Why Projects Fail
Projects seldom fail due to technical reasons; most reasons involve people problems and excessive schedule pressure. People problems can be solved with the help of good communication and good teams. Good teams guide in handling pressure. Development of Team Software Process (TSP) is another important step in software process improvement, after the development of CMM and PSP. The TSP provides a disciplined context for engineering work. The principal motivator for the development of the TSP was the conviction that engineering teams can do extraordinary work, but only if they are properly formed, suitably trained, staffed with skilled members, and effectively led. The objective of the TSP is to build and guide such teams. A team is more than just a group of people who happen to work together. Teamwork takes practice and it involves special skills. Teams require common processes, agreed upon goals, and effective guidance and leadership.
π Definition β Team Software Process (TSP): A disciplined context for engineering work that provides guidance for building and guiding effective software engineering teams.
What is a Team?
A team consists of at least two people working toward a common goal, with each person having a specific assigned role, and with some form of dependency among group members to complete the mission. Roles provide a sense of ownership and belonging; they help guide team members, prevent conflicts, duplicate work, and wasted effort; and they provide members with a degree of control over their working environment. Interdependence means each team member depends to some degree on the performance of other members; it improves individual performance because members can help and support each other. Team performance is further enhanced by the social support of membership. Constantine suggests four organizational paradigms for software engineering teams:
- Closed paradigm β traditional, good for dΓ©jΓ vu projects
- Random paradigm β loose, innovative projects
- Open paradigm β mix of traditional and random
- Synchronous paradigm β natural compartmentalization of problem
High-Performance Team
Team members must have trust in one another. The distribution of skills must be appropriate to the problem. Mavericks may have to be excluded from the team if team cohesiveness is to be maintained. A jelled team is a group of people so strongly knit that the whole is greater than the sum of the parts. Once a team begins to jell, the probability of success goes way up.
Factors that Foster Toxic Team Environment
- A frenzied work atmosphere where team members waste energy and lose focus
- High frustration causing friction among team members
- Fragmented or poorly coordinated procedures or a poorly defined process model
- Unclear definition of roles resulting in lack of accountability
- Continuous and repeated exposure to failure leading to loss of confidence and lowered morale
Principle Elements of TSP
Before team members can participate on a TSP team, they must know how to do disciplined work. Training in the Personal Software Process (PSP) is required to provide engineers with the knowledge and skills to use the TSP. PSP training includes learning how to make detailed plans, gathering and using process data, developing earned value plans, using earned value to track a project, measuring and managing product quality, and defining and using operational processes. The Capability Maturity Model (CMM) or CMMI provides the overall improvement framework needed for effective engineering work. The PSP provides the engineering disciplines that engineers need for consistently using a defined, planned, and measured process.
π‘ Why this matters: The TSP bridges the gap between individual discipline (PSP) and organizational capability (CMM/CMMI), providing the practical guidance for teams to actually execute improvements.
Tying Process Improvement Efforts
The TSP couples the principles of integrated product teams with the PSP and CMM/CMMI methods to produce effective teams. In essence, the CMM/CMMI and PSP provide the context and skills for effective engineering while the TSP guides engineers in actually doing the work. Thus, the TSP capitalizes on the preparation provided by the PSP and CMM/CMMI while also providing explicit guidance on how to do the work.
TSP Teambuilding Principles
The team members establish common goals and defined roles. The team develops an agreed-upon strategy. The team members define a common process for their work. All team members participate in producing the plan, and each member knows his or her personal role in that plan. The team negotiates the plan with management, and management reviews and accepts the negotiated plan. The team members do the job in the way they planned. The team members communicate freely and often. The team forms a cohesive group: the members cooperate and are all committed to meeting the goal. The engineers know their status, get feedback on their work, and have leadership that sustains their motivation. Effective team formation requires that the members truly understand what they are supposed to do, agree on how to do the job, and believe that their plan is achievable. In the TSP, this demanding team-building task is a four-day planning process called the team launch.
TSP Process
TSP processes include: launching a team project, development strategy, development plan, design process, implementation process, test plan, and postmortem.
The TSP Launch Process
Teams generally need professional guidance to properly complete the launch process. This guidance is provided by a trained launch coach who leads the team through the launch process. While the TSP scripts provide essential guidance, every team has unique problems and issues, so a simple process cannot provide all the material needed to guide an inexperienced team. Unless teams are very experienced and have a team leader who has completed several TSP projects, they generally need the support of a trained launch coach.
Introduction to Measurements
Software measurement, once an obscure and esoteric specialty, has become essential to good software engineering. Effective project managers measure attributes of process and product to be able to tell when the software will be ready for delivery and whether the budget will be exceeded. Informed customers measure aspects of the final product to determine if it meets requirements and is of sufficient quality. Without measurement, technology cannot function.
π Examples of Measurements: Prices act as a measure of value; height, weight, and size measurements ensure clothing fits properly; when making a journey, we calculate distance, choose route, measure speed, and predict arrival time.
β Key Takeaways
The software-improvement journey requires a clear vision of the strategic future and systematic approaches to improving "mileage" through understanding business needs, current state, costs, organizational readiness, and resistance to change. The TSP provides a disciplined framework for building effective engineering teams through proper team formation, role assignment, and the four-day team launch process led by a trained coach. Teams are defined by having at least two members with common goals, specific roles, and interdependence. Software measurement is essential for understanding whether requirements are met, code is ready for testing, and projects are on track. The TSP effectively bridges individual discipline (PSP) with organizational capability (CMM/CMMI) to guide practical improvement execution.
π§ Quick Revision Questions
- What are the four key elements that define a team according to the TSP framework?
- What are the ten strategies (Improving Mileage #1 through #10) for improving success in the software-improvement journey?
- What is a "jelled team" and what happens when a team begins to jell?
- What are the five factors that foster a toxic team environment?
- How does the TSP tie together PSP and CMM/CMMI, and what is the purpose of the team launch?