Programming team

This article has multiple issues. Please help improve it or discuss these issues on the talk page. (Learn how and when to remove these template messages)

This article needs to be updated. The reason given is: Sources are dated for this topic; other teams exist and should be explored (with references). Please update this article to reflect recent events or newly available information. (March 2019)

|

(Learn how and when to remove this template message)

A programming team is a team of people who develop or maintain computer software.[1] They may be organised in numerous ways, but the egoless programming team and chief programmer team have been common structures.[2]

## Contents

* 1 Description
* 2 Programming team structures
* 2.1 Egoless programming
* 2.2 Chief programmer team
* 2.3 Shared workstation teams
* 2.3.1 Pair programming
* 2.3.2 Mob programming
* 3 Programming models
* 3.1 Waterfall model
* 3.2 Agile model
* 4 See also
* 5 References

## Description

A programming team comprises people who develop or maintain computer software.[3]

## Programming team structures

Programming teams may be organised in numerous ways, but the egoless programming team and chief programmer team are two common structures typically used.[2] The main determinants when choosing the programming team structure typically include: difficulty, size, duration, modularity, reliability, time, and sociability.[2]

### Egoless programming

Main article: Egoless programming

According to Marilyn Mantei, individuals that are a part of a decentralized programming team report higher job satisfaction.[2] But an egoless programming team contains groups of ten or fewer programmers. Code is exchanged and goals are set amongst the group members. Leadership is rotated within the group according to the needs and abilities required during a specific time. The lack of structure in the egoless team can result in a weakness of efficiency, effectiveness, and error detection for large-scale projects. Egoless programming teams work best for tasks that are very complex.

### Chief programmer team

Main article: Chief programmer team

A chief programmer team will usually contain three-person teams consisting of a chief programmer, senior level programmer, and a program librarian. Additional programmers and analysts are added to the team when necessary. The weaknesses of this structure include a lack of communication across team members, task cooperation, and complex task completion. The chief programmer team works best for tasks that are simpler and straightforward since the flow of information in the team is limited. Individuals that work in this team structure typically report lower work morale.[2]

### Shared workstation teams

#### Pair programming

Main article: Pair programming

A development technique where two programmers work together at one workstation.

#### Mob programming

Main article: Mob programming

A software development approach where the whole team works on the same thing, at the same time, in the same space, and at the same computer.[4]

## Programming models

Programming models allow software development teams to develop, deploy, and test projects using these different methodologies.

Throughout both of these programming models, team members typically participate in daily 5 - 15 minute stand-ups. Traditionally, each member of the team will stand up and state what they have worked on since the previous stand-up, what they intend to work on until the next stand-up, and whether or not there is anything preventing them from making progress, often known as a "blocker".[5]

### Waterfall model

Main article: Waterfall model

The waterfall model, noted as the more traditional[6] approach, is a linear model of production. The sequence of events of this methodology follows as:

1. Gather and document requirements
2. Design
3. Code and unit test
4. Perform system testing
5. Perform user acceptance testing (UAT)
6. Fix any issues
7. Deliver the finished product

Each stage is distinct during the software development process, and each stage generally finishes before the next one can begin.

Programming teams using this model are able to design the project early on in the development process allowing teams to focus on coding and testing during the bulk of the work instead of constantly reiterating design. This also allows teams to design completely and more carefully so that teams can have a complete understanding of all software deliverables.

### Agile model

Main article: Agile software development

The Agile development model is a more team-based approach to development[6] than the previous waterfall model. Teams work in rapid delivery/deployment which splits work into phases called "sprints". Sprints are usually defined as two weeks of planned software deliverables given to each team/team member.

After each sprint, work is reprioritized and the information learned from the previous sprint is used for future sprint planning. As the sprint work is complete, it can be reviewed and evaluated by the programming team and sent back for another iteration (i.e. next sprint) or closed if completed.

The general principles[7] of the Agile Manifesto[8] are as follows:

* Satisfy the customer and continually develop software.
* Changing requirements are embraced for the customer's competitive advantage.
* Concentrate on delivering working software frequently. Delivery preference will be placed on the shortest possible time span.
* Developers and business people must work together throughout the entire project.
* Projects must be based on people who are motivated. Give them the proper environment and the support that they need. They should be trusted to get their jobs done.
* Face-to-face communication is the best way to transfer information to and from a team.
* Working software is the primary measurement of progress.
* Agile processes will promote development that is sustainable. Sponsors, developers, and users should be able to maintain an indefinite, constant pace.
* Constant attention to technical excellence and good design will enhance agility.
* Simplicity is considered to be the art of maximizing the work that is not done, and it is essential.
* Self-organized teams usually create the best designs.
* At regular intervals, the team will reflect on how to become more effective, and they will tune and adjust their behavior accordingly.

