Using extreme programming to build a strong, scalable team culture.

Culture is key to any organisation, especially where the products and services you create have a global impact. Creating a strong and scalable software engineering culture is not easy. But Extreme Programming (XP) practices make it easier.

Using extreme programming to build a strong, scalable team culture.
Photo by Priscilla Du Preez / Unsplash

In this blog post, we will look at how Extreme Programming (XP) practices can help build a Culture of Trust that encourages open, honest communication and high levels of innovation.

So what is Extreme Programming?

Extreme Programming (XP) is a software development methodology first coined in 1996 by Kent Beck. It is based on the principles of Simplicity, Communication, Feedback, and Courage. XP has been used successfully on large-scale projects such as Microsoft Windows 2000 and XP, Adaptive Path's Manifesto project, and Chrysler Comprehensive Compensation System.

Extreme Programming practices are designed to address the challenges that software engineers face when working on complex projects. These challenges include:

  • The need for speed: In today's fast-paced world, it is important to be able to get products to market quickly. With XP practices such as continuous integration and automated testing, software engineers can make changes to code and immediately see the results. This helps reduce errors and get products to market faster.
  • The need for quality: In order to be successful, software products must be high quality. XP practices such as test-driven development and pair/mob programming help ensure that code is of the highest quality before it is released to customers.
  • The need for flexibility: As customer needs change, so too must the software that they use. XP practices such as refactoring and customer collaboration help make sure that code is flexible enough to meet changing needs.

Ok, great, we now know what XP is, but what is it not?

So what is Extreme Programming Not?

Extreme Programming is not a silver bullet. It is a software development methodology that can be used well or badly. XP is not scrum. Scrum is an agile software development methodology that was created in the early 1990s by Takeuchi and Nonaka. While XP and Scrum share some common practices, they are two distinct approaches to software development.

Ok, so XP isn't just another name or variation of Scrum. I get that XP is its own set of software development principles, but how does that impact my team's culture?

How does XP impact a team culture?

As already covered, there are four principles in EP - Simplicity, Communication, Feedback, and Courage. These are at the heart of what it means to have a Culture of Trust. A culture of trust begets a culture of inclusion. A culture of inclusion breads a culture of innovation. And a culture of innovation creates products and solutions that provide delightful user experiences. The pinnacle of engineering culture that we all strive for.

Let's break down these 4 principles.

#1 Simplicity

To be successful, software must be easy to use. This means that the code must be simple and easy to understand. The XP practice of "You ain't gonna need it" (YAGNI) helps ensure that code is kept as simple as possible. This also has the added benefit that your code and product become self-documenting, easy to change, and easy to refactor. This keeps your tech debt levels down and allows your engineers the time, space, and confidence to innovate. Empowered and happy engineers tend to stay put, which will help your employee retention rates, too (which is always nice).

#2 Communication

For a team to be successful, members must be able to communicate openly and honestly with each other. The XP practices of "pair programming" and "mob programming" help encourage communication by requiring two or more people to work together on every* task. Naturally, people who work together closely, talk to each other frequently, form naturally stronger bonds, and as a result, are more likely to step in and help each other out when needed. Your team, as a result, become loyal to each other and care about each other, which again keeps them happy and energised and helps your retention rate (there's a theme here?).

*A little caveat here is when I say "every", it's not a hard requirement. Sometimes there are small changes that have only a single correct solution and implementation, and in those cases, solo programming is fine. The general rule of thumb is that pairs and mobs are the norms, and solo work is the exception. The reverse of what you usually see, even in teams that claim to communicate and collaborate frequently.

#3 Feedback

For a team to be successful, members must be able to give and receive feedback. The practices of "pair" and "mob" programming that drove a culture of communication as a by-product drive this culture of feedback. Feedback becomes second nature and is baked into the development cycle, which, if you want, gives you a great footing to get rid of the often large bottleneck of the peer review process. The XP practice of "continuous integration" also helps ensure that feedback is given early and often by requiring every change to be integrated into the main codebase immediately. This allows people to test out changes quickly, iteratively, and with minimal changes required when problems are surfaced, and action is required. All of this practice and giving and receiving feedback also drives engineers to become better at their craft, and engineers who are improving are generally happy, which helps your retention rates (see where this theme is going?).

#4 Courage

Successful teams must have the courage to experiment and fail. The communication and feedback culture gives engineers a sense of psychological safety that allows them the courage to innovate and refactor tech debt. Refactoring helps encourage experimentation by allowing code to be changed without breaking the existing functionality, it helps to keep your code base clean and simple, and it ultimately allows the team the confidence to change direction, change technology, and otherwise do what they need to do to succeed without the fear of legacy code and tech debt. Engineers that can innovate and try new things and don't get weighed down by the heavy burden of legacy code are ... you guessed it, happy. Which (repeat after me) helps your retention rates.

By following the Extreme Programming practices of Simplicity, Communication, Feedback, and Courage, teams can build a Culture of Trust that will help them move fast and stay happy.

Ok, but how does this scale?

Extreme Programming was designed to be a lightweight process that can scale with a team. The practices are easy to follow and don't require a lot of overhead or additional processes to implement. As a result, Extreme Programming teams can easily add new members without worrying about process overhead, and the team can continue to move fast and stay happy. The added bonus is that this simplicity can apply to multiple teams and when added up, can function just as well for an organisation of 1 team and 5 people, or of 20 teams and 100's if not 1000s of people.

So there you have it; Extreme Programming is a great way to build a Culture of Trust that will help your team move fast and stay happy. And as we all know, happy teams are successful teams. And happy, successful teams don't churn, which keeps you happy too.

What do you think? Do you agree with the points made in this blog post? Let me know in the comments below! Thanks for reading! :) . . .