Team software process

Short description: Self-optimization method for development teams

Software development

Core activities

* Processes
* Requirements
* Design
* Engineering
* Construction
* Testing
* Debugging
* Deployment
* Maintenance

Paradigms and models

* Agile
* Cleanroom
* Incremental
* Prototyping
* Spiral
* V model
* Waterfall

Methodologies and frameworks

* ASD
* DevOps
* DAD
* DSDM
* FDD
* IID
* Kanban
* Lean SD
* LeSS
* MDD
* MSF
* PSP
* RAD
* RUP
* SAFe
* Scrum
* SEMAT
* TSP
* UP
* XP

Supporting disciplines

* Configuration management
* Documentation
* Software quality assurance (SQA)
* Project management
* User experience

Practices

* ATDD
* BDD
* CCO
* CI
* CD
* DDD
* PP
* SBE
* Stand-up
* TDD

Tools

* Compiler
* Debugger
* Profiler
* GUI designer
* Modeling
* IDE
* Build automation
* Release automation
* Infrastructure as code
* Testing

Standards and Bodies of Knowledge

* BABOK
* CMMI
* IEEE standards
* ISO 9001
* ISO/IEC standards
* PMBOK
* SWEBOK
* ITIL

Glossaries

* Artificial intelligence
* Computer science
* Electrical and electronics engineering

* v
* t
* e

In combination with the personal software process (PSP), the team software process (TSP) provides a defined operational process framework that is designed to help teams of managers and engineers organize projects and produce software for products that range in size from small projects of several thousand lines of code (KLOC) to very large projects greater than half a million lines of code. The TSP is intended to improve the levels of quality and productivity of a team's software development project, in order to help them better meet the cost and schedule commitments of developing a software system.[1][2][3][4]

The initial version of the TSP was developed and piloted by Watts Humphrey in the late 1990s[5] and the Technical Report[6] for TSP sponsored by the U.S. Department of Defense was published in November 2000. The book by Watts Humphrey,[7] Introduction to the Team Software Process, presents a view of the TSP intended for use in academic settings, that focuses on the process of building a software production team, establishing team goals, distributing team roles, and other teamwork-related activities.

## Contents

* 1 Introduction to TSP
* 2 How TSP works
* 3 Latest developments
* 4 Publications
* 5 See also
* 6 References
* 7 External links

## Introduction to TSP

The primary goal of TSP is to create a team environment for establishing and maintaining a self-directed team, and supporting disciplined individual work as a base of PSP framework. Self-directed team means that the team manages itself, plans and tracks their work, manages the quality of their work, and works proactively to meet team goals. TSP has two principal components: team-building and team-working. Team-building is a process that defines roles for each team member and sets up teamwork through TSP launch and periodical relaunch. Team-working is a process that deals with engineering processes and practices utilized by the team. TSP, in short, provides engineers and managers with a way that establishes and manages their team to produce the high-quality software on schedule and budget.

## How TSP works

Before engineers can participate in the TSP, it is required that they have already learned about the PSP, so that the TSP can work effectively. Training is also required for other team members, the team lead and management. The TSP software development cycle begins with a planning process called the launch, led by a coach who has been specially trained, and is either certified or provisional.[8][9] The launch is designed to begin the team building process, and during this time teams and managers establish goals, define team roles, assess risks, estimate effort, allocate tasks, and produce a team plan. During an execution phase, developers track planned and actual effort, schedule, and defects meeting regularly (usually weekly) to report status and revise plans. A development cycle ends with a Post Mortem to assess performance, revise planning parameters, and capture lessons learned for process improvement.

The coach role focuses on supporting the team and the individuals on the team as the process expert while being independent of direct project management responsibility.[10][11] The team leader role is different from the coach role in that, team leaders are responsible to management for products and project outcomes while the coach is responsible for developing individual and team performance.[12][13]

## Latest developments

TSP has been adapted to work with other types of knowledge work, including systems engineering[14] and services.[15][16]

Mapping TSP to Capability Maturity Model Integrated (CMMI) practices was documented in 2010,[17] and piloted as an alternative path to implement CMMI process improvement.[18][19] A body of knowledge (BOK) was issued in 2010.[20] The coach mentor program guidebook was released in 2010.[21]

According to a study by Capers Jones TSP is one of the most successful development methodologies regarding schedule, quality and budget (TCO) [22]

## Publications

* TSP: Leading a Development Team 2005
* TSP: Coaching Development Teams 2005

## See also

* Personal software process (PSP)
* Watts Humphrey

## References

