In software engineering, team programming is a project management strategy for coordinating task distribution in computer software development projects, which involves the assignment of two or more computer programmers to work collaboratively on an individual sub-task within a larger programming project. In general, the manner in which this term is used today refers to methods currently in vogue within the software development industry where multiple individuals work simultaneously on the same activity; in these systems, programmers are often grouped in pairs at the same computer workstation, one observing the other working on the software and alternating roles at time intervals.

Traditional team management methods

Traditional software development has nearly always involved multiple programmers working on separate parts of a computer system for any project of significant scope and scale—a method of division of labour. Clearly, it is unreasonable to imagine that a single programmer could adequately complete all the required work for a complex system working entirely on their own within a viable timescale; and as development projects become more complex, specialised expertise becomes of paramount importance in aspects such as systems analysis, quality assurance, and technical challenges posed by individual components. Initially this tended to be an informal process, but with the rise of commercial software development as a viable industry, a more industrial and systematic approach became necessary.

Paper-oriented systems methodologies originally designed for undertaking governmental projects, such as the Structured Systems Analysis and Design Method (SSADM), assigned individual people to carry out individual tasks, and specified the role of designers as being clearly separate from that of the programmers in the waterfall software development model. This methodology also clearly separated each of the individual "life-cycle" stages through which a system development project progressed. The resulting "paper trail" for a systems development project could take so long to build that often parts of the analysis documentation—or sometimes its entirety—was out of date by the time of actual development, rendering them worse than useless.

Modern trends: multiple programmers to one sub-task

Difficulties were experienced with these older methods, such as costs spiralling out of control as systems grew, and schedules failing to meet time-to-market targets. These issues gave rise to techniques such as pair programming, mob programming (aka. ensemble programming), along with new systems lifecycle structures such as the Boehm spiral. Specification of these new approaches began in the mid-1980s and continues today. Many of these strategies involve multiple programmers working collaboratively on the same piece of source code as opposed to being individually responsible for individual tasks. For example, in "pair programming", responsibility for the resulting product is equally shared between two programmers who work on their assigned sub-task together. Benefits of this approach include the deficiencies in knowledge of one programmer to be compensated for by the ability in specific areas by the other programmer; in addition, the shared responsibility is thought to increase incentives for meeting project deadlines and quality targets.

This technique is frequently used in newer programming methodologies that are focused around object-oriented programming techniques, such as the Rational Unified Process and Extreme Programming (acronym "XP"), often in combination with design documentation methods such as the Unified Modelling Language (UML). In object-oriented programming languages, software functionality forms modular, discrete units (termed classes for the functional elements, and packages for constellations of interlinked classes that carry out a particular function); the two most well-known of these are C++ and Java. This lends itself well towards the division of programming projects into sub-teams, although issues are still often encountered in integrating the resulting product following completion of each sub-task.

Mob programming

Mob programming (sometimes informally called mobbing, ensemble programming or posse programming^[1]) is 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. This is similar to pair programming where two people sit at the same computer and collaborate on the same code at the same time. With mob programming, the collaboration is extended to everyone on the team, while still using a single computer for writing the code and inputting it into the code base.^[2]

The basic concept of mob programming is simple: the entire team works as a team together on one task at the time. That is: one team – one (active) keyboard – one screen (projector of course). ^[3]

— Marcus Hammarberg, Mob programming – Full Team, Full Throttle

It builds on principles of lean manufacturing, extreme programming, and lean software development. Early use of the phrase "mob programming" was made in Extreme Programming Perspectives.^[4]

In addition to software coding, a mob programming team can work together to tackle other typical software development tasks. Some examples include: defining user stories or requirements, designing, testing, deploying software, and working with subject matter experts. Almost all work is handled in working meetings or workshops, where all the people involved in creating the software are considered to be team members, including the customer and business experts.^[5] Mob programming also works for distributed teams in the same virtual space using screen sharing technology.^[6]