Mob Programming and the Cynefin Framework Mob Programming and the Cynefin Framework
In the ever-evolving landscape of software development, traditional methods often fall short in addressing the inherent complexities. Mob Programming (also known as Ensemble Programming by those who prefer to avoid the potentially negative connotation of the word ‘mob.’) is a collaborative approach that is often met with skepticism. This blog post delves into the nuances of Mob Programming, its relation to complexity, and how the Cynefin framework provides a lens to understand its effectiveness.
What is Mob Programming?
Similar to pair programming, Mob Programming is a development practice where more than one person works together on the same code, at the same time, on the same computer.
The difference is that in a mob more than two people (i.e. a pair) work together. It can be the entire team, or a subset of the team, depending on the size of the team and the preferences of team members.
The setup involves a driver, who is at the keyboard typing, and a navigator, who thinks about the context and what needs to be done. The roles rotate regularly, ensuring that everyone takes turns being the driver and navigator. At first glance, this might seem inefficient — how can an entire team be productive when only one person is writing code? But the true power of Mob Programming lies in its collaborative nature.
Key Components of Mob Programming
- Driver and Navigator Roles: The driver focuses on executing the current task, while the navigator provides direction and context. This division of labor ensures that the driver can concentrate on the specifics while the navigator thinks strategically.
- Regular Rotation: The roles rotate typically every 10-20 minutes. This keeps everyone engaged and ensures that all team members contribute to both hands-on and strategic aspects of the work.
- Shared Workspace: A central, large screen where the code is displayed ensures that everyone can see and contribute. Additional keyboards and mice can be used to facilitate smooth transitions between roles.
Understanding Complexity: The Cynefin Framework
To appreciate the effectiveness of Mob Programming, it helps to understand the Cynefin framework. Developed by Dave Snowden, the Cynefin framework categorizes systems into five domains based on their complexity:
- Clear: Clear cause and effect, best practices apply.
- Complicated: Expert analysis required, good practices apply.
- Complex: Cause and effect are only apparent in retrospect, emergent practices apply.
- Chaotic: No clear cause and effect, novel practices apply.
- Confused: Disorder, where it’s unclear which domain applies.
Software development, by its nature, falls into the complex domain. It involves teams, people, and customers, making it a dynamic and unpredictable process. In such environments, traditional management practices often falter, and adaptive, collaborative approaches like Mob Programming shine.
The Synergy Between Mob Programming and Complexity
In complex systems, the relationship between cause and effect isn’t obvious. Solutions emerge through collaboration, experimentation, and shared understanding. Mob Programming aligns perfectly with these principles. Here’s how:
1. Collective Intelligence
By working together, teams tap into their combined knowledge and competence. Every team member’s experience, knowledge, and perspective contribute to solving problems. This diversity of thought is invaluable in complex systems where solutions aren’t straightforward.
2. Enhanced Knowledge Sharing
Mob Programming ensures that everyone on the team is on the same page. Knowledge isn’t siloed; it’s instant and shared organically. Besides reducing the need for meetings, code reviews, and documentation, this type of shared understanding is crucial in complex systems.
3. Rapid Feedback and Adaptation
Complex systems work best with fast feedback loops and iterative approaches, where solutions evolve over time. Quick feedback loops are essential. Mob Programming facilitates real-time feedback and adaptation. As the team works together, they can immediately address issues, experiment with solutions, and iterate rapidly.
4. The Importance of Psychological Safety
Experimentation means failure is inevitable. It has to be ok to fail. For people to feel safe to share ideas, make mistakes, and learn from each other, psychological safety is crucial. Mob Programming can foster, but also benefit from, a culture of trust and openness. When team members feel safe to share ideas, make mistakes, and learn from each other, the collective problem-solving capability is amplified.
5. Accelerated Onboarding
In complex systems where cause and effect are not always clear, onboarding new team members can be challenging. Traditional methods of onboarding often involve isolating newcomers with documentation or bug fixes. Mob Programming offers a hands-on approach that accelerates the learning curve. New team members get involved in the team’s workflow and real-life problems right away. This hands-on experience accelerates the learning curve and integration into the team.
Overcoming Skepticism: A Case Study
In a company where I previously worked, the idea of Mob Programming was initially met with skepticism by management. They couldn’t fathom how having an entire team work on a single computer could possibly be productive. However, kudos to them for letting the team experiment with it. The team chose to use Mob Programming to tackle a new, complicated API.
The results spoke for themselves. The shared understanding and collaborative problem-solving accelerated the development process. Everyone had the same context and input, which reduced the need for extensive rework later. Seeing the success, other teams in the company began experimenting with Mob Programming to varying degrees, leading to overall increased productivity and satisfaction.
Best Practices for Implementing Mob Programming
For teams looking to adopt Mob Programming, here are some good practices to consider:
1. Cultivate Psychological Safety
Creating an environment of trust and openness is crucial. Encourage team members to share ideas without fear of judgment. Leadership plays a key role in fostering this culture, leading by example.
2. Set Up the Right Environment
Tools: Use tools that facilitate easy handover of the keyboard and tracking of roles. There are online tools available to assist with this. For example, try our free Ensemble Conductor tool to set up teams and manage roles and rotations. It supports setting up sub-teams and rotating members between them.
Workspace: Ensure a comfortable setup with a large screen so everyone can see clearly and participate. Multiple keyboards can make the transition between drivers smoother.
Communication Channels: Establish clear communication channels to ensure that everyone can contribute effectively, whether they are remote or in-person.
3. Start Small
Begin with a pilot project or start out small, for example running a mob programming session per week. This allows the team to get accustomed to the practice without overwhelming them, and might help convince skeptics of its effectiveness.
4. Learn from Others
Connect with teams or organizations that have successfully implemented Mob Programming. Learning from their experiences can provide valuable insights and help address initial skepticism.
5. Regular Retrospectives
Every team is different. What works for one team might not work for another. Be flexible and willing to adapt the Mob Programming practices to fit the unique dynamics of your team.
Hold regular retrospectives to reflect on the Mob Programming sessions. Discuss what worked well, what didn’t, and how the process can be improved. Some things to iterate and experiment with include:
- Mob size
- Rotation frequency
- Tools and setup
- How often to use Mob Programming
Addressing Common Concerns
1. Perceived Inefficiency
One of the most common concerns about Mob Programming is the perceived inefficiency of having the entire team working on a single task. However, this perspective often overlooks the hidden inefficiencies in traditional workflows, such as communication delays, context switching, and rework. By working together, Mob Programming minimizes these inefficiencies and enhances overall productivity.
Remember that Mob Programming is not intended to be used for all tasks, or all the time. It can be particularly effective for complex problems that require collaboration and shared understanding.
2. Loss of Individual Contribution
Another concern is that individual contributions might be overshadowed in a mob setting. In reality, Mob Programming encourages active participation from all team members. The regular rotation of roles ensures that everyone has the opportunity to contribute their expertise and ideas.
3. Difficulty in Scaling
Some believe that Mob Programming might be difficult to scale in larger organizations. Mob Programming is a team practice, so the size of the organization is less relevant than the size of the team.
For larger teams, consider dividing into smaller mobs depending on the task and context.
Mob size Some teams I talked to found that a mob size of 3-4 people is optimal. This means the team is split into two or more mobs. When dividing into sub-teams, it is important to rotate team members between mobs to avoid creating silos.
Outcomes and Benefits
Teams that have successfully adopted Mob Programming report several benefits:
- Increased Productivity: The collaborative approach accelerates problem-solving and reduces rework.
- Employee Satisfaction: Working together fosters a sense of camaraderie and shared purpose.
- Improved Onboarding: New team members integrate more quickly as they learn from the collective experience of the team.
- Reduced Technical Debt: With everyone involved in the coding process, there’s a greater emphasis on writing clean, maintainable code, reducing technical debt in the long run.
- Team Cohesion: The practice fosters a strong sense of team cohesion and mutual respect, which can have positive ripple effects on other areas of work.
Final Thoughts
In the realm of software development, where complexity is the norm, seemingly counterintuitive practices like Mob Programming can be incredibly effective. It’s not just about coding and there is no such thing as a “software factory”; it’s about understanding problems, aligning goals, and leveraging collective intelligence. Trusting the team to know what will make them most productive is key. As we navigate the complexities of software development, embracing collaborative approaches like Mob Programming can lead to innovation, efficiency, and a more cohesive team dynamic.
Once one understands that software development is a complex system, it is easier to see the value of Mob Programming, and the Cynefin framework provides a lens to understand why Mob Programming has the potential to be so effective.