## See also

* Cross-functional team
* Scrum (software development)
* Software development process
* Team software process
* Project team

## References

1. ↑ Jack Belzer, Albert George Holzman, Allen Kent (October 1, 1979), Encyclopedia of computer science and technology, 13, CRC Press, ISBN 9780824722630, https://books.google.com/books?id=CEGXR7FeAWQC&pg=PA217
2. ↑ 2.0 2.1 2.2 2.3 2.4 Marilyn Mantei (March 1981). "The Effect of Programming Team Structures on Programming Tasks". Communications of the ACM 24 (3): 106–113. http://sunnyday.mit.edu/16.355/mantei-teams.pdf. Retrieved 2019-03-26.
3. ↑ Jack Belzer, Albert George Holzman, Allen Kent (October 1979), Encyclopedia of computer science and technology, 13, CRC Press, ISBN 9780824722630, https://books.google.com/books?id=CEGXR7FeAWQC&pg=PA217
4. ↑ Jack Belzer, Albert George Holzman, Allen Kent (October 1979), Change Management Process, 13, ISBN 9780824722630, https://www.slideteam.net/change-management-powerpoint-presentation-slides.html/id=CEGXR7FeAWQC&pg=PA217
5. ↑ Griffin, Christina; Roldan, Margaret (29 October 2013). "Swimming up the waterfall: agile processes in a waterfall world". https://www.pmi.org/learning/library/waterfall-methodology-agile-approach-5821#:~:text=Exhibit 2 – Examples of waterfall and agile (Scrum) uses.&text=Every Sprint is 10 days,product backlog grooming, and Retrospective..
6. ↑ 6.0 6.1 Mary Lotz (July 5, 2018), Waterfall vs. Agile: Which is the Right Development Methodology for Your Project?, https://www.seguetech.com/waterfall-vs-agile-methodology
7. ↑ Linchpin SEO Team (March 26, 2019), A Beginners Guide To The Agile Method & Scrums, https://linchpinseo.com/the-agile-method/
8. ↑ "Principles behind the Agile Manifesto". 2019-06-11. http://agilemanifesto.org/principles.html.

* v
* t
* e

Software engineering

Fields|

* Computer programming
* Requirements engineering
* Software deployment
* Software design
* Software maintenance
* Software testing
* Systems analysis
* Formal methods

Concepts|

* Data modeling
* Enterprise architecture
* Functional specification
* Modeling language
* Orthogonality
* Programming paradigm
* Software
* Software archaeology
* Software architecture
* Software configuration management
* Software development methodology
* Software development process
* Software quality
* Software quality assurance
* Software verification and validation
* Structured analysis

Orientations|

* Agile
* Aspect-oriented
* Object orientation
* Ontology
* Service orientation
* SDLC

Models|

| Developmental|

* Agile
* EUP
* Executable UML
* Incremental model
* Iterative model
* Prototype model
* RAD
* UP
* Scrum
* Spiral model
* V-Model
* Waterfall model
* XP

|

Other|

* SPICE
* CMMI
* Data model
* ER model
* Function model
* Information model
* Metamodeling
* Object model
* Systems model
* View model

Languages|

* IDEF
* UML
* USL
* SysML

Software
engineers

* Victor Basili
* Kent Beck
* Grady Booch
* Fred Brooks
* Barry Boehm
* Peter Chen
* Danese Cooper
* Ward Cunningham
* Tom DeMarco
* Edsger W. Dijkstra
* Delores M. Etter
* Martin Fowler
* Adele Goldstine
* Margaret Hamilton
* C. A. R. Hoare
* Lois Haibt
* Mary Jean Harrold
* Grace Hopper
* Watts Humphrey
* Michael A. Jackson
* Ivar Jacobson
* Alan Kay
* Nancy Leveson
* Stephen J. Mellor
* Bertrand Meyer
* David Parnas
* Trygve Reenskaug
* Winston W. Royce
* James Rumbaugh
* Mary Shaw
* Peri Tarr
* Elaine Weyuker
* Niklaus Wirth
* Edward Yourdon

Related fields|

* Computer science
* Computer engineering
* Project management
* Risk management
* Systems engineering

* Category
* Commons

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Programming team. Read more

|

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