1. ↑ Jones, Capers (2009). Software Engineering Best Practices. McGraw-Hill. pp. 11. ISBN 9780071621618.
2. ↑ Kindler, Nosh B; Krishnakanthan, Vasantha; Tinaikar, Ranjit. Applying Lean to Application Development . McKinsey Quarterly, May 2007
3. ↑ "Agile Capital Consulting". http://www.agilecapitalconsulting.com/.
4. ↑ Ker, J. I., Wang, Y., Hajli, M. N., Song, J., & Ker, C. W. (2014). "Deploying lean in healthcare: Evaluating information technology effectiveness in US hospital pharmacies". International Journal of Information Management, 34(4), 556–560.
5. ↑ McAndrews, Donald (1998). The Team Software ProcessSM (TSPSM): An Overview and Preliminary Results of Using Disciplined Practices. http://en.scientificcommons.org/18590660. Retrieved 2011-07-25.
6. ↑ Humphrey, Watts. "The Team Software Process". Software Engineering Institute. http://www.sei.cmu.edu/reports/00tr023.pdf.
7. ↑ Humphrey, Watts (1999). Introduction to the Team Software Process. Addison Wesley.
8. ↑ Humphrey, Watts (2018). The Team Software Process Body of Knowledge. Software Engineering Institute. doi:10.1184/R1/6584825.v1. https://kilthub.cmu.edu/articles/Team_Software_Process_TSP_Body_of_Knowledge_BOK_/6584825.
9. ↑ Chick, Timothy (2010). Team Software Process (TSP) Coach Mentoring Program Guidebook Version 1.1. Software Engineering Institute. doi:10.1184/R1/6584810.v1. https://kilthub.cmu.edu/articles/Team_Software_Process_TSP_Coach_Mentoring_Program_Guidebook_Version_1_1/6584810.
10. ↑ Humphrey, Watts (2018). The Team Software Process Body of Knowledge. Software Engineering Institute. doi:10.1184/R1/6584825.v1. https://kilthub.cmu.edu/articles/Team_Software_Process_TSP_Body_of_Knowledge_BOK_/6584825.
11. ↑ Humphrey, Watts (2005). TSP: Coaching Development Teams. Addison Wesley.
12. ↑ Humphrey, Watts (2018). The Team Software Process Body of Knowledge. Software Engineering Institute. doi:10.1184/R1/6584825.v1. https://kilthub.cmu.edu/articles/Team_Software_Process_TSP_Body_of_Knowledge_BOK_/6584825.
13. ↑ Humphrey, Watts (2005). TSP: Coaching Development Teams. Addison Wesley.
14. ↑ Carleton, Anita. "Extending Team Software Process (TSP) to Systems Engineering: A NAVAIR Experience Report". Software Engineering Institute. http://www.sei.cmu.edu/reports/10tr008.pdf.
15. ↑ Battle, Ed. "Leading & Learning – Using TSP at the MSG Level". Naval Oceanographic Office. http://www.sei.cmu.edu/tspsymposium/past-proceedings/2009/DAY 1 930AM Battle.pdf.
16. ↑ "Software consulting: How to make sure the software consulting company you are looking for is reliable.". https://devsdata.com/software-consulting.
17. ↑ "Implementation Guidance for the Accelerated Improvement Method (AIM)". Software Engineering Institute. December 2010. http://www.sei.cmu.edu/reports/10sr032.pdf.
18. ↑ Webb, David (April 2007). "CMMI Level 5 and the Team Software Process". Cross Talk. https://apps.dtic.mil/sti/pdfs/ADA487567.pdf.
19. ↑ Mondragon, Oscar. "AIM Case Study". Software Engineering Excellence Center. http://www.sei.cmu.edu/tspsymposium/past-proceedings/2010/AIM_Case_Study.pdf.
20. ↑ Humphrey, Watts (2018). The Team Software Process Body of Knowledge. Software Engineering Institute. doi:10.1184/R1/6584825.v1. https://kilthub.cmu.edu/articles/Team_Software_Process_TSP_Body_of_Knowledge_BOK_/6584825.
21. ↑ Chick, Timothy (2010). Team Software Process (TSP) Coach Mentoring Program Guidebook Version 1.1. Software Engineering Institute. doi:10.1184/R1/6584810.v1. https://kilthub.cmu.edu/articles/Team_Software_Process_TSP_Coach_Mentoring_Program_Guidebook_Version_1_1/6584810.
22. ↑ Jones, Capers (2013). "Evaluating ten software development methodologies". http://namcookanalytics.com/evaluating-ten-software-development-methodologies/.

## External links

* TSP homepage

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Team software process. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Team_software_process&oldid=4346081"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template