Normal view MARC view ISBD view

PSP : a self-improvement process for software engineers / Watts S. Humphrey

Humphrey, Watts S.
Material type: materialTypeLabelBook; Format: print Series: Software Engineering.Publisher: Upper Saddle River, NJ : Addison-Wesley, 2005Description: xx, 346 p. ; 24 cm.ISBN: 9780321305497.Subject(s): Software engineering | Computer software -- Management | PSP | Ingeniería de sistemas
Tags from this library: No tags from this library for this title. Log in to add tags.
    average rating: 0.0 (0 votes)
Item type Home library Call number Status Loan Date due Barcode Item holds Course reserves
681.3.06/HUM/psp (Browse shelf) Available   Shelving location | Bibliomaps® BIBLIOG. RECOM. 3744060552


Total holds: 0

Enhanced descriptions from Syndetics:

This book describes and documents the PSP (Personal Software Process) for

individual software developers, and introduces them to the TSP (Team

Software Process) for teams. With examples and data drawn from real-world

development projects, it shows how developers can better manage and

dramatically improve their personal software process. In doing so,

organizations become better able to deliver defect-free software on time and

under budget.

In short, this book is the industrial version of the author's Incredibly influential

"A Discipline for Software Engineering." It build upon and modernizes that

text (as well as Humphrey's previous PSP and TSP books) to present a

contemporary and completely updated approach toward the highly important

topic of software process improvement.

Table of contents provided by Syndetics

  • Preface (p. xiii)
  • Chapter 1 The Personal Process Strategy
  • 11.1 The PSPs Purpose
  • 3 1.2 The Logic for a Software Engineering Discipline
  • 4 1.3 Using Disciplined Development Practices
  • 6 1.4 Operational Processes
  • 6 1.5 Defining and Using a Personal Process
  • 7 1.6 Learning to Use a Personal Process
  • 8 1.7 Preparing for the Team Software Process
  • 9 1.8 Summary
  • 9 Reference
  • 10
  • Chapter 2 The Baseline Personal Process
  • 112.1 What Is a Process?
  • 12 2.2 Defining Your Own Process
  • 13 2.3 Baseline Process Contents
  • 14 2.4 Why Forms Are Helpful
  • 16 2.5 The PSP Process Elements
  • 17 2.6 The PSP0 Process
  • 18 2.7 PSP0 Measures
  • 20 2.8 Time Recording
  • 21 2.9 Defect Recording
  • 24 2.10 The PSP0 Project Plan Summary
  • 30 2.11 The Compile Phase
  • 31 2.12 Incremental Development
  • 32 2.13 PSP Tool Support
  • 34 2.14 Summary
  • 34 2.15 Exercises
  • Chapter 3 Measuring Software Size
  • 353.1 Size Measures
  • 35 3.2 Establishing a Database Counting Standard
  • 40 3.3 Establishing a Line-of-Code Counting Standard
  • 40 3.4 Size Accounting
  • 42 3.5 Using Size Data
  • 45 3.6 Calculating Productivity
  • 47 3.7 Size Counters
  • 48 3.8 Other Size Measures
  • 53 3.9 Summary
  • 54 3.10 Exercises
  • 54 References
  • l5
  • Chapter 4 Planning
  • 574.1 The Planning Process
  • 58 4.2 Why Make Plans?
  • 59 4.3 What Is a Plan?
  • 60 4.4 The Contents of a Software Plan
  • 60 4.5 Planning a Software Project
  • 62 4.6 The Conceptual Design
  • 63 4.7 Plan Quality
  • 65 4.8 Planning Issues
  • 65 4.9 Summary
  • 66 Reference
  • 67
  • Chapter 5 Software Estimating
  • 695.1 Size Estimating Principles
  • 69 5.2 The Conceptual Design
  • 70 5.3 Proxy-Based Estimating
  • 71 5.4 Using Proxies in Estimating
  • 75 5.5 Producing the Relative-Size Table
  • 78 5.6 Estimating Considerations
  • 80 5.7 Summary
  • 84
  • Chapter 6 The PROBE Estimating Method
  • 856.1 Estimating from Data
  • 85 6.2 Proxy-Based Estimating
  • 87 6.3 Estimating with Limited Data
  • 95 6.4 An Estimating Example
  • 100 6.5 Estimating Nonprogramming Tasks
  • 102 6.6 Considerations in Using PROBE
  • 105 6.7 Summary
  • 108 6.8 Exercises
  • 108
  • Chapter 7 Software Planning
  • 109 7.1 Plan Requirements
  • 109 7.2 Project and Period Plans
  • 111 7.3 Producing the Schedule
  • 113 7.4 Making the Schedule
  • 115 7.5 Earned Value
  • 119 7.6 An Earned Value Example
  • 120 7.7 Comments on the EV Example
  • 123 7.8 Estimating Accuracy
  • 125 7.9 The Prediction Interval
  • 126 7.10 Alerting Management to Changes
  • 128 7.11 Planning Considerations
  • 129 7.12 Summary
  • 131 7.13 Exercises
  • 132 References (p. 132)
  • Chapter 8 Software Quality
  • 133.8.1 The PSP Quality Strategy
  • 135 8.2 What Is Software Quality?
  • 135 8.3 The Economics of Software Quality
  • 136 8.4 Defect Types
  • 141 8.5 Personal Quality Practices
  • 142 8.6 Quality Measures
  • 143 8.7 Quality Management
  • 153 8.8 Personal Quality Management
  • 154 8.9 Managing Product Quality
  • 156 8.10 PSP Improvement Practices
  • 157 8.11 Defect Prevention
  • 158 8.12 Summary
  • 160 References (p. 161)
  • Chapter 9 Design and Code Reviews
  • 163 9.1 What Are Reviews?
  • 164 9.2 Why Review Programs?
  • 164 9.3 Review Principles
  • 168 9.4 The PSP Code Review Process
  • 173 9.5 The Code Review Checklist
  • 176 9.6 Design Reviews
  • 181 9.7 Design Review Principles
  • 183 9.8 Review Measures
  • 187 9.9 Review Issues
  • 194 9.10 Summary
  • 201 9.11 Exercises
  • 202 References (p. 202)
  • Chapter 10 Software Design (p. 203)
  • 10.1 What Is Design? 204
  • 10.2 Why Design? 206
  • 10.3 The Design Process 207
  • 10.4 Design Levels 210
  • 10.5 Design and Development Strategi

Excerpt provided by Syndetics

The record of most development groups is poor, but the record of software groups is particularly bad. The Standish Group reports that more than half of all software projects are seriously late and over budget, and that nearly one-quarter of them are cancelled without being finished.1Under 30% of the projects were considered successful. Most of the software developers I know are well aware of these problems and can even explain their causes: unrealistic schedules, inadequate resources, and unstable requirements. Although these problems are common and not hard to solve, few developers know how. It is tempting to blame others for our difficulties, but a victimlike attitude doesn't solve problems. When you approach these software management problems in the proper way, you can generally solve them. However, this requires skills and practices that you may not have learned. It also requires dealing with management on management's terms. You can gain the required practices with the Personal Software Process (PSP).2This book describes the PSP and explains the practices and methods you will need to deliver quality products on predictable schedules. After learning these skills, you will be qualified to participate on a team that uses the Team Software Process (TSP). Such teams are called self-directed because they define their own working practices and negotiate their plans and schedules with management. The final chapter of the book describes the TSP and how it helps to put you in charge of your own work. Being a Software Engineer An engineer is someone who knows how to consistently and predictably do quality work. Many of the states in the United States have regulations governing the practice of engineering and they do not allow people to call themselves engineers unless they have demonstrated competence in their professional specialty. Most engineering fields were originally established because the public demanded protection from unqualified work, particularly in building construction, steam power plants, and the like. Without such licensing, steam boilers frequently exploded and bridges collapsed. Although licensing did not magically solve all of these problems, it has been a big help. Licensed engineers use known and proven methods, they are tested to ensure that they consistently do quality work, and they are required to demonstrate their competence at producing safe products. The difference between a licensed engineer and any other technical worker is that the engineer knows the proper ways to do his or her job and is required by law to work that way regardless of management, customer, or other pressures. If we are to call ourselves engineers, we must learn to produce quality products on predictable schedules. This requires that we learn how to consistently meet our commitments and that we know how to handle the normal challenges of creative development work. Software development is the most challenging professional occupation I know of and we must all consistently use the best available methods to meet our management's and our customers' needs. Quality Problems Poor quality management causes many of today's software problems. Most software professionals spend nearly half of their time testing and fixing their products during development and final testing. Poor quality also leads to schedule problems, with defective products delivered long after they were committed. Although fixing a few defects may seem inconvenient, even fairly small programs can have hundreds of defects, and finding and fixing them can take many weeks or even months. Software quality starts with the individual developer. If any of the program modules that we develop have numerous defects, they will be hard to test, take time to integrate into larger systems, and be troublesome for our users. Most of us can be highly productive when writing very small programs. However, our productivity falls off sharply when we develop larger programs. Although developing bigger systems involves some added architectural and design work, most of the added effort is caused by defects. The average amount of time it takes to find and fix each defect increases exponentially as programs become larger. However, if you can consistently write high-quality module-size programs, you will produce better products and improve your and your organization's productivity. A disciplined software engineering process includes effective defect management, comprehensive planning, and precise project tracking and reporting. This book shows you how to use these disciplines to do better development work as an individual and as a TSP team member. It also shows why these practices are essential if you want to manage your own work. The Benefits of Being a Software Engineer As our lives increasingly depend on software, the demands for safety, security, and quality will only increase. This means that the demand for capable software professionals will also increase. Unfortunately, few software developers have any way to distinguish themselves from the many programmers who bang out poor-quality code. With PSP training, you can apply to the Software Engineering Institute to become a PSP-certified software professional. This will distinguish you from the many developers who have no unique qualifications. PSP training will also qualify you to participate on a TSP team, and PSP certification will assure potential employers that you are a professional who is capable of producing high-quality software for predictable costs and on committed schedules. Other personal benefits of PSP certification are the added recognition of being a skilled software professional and easier access to more responsible and higher-paying positions. Developers with such qualifications are now widely sought and will be increasingly needed in the future. Who Should Learn the PSP? Modern technical work involves many specialties, and the people who participate in developing modern products and systems now come from a wide range of disciplines. To produce quality products on predictable schedules, all of the work that these people do must be planned, managed, and quality-controlled. This means that just about everyone associated with system development must know how to do disciplined engineering work. It also means that just about anyone doing such work would benefit from learning the PSP. Although the examples and exercises in this book concern developing small programs, this is only because, even for small programs, software development is a marvelously rich process that can be measured and analyzed. This makes the software process particularly suitable for teaching disciplined engineering practices. Most modern professionals in almost any technical field now learn to write programs during their education, so the PSP course is appropriate for almost anyone planning an engineering or technical career, and it is particularly appropriate for anyone planning to work in product or system development. The Approach Taken by This Book With the growing importance of software and software products, organizations will increasingly need software engineers who consistently use disciplined personal practices. To meet this need, we must learn and consistently practice these disciplines with every program we write. If we don't use sound development practices when writing module-size programs, there is little chance that we will use them when writing large programs. When students start to program, they generally begin by learning a programming language. They practice on toy problems and develop the personal skills to deal with issues at this toy level. As they take more courses, they build their personal skills and can soon develop fairly large programs relatively quickly. These programming-in-the-small skills, however, are inherently limited. Although they may suffice on small-scale individual tasks, they do not provide an adequate foundation for solving the problems of large-scale, multiperson, distributed project teams. This book follows a fundamentally different strategy. It scales down industrial software practices to fit the needs of module-size program development. It then walks you through a progressive sequence of software processes that provide a sound foundation for large-scale software development. By doing the exercises and using the methods described in this book, you will learn how to use the methods for yourself. Once you have learned and used these practices on module-size programs, you will have the skills to use them on larger projects. Although some additional requirements, design, implementation, and testing methods are needed for developing large programs, the basic software engineering disciplines taught by this book apply directly to large-scale system development. The reason, of course, is that large systems are built from collections of program modules that are much like the programs you develop in the PSP course. The principal goal of this book is to guide you in developing the personal software engineering skills that you need to perform at your very best. Consider the challenge of improving personal performance. In sports, for example, runners know the length of the track, their personal time, their fastest time, and the record time for each event. With proper coaching and guidance, they learn their personal strengths and weaknesses and see how to improve. In software, without clear performance measures, few of us can understand our personal strengths and weaknesses or see how to improve. The methods in this book will help you to assess your own performance, to identify ways to improve, and to guide your improvement efforts. In addition to helping you improve your personal performance, this book will also help you build the engineering skills needed for large-scale software work. You will learn how to make accurate plans, how to estimate the accuracy of these plans, and how to track your performance against them. You will use defect management, design and code reviews, design templates, and process analysis. You will do this with a defined and measured personal software process. These measurement and analysis disciplines will help you to evaluate your performance, to understand your strengths, and to see where you should try to improve. From all of this you will develop the tools you need to continue personal improvement throughout your professional career. What's Involved in Learning the PSP In learning the PSP, the benefits you get will depend on the effort you invest. Although there are many ways to organize a PSP course, the basic requirements are reading the 14 chapters of this book and completing the programming and report exercises provided on the SEI Web site ( ). This web site also includes various course plans. The original PSP course called for a total of ten exercise programs and five report exercises. Other strategies have used various numbers of program exercises, but the basic requirement is to write a program at each of the six PSP process levels plus an additional two to four programs to master the methods and build the data to support your continuing work. Reading the chapters should not take too long; the time it takes to write the programs can vary widely. These PSP exercise programs have now been written many thousands of times, and I use a sample of 8,100 sets of PSP program data for many examples in this book. In writing these programs, half of the developers spent less than four hours each, and one-third averaged under three hours. To minimize your time, use the programming language and environment that you know best, and keep your designs simple and straightforward. Because the PSP course involves writing programs, people often think it is a programming course. It is not. Even after writing all of the assigned programs, if you did not follow the prescribed PSP processes and gather, analyze, and use all of the specified data, you would not learn the PSP. This is a process course, and to avoid wasting your time, follow the prescribed process to write each program. If you have problems doing this, ask your instructor for help. The following two suggestions will ensure that you get the most from the PSP course. First, do not substitute programs from your work for those called for by the text. Of the thousands of developers who have completed PSP training, no one has done this successfully. Taking this course involves learning new and unfamiliar methods. The exercises in this course are like experiments, and working programmers are universally reluctant to experiment with unfamiliar methods when they work on a project. Second, do not merely read the book and then try to apply the methods without doing the exercises. Until you have completed the course and the exercises, you will not be able to apply the methods on the job. At least, nobody has done so thus far. Book Overview The 14 chapters of this book introduce the PSP methods in steps. Chapter 1 describes the overall principles of the PSP and the introduction strategy. Chapters 2 and 3 explain how to follow a defined process and how to gather and use the data required to manage a programming development job. Chapters 4, 5, 6, and 7 cover estimating and planning, and Chapters 8 through 12 cover quality management and design. Chapter 13 describes how to use the PSP for various kinds of work, and Chapter 14 describes how the PSP methods are used in the TSP process and how the TSP guides PSP-trained software engineers in using these methods on a project. It also discusses the personal issues involved in learning and using the PSP. Support Materials This book has extensive support materials, which are available at . The support items are a data-gathering and planning tool, the PSP exercise assignment kits, and reference materials. Also included are pointers to PSP course descriptions and the addresses of SEI-authorized organizations that can help you to introduce and use the PSP and TSP in your organization. The PSP also be taught as a university course. For this purpose, the online support materials include an instructor's guide, suggested slides for PSP course lectures, and class exercises. These items are also publicly available on the Web site. Book Background and History This is the fourth book I have written on the PSP. I wrote A Discipline for Software Engineering in 19953and I published Introduction to the Personal Software Process in 1997.4 Introduction to the Team Software Process followed in 2000.5The Discipline book was for a graduate course in computer science, and the introductory books were texts for undergraduate courses. In the intervening years, thousands of software developers have taken the PSP course and hundreds of TSP teams have used the PSP methods on their projects. The results have been far better than I had hoped. This experience demonstrated that a PSP textbook was needed for industrial software developers. Although Discipline for Software Engineering covers all of the required materials, it also includes a number of topics that are of more academic interest and are not essential for teaching industrial software developers. Because course duration is a principal concern for industrial organizations, these more academic topics have been omitted from this book. Notes 1. The Standish Group International, Inc., 586 Olde King's Highway, Dennis, MA 02638; . 2. Personal Software Process, PSP, Team Software Process, and TSP are service marks of Carnegie Mellon University. 3. Watts Humphrey, A Discipline for Software Engineering, Addison-Wesley, 1995. 4. Watts Humphrey, Introduction to the Personal Software Process, Addison-Wesley, 1997. 5. Watts Humphrey, Introduction to the Team Software Process, Addison-Wesley, 2000. 0321305493P03172005 Excerpted from PSP: A Self-Improvement Process for Software Engineers by Watts S. Humphrey All rights reserved by the original copyright owners. Excerpts are provided for display purposes only and may not be reproduced, reprinted or distributed without the written permission of the publisher.

Author notes provided by Syndetics

Known as "the father of software quality," Watts S. Humphrey is the author of numerous influential books on the software-development process and software process improvement. Humphrey is a fellow of the Software Engineering Institute (SEI) at Carnegie Mellon University, where he founded the Software Process Program and provided the vision and early leadership for the original Capability Maturity Model (CMM). He also is the creator of the Personal Software Process (PSP) and Team Software Process (TSP). Recently, he was awarded the National Medal of Technology--the highest honor given by the president of the United States to America's leading innovators.

There are no comments for this item.

Log in to your account to post a comment.

Powered by Koha