Watts Humphrey is the visionary behind the Capability Maturity Model (CMM)(R) and the Personal Software Process (PSP) (sm). The CMM contains a framework for software process improvement at the organizational level. The PSP builds the self-discipline needed for individual programmers to work efficiently and effectively. The author's new Team Software Process (TSP) (sm) details methods to guide the formation of software development teams, to motivate their work, and to enhance their productivity.

 

This book describes an introductory version of TSP, ideal for smaller projects but also useful for learning basic techniques and procedures that apply to other development projects. Methods presented include:

• how to establish roles;
• how to conceive, design, and plan a project;
• how to track and report on progress.

The book walks readers through a complete development cycle, illustrating:

• how best to use the talents at hand;
• how to formulate well-defined goals;
• how to coordinate activities for maximum progress;
• how to promote effective communication;
• how to alleviate many of the conflicts that undermine teamwork.

Team members should not have to expend valuable time and energy reinventing ways to organize and run their team. By following a proven process, the team will more quickly be able to focus on the successful completion of the project itself. To help a team course apply these methods, the book provides two project exercises, with prescribed development goals and team roles.

Watts S. Humphrey, a widely respected authority on software process improvement and a long-time senior manager of software development at IBM, is a Fellow at the Software Engineering Institute at Carnegie Mellon University. Mr. Humphrey also is the author of Managing the Software Process (1989), A Discipline for Software Engineering (1995), Managing Technical People (1997), and Introduction to the Personal Software Process (1997).

This book is for students and engineers who have already learned and, preferably, applied the Personal Software Process (PSP) SM . You may have learned the PSP in a graduate or senior-level course (1) or in an earlier introductory course (2). Alternatively, you may be a practicing engineer who seeks guidance on how to use the PSP in an industrial team environment. In any case, when you have learned the PSP, you have the background to use the methods and practices in this book. After you have learned the PSP, you may need guidance on applying it to the many tasks of the software process. This is the principal role of the Team Software Process (TSP) SM : to provide a framework for using sound engineering methods while developing software. There is a great deal to say about teamwork, and this book covers the basic elements. TSPi (the introductory Team Software Process) introduces team concepts and walks you through the steps of building teams and working on a team. Note, however, that this text is designed for an introductory course and does not cover all the material that you will need to use the TSP for larger-scale industrial projects. How TSPi Helps Engineers This book teaches engineers about software development teamwork. TSPi provides a structured set of steps, shows engineers what to do at each step, and demonstrates how to connect these steps to produce a completed product. TSPi also provides two interesting and reasonably challenging project exercises. Each is at the same time small enough to be completed in a few weeks and large enough to simulate a typical small project. When capable engineers follow the guidance provided in this book, they will invariably produce a finished working product. In the suggested TSPi strategy, teams develop a product in two or three cycles. In the first cycle, teams build a small working product kernel. With each succeeding cycle function is added to this base. This strategy demonstrates the benefits of using data from a prior project to plan a new project. Also, by taking new roles for each cycle, engineers will have two or three quite different experiences in just one project. After several development cycles, engineers will have had a broad exposure to teaming methods, and they are likely to continue using the TSPi methods on their own. Why TSPi Courses Are Needed Because project courses have proven to be effective in preparing students for software engineering careers, a growing number of universities now offer them. These courses are often oversubscribed. Students seek material that applies to their future jobs, and they see team courses as meeting this need. After graduation, students and employers report that software project courses are useful preparation for work in industry. There is now a large body of experience with team project courses (3). Although many of these courses have been successful, three problems are common. First, the students often attempt projects that are too large. Second, they frequently concentrate on the product and ignore the process. Finally, one or more team members are disruptive. Although TSPi cannot prevent all these problems, it provides guidance on how to avoid or mitigate them. To make effective use of curriculum time, team software courses should be carefully structured and based on proven project experience. Without a defined process or a structured team framework, engineers must figure out for themselves how to run their projects. Without this process and structure, these groups must learn team-building and teamwork basics through an often painful trial-and-error process. This is both expensive and unnecessary because teamwork principles are well known and straightforward. TSPi guides engineers in effective teamwork methods. It does this by walking them through a team-building process and then using a measure