The Power of Pairs

This ad is not shown to multipass and full ticket holders
JSNation US
JSNation US 2025
November 17 - 20, 2025
New York, US & Online
See JS stars in the US biggest planetarium
Learn More
In partnership with Focus Reactive
Upcoming event
JSNation US 2025
JSNation US 2025
November 17 - 20, 2025. New York, US & Online
Learn more
Bookmark
Rate this content

Engineering team often face difficult challenges with constrained resources. If the job requires 1 engineer, we put one on the job. If it requires 2, we split topics into actionable chunks and assign them to individuals.


But there are several benefits to do things in pairs: It helps to catch errors and bugs, it allows for better communication and collaboration between team members and it can also lead to more efficient and higher-quality code, as engineers can challenge their peer's assumptions and suggest alternative approaches.

This talk has been presented at TechLead Conference 2023, check out the latest edition of this Tech Conference.

FAQ

Pair programming is a collaborative software development technique where two developers work together at one workstation, sharing a keyboard and mouse. One developer, the 'driver,' writes the code while the other, the 'navigator,' reviews the code and suggests improvements.

The benefits of pair programming include improved code quality with fewer bugs, enhanced knowledge sharing and growth opportunities among developers, increased team morale, and overall productivity gains.

Challenges of pair programming include perceived inefficiency in resource use, difficulty in finding compatible partners with complementary working styles, resistance to change from developers accustomed to working alone, and the need for effective communication.

While pair programming might seem less cost-efficient due to two developers working on a single task, studies suggest the practice can offset initial costs by reducing maintenance needs, decreasing bug rates, and speeding up code reviews and testing phases.

Pair programming allows developers to share knowledge directly by discussing code in real-time, providing immediate feedback, and explaining complex concepts or techniques, which facilitates rapid learning and skill development.

Pair programming is particularly useful for complex tasks that require significant brainstorming, for onboarding new team members by providing them hands-on learning, and for tackling parts of the project that benefit from diverse expertise.

Best practices include rotating roles between the driver and navigator to balance workload, maintaining clear communication, minimizing distractions, taking regular breaks to prevent fatigue, and keeping a positive and open-minded attitude during sessions.

Overcoming resistance can be addressed by involving team members in the decision-making process, starting with short, focused sessions to gradually introduce the practice, and providing necessary training and support to ease the transition.

Effective implementation of pair programming involves selecting the right pairing based on task complexity, preparing the necessary tools, setting clear goals and expectations, and fostering a positive environment with good communication practices.

Octave Raimbault
Octave Raimbault
21 min
09 Mar, 2023

Comments

Sign in or register to post your comment.
Video Summary and Transcription
Pair programming is a collaborative software development technique where two developers work together at one workstation. It offers benefits such as easier code maintenance, faster code reviews, and reduced likelihood of bugs. Implementing pair programming involves finding compatible partners, setting goals, and establishing clear communication protocols. To address challenges, provide training and support, involve team members in decision-making, and carefully select partners. Pair programming can help achieve goals like collaboration, knowledge growth, code stability, and maintenance.
Available in Español: El poder de los pares

1. Introduction to Pair Programming

Short description:

Hello, and welcome to the Power of Pairs, a talk about pair programming. Pair programming is a collaborative software development technique where two developers work together at one workstation sharing a keyboard and a mouse. The two developers, who participate in pair programming, are equal partners, each with its own responsibilities.

Hello, and welcome to the Power of Pairs, a talk about pair programming. My name is Octave and I'm a software engineer at Datadog. I've been a software engineer for the last eight years and this presentation is based on both my personal experience as well as some research papers and articles available online.

Let's start with a quick introduction for those who are not yet familiar with pair programming. Pair programming is a collaborative software development technique where two developers work together at one workstation sharing a keyboard and a mouse. The two developers work together to complete a task such as implementing a feature, fixing a bug, or writing tests. One developer, the driver, is responsible for writing the code while the other developer, the navigator, reviews the code, provides feedback, and suggests improvements. The two developers, who participate in pair programming, are equal partners, each with its own responsibilities. It is much like the team of a rally car, with the driver maneuvering the car very precisely, while its partner is focusing on the map, and giving the driver a heads-up about turns and other road specificities. The two roles complement each other and are equally important.

2. Benefits and Challenges of Pair Programming

Short description:

Let's now have a look at some compelling arguments as to why you might be interested in pair programming in your team habits, and also as counter-arguments. There are many upsides to pair programming and they will vary depending on the specificities of your organization. Nevertheless, here are some of the most common and sought-after benefits of pair programming. As code is thoroughly reviewed and built combining the knowledge of two engineers, it is likely to be easier to maintain and less likely to cause errors and bugs.

Let's now have a look at some compelling arguments as to why you might be interested in pair programming in your team habits, and also as counter-arguments. There are many upsides to pair programming and they will vary depending on the specificities of your organization. Nevertheless, here are some of the most common and sought-after benefits of pair programming.

As code is thoroughly reviewed and built combining the knowledge of two engineers, it is likely to be easier to maintain and less likely to cause errors and bugs. As developers spend more time sharing thoughts and practices, as well as witnessing their teammates' developing practices, they provide growth opportunities for one another. It can have a very positive impact on morale, as teammates spend more time together and bond over professional activities. It may involve one individual intervening on a part of the product they are not responsible about, which gives them an opportunity to ask questions and learn about it. Finally, when taking a holistic look at productivity, pair programming will frequently have a positive impact, and we will talk again about that later in the presentation.

There are also some downsides and challenges. They can have an important impact on the outcome of your pair programming sessions. The first and by far the most frequent argument is that pair programming is not cost-efficient. A study from two researchers at Microsoft says that there was considerable, quote, skepticism that having two people working on one task is a good use of resources. And later on, that manager buy-in was also challenging, with one of the managers stating, quote, if I have a choice, I can employ one star programmer instead of two programmers who need to code in pair. This is something we'll talk about again later in this presentation, as it can be arguable and there are different figures to look at. Another issue is finding partners who work well together. Team members may have different working styles, preferences, personalities and cultures that can make it difficult to find a compatible partner. Resistance to change is another one. Some developers may resist the change to pair programming and prefer to work alone. This can be a significant challenge, especially if team members are not used to collaborate closely with others. For example, they may feel like they are being watched over or micromanaged when they are in the driver seat. Finally, effective communication is crucial for pair programming, and so it can also be a challenge, especially if team members have different communication styles or preferences. Personally, I've had the experience with multicultural teams where it sometimes increases the risk of not properly communicating, as you may not be sensitive to the same words and meanings and attitudes as the other party. These challenges are definitely valid arguments, and later in this talk, we'll mention ways to address and try to mitigate their impact.

To add some context and practical figures, here are some of the feedbacks gathered in a study done at Microsoft in 2007. These are the top 5 most brought up arguments in favor and against pair programming, with a score representing how often these arguments were brought up by the people in the study. This is of course a single study, and others may be in different rankings and items, but I think this one gives you a pretty accurate representation of how developers feel about pair programming overall. I want to take some time and address the cost argument. As we saw that it is by far the biggest worry. Let's first start by saying that it would be most often wrong to think that it doubles the cost. This is because you very often do not spend a full development cycle in a pair programming situation.

3. Benefits of Pair Programming

Short description:

Pair programming is a practice that pays off when you consider the costs that can be avoided or reduced. It allows for faster code reviews, quicker testing, and reduces the likelihood of bugs. It also increases team familiarity with the code base and reduces maintenance and future development times.

A study from the University of Utah showed that the overall increase in development time was around 15% on the dataset that they had. Moreover, just like investing in refactoring can be beneficial for the long-term benefits of the organization and the codebase, pair programming is a practice that pays off when you look at all the costs that can be avoided or reduced. For example, the additional time invested in development will allow for faster code reviews, since the reviewer will be more familiar with the parts that are being changed. Testing the changes is also quicker, as developers are more aware of the intent behind the code, and can easily test the different scenarios impacted by the modifications. Bugs are also less likely to arise, since the work has been cross examined very thoroughly, and had two different mindsets applied to it. Finally, this practice increases the team familiarity with a broader scope of the code base and the product. Consequently, maintenance and future development times are reduced. When you take all those costs and add them up, and compare them to the initial investment that you had on the development part, they can either balance the initial cost or completely reimburse it and even make you gain time. This makes pair programming an investment that, just like investing in technical depth, will benefit the team over time. I hope this part about why you may want to give a try to pair programming was convincing enough.

4. Implementing and Improving Pair Programming

Short description:

Pair programming is a great way to tackle complex tasks, share knowledge, onboard new team members, and foster collaboration. To implement it, find the right match, prepare necessary tools, set goals and expectations, plan the session, rotate roles, and establish clear communication protocols.

Let's now go over how you can implement or improve pair programming in your organization. First of all, we should look at what are good opportunities to apply programming and when to use it. Pair programming can be a great way to tackle complex tasks or problems that require a lot of brainpower. By working in pairs, team members can bounce ideas of each other, brainstorm solutions, and catch mistakes before they become larger problems. By pairing team members with different areas of expertise, team members can learn and develop new skills, becoming more well-rounded developers.

Pair programming can be an effective way to share knowledge and skills among team members, and it's not just for new developers or junior programmers. In fact, experienced developers can also benefit from pair programming, as it can provide a fresh perspective on a problem and lead to new insights and solutions. Pair programming is also a great way to onboard new team members. By pairing team members with more experienced members, new team members can learn the codebase, the development practices of the workplace, and the workflows while working side by side with one of their new teammates. Finally, pair programming can simply be used as a very good excuse to spend more time with co-workers. Spending more time together and investing that time toward a common goal helps teams build camaraderie, improve communication, and foster a culture of collaboration and learning.

Here are a couple of steps to bootstrap your first pair programming sessions. First, you need to find the right match for the topic you'll be working on. Do it based on why you chose to do a pair programming session, for which we showed ideas in the previous slide. For example, if your opportunity for pair programming is to onboard a new team member, you may want to pick a partner with a good product understanding and a knowledge of a broader part of the code base. If you decided to work on a complex task, on the other hand, you should probably choose people with specialized skills and in-depth understanding of the part of the product you'll be working on. Next, prepare the necessary tools to get the job done. Remote teams may benefit from a conference tool such as Zoom, and from an advanced IDE with collaboration features such as Visual Studio Code and its Live Share feature. For on-site teams, you will need a quiet space, such as a conference room, and you should leverage simple tools, like a drawing board. Once you have all this, clearly set the goals and expectations. Should you have a valid pull request by the end of the session? Or are you in an earlier phase of development where you just want to get the groundwork done and plan? What are both parties expecting to learn from the session? You should probably find key success metrics to ensure that you will not lose time or be diverging during the session. Finally, plan the session ahead of time and limit it to a reasonable amount of time. A session should usually last 30 to 60 minutes. You can use the Pomodoro technique to help you set the appropriate amount of time and be reminded about regular breaks. To make the most of pair programming during the session, it is important to follow some best practices. First, rotate roles regularly. To ensure that both team members have an opportunity to contribute and learn, it is important to rotate roles on a frequent basis. This allows each team member to experience different aspects of the process such as writing the code or giving direction, and it also helps to ensure that both team members stay engaged and avoid getting stuck. Establish clear communication protocols. Clear and effective communication is essential for the success of pair programming.

5. Effective Pair Programming

Short description:

Teams should establish clear protocols for communication and a common language. Avoid distractions and take regular breaks to prevent burnout. Stay positive and open-minded to encourage collaboration.

Teams should establish clear protocols for communication, including things like how to ask for help, how to offer feedback, and how to handle disagreements. It is also important to establish a common language and terminology to ensure that both team members understand each other.

Avoid distractions. Turn off notifications and apps that may require your attention during the meeting. Make sure that you are not expected to respond quickly to anything, such as an issue in production. The navigator role here is also to make sure that they don't get sidetracked by something in the code or the product, and stay on the road. If you happen to discover something that is not related to the target during the meeting, take a note and go back to it after the session.

Take regular breaks. Pair programming can be intense, and it's important to take regular breaks to avoid burnout. Teams should take short breaks every hour or so to rest, stretch, and recharge. This can help improve focus and productivity and prevent fatigue or boredom from setting in.

Finally, stay positive and open minded. Pair programming requires a positive and open minded attitude. Teams should encourage each other to stay positive and avoid negative criticism or blame. Instead, focus on finding solutions together and learning from mistakes. A positive and supportive attitude can help to build trust and encourage collaboration, leading to better results. And of course, this doesn't limit to only the pair programming session.

6. Challenges and Implementation of Pair Programming

Short description:

Let's address some common challenges of pair programming: finding compatible partners, resistance to change, skill and experience, and engineering structure. To address these challenges, provide training and support, involve team members in decision-making, carefully select partners, and plan pair programming sessions carefully. Pair programming is just a tool, but if chosen, introduce it gradually, seek feedback, and reassess regularly. It can help achieve goals like team collaboration, knowledge growth, code stability, and maintenance.

Let's address now some common challenges of pair programming and how they can be addressed. Finding compatible partners. One of the biggest challenges of pair programming is finding people who work well together. Team members may have different working styles, preferences or personalities that can make it difficult to find a compatible partner. To address this challenge, it is important to provide training and support for teams to improve their pair programming skills and to help them learn to work effectively with others. It can also be helpful to encourage new team members to try working with different partners to find a good fit.

Resistance to change Some developers may resist the pair programming aspect and prefer to work alone. This can be a significant challenge, especially in teams where members are not used to collaborating closely with others. To address this challenge, it's important to involve team members in the decision-making process and to provide training and support to help them become more comfortable with the technique. It can be helpful to start with short, focused sessions, and gradually increase the amount of time spent in pair programming, once you validate the practice and notice that it is well received by the team.

Skill and experience is also a challenge. This challenge is about ensuring that both team members have the necessary skills and experience to work effectively with the other. This can be addressed by carefully selecting partners with complementary skills, as we've shown previously. And by providing training and support to help team members develop the necessary skills. Finally, engineering structure. It is common in an engineering or product department to break teams down into task forces dedicated to specific product investment. And this is a very valid practice to improve productivity and help people focus on a few tasks. But from a personal experience, this also creates silos in which you might not have many pairing opportunities. As often, you only have one or two engineers in your specialty working on the same topic. This means that you will need to seek people working on other topics and initiatives to pair program. In order to do it without putting their project at risk, you need to plan and time-box very carefully. You also need to avoid doing that during tough times, like situations where they have a very strong deadline. You may also offer to do a session of pair programming on their initiative afterward. This will put things in balance and in the end, both developers will be more aware of both topics.

Before I leave you with the next speakers, I'd like to share some closing thoughts. Pair programming, in the end, is just a tool. You may choose to use it or not. If you choose not to, you'll have to use other tools to achieve the same goals that you set for your team and organization, such as building a strong team collaboration, growing knowledge, and ensuring the code stability and maintenance. However, if you do choose to use it, you need to introduce it just like you would any other tool. You'll first need to clearly communicate with your team about what it may bring, and seek their buy-in. You'll then need to gradually implement it in a way that works for them, and for your organization. You'll need to regularly seek feedbacks and reassess along the way. And if you're successful, then your team will have one more tool to its belt that it can use to sheet better code and to work better together. This talk was about helping you take that decision with the belief that there are many scenarios in which you should give it a shot. However, I also encourage you to do your own research and read some papers available online to prepare for the task ahead. I hope you liked this talk. Thank you for listening to it.

Check out more articles and videos

We constantly think of articles and videos that might spark Git people interest / skill us up or help building a stellar career

Impact: Growing as an Engineer
React Summit 2022React Summit 2022
26 min
Impact: Growing as an Engineer
Top ContentPremium
This Talk explores the concepts of impact and growth in software engineering. It emphasizes the importance of finding ways to make the impossible possible and the role of mastery in expanding one's sphere of impact. The Talk also highlights the significance of understanding business problems and fostering a culture of collaboration and innovation. Effective communication, accountability, and decision-making are essential skills for engineers, and setting goals and finding sponsors can help drive career growth. Feedback, goal setting, and stepping outside of comfort zones are crucial for personal development and growth. Taking responsibility for one's own growth and finding opportunities for impact are key themes discussed in the Talk.
On Becoming a Tech Lead
TechLead Conference 2023TechLead Conference 2023
24 min
On Becoming a Tech Lead
Top ContentPremium
The role of a Tech Lead involves shaping the roadmap, helping the team be more effective, and working on important projects. Lessons learned include encouraging idea sharing, avoiding taking on all the work, and focusing on delegation. Tech Leads focus on the outcome, involve the team in decision-making, and make plans based on how different pieces will interact. The role of a Tech Lead is to focus on engineering and guide the team in figuring out how the whole system should fit together. Architecting can become problematic when it loses touch with the coding part, resulting in implementation issues.
A Framework for Managing Technical Debt
TechLead Conference 2023TechLead Conference 2023
35 min
A Framework for Managing Technical Debt
Top ContentPremium
Today's Talk discusses the importance of managing technical debt through refactoring practices, prioritization, and planning. Successful refactoring requires establishing guidelines, maintaining an inventory, and implementing a process. Celebrating success and ensuring resilience are key to building a strong refactoring culture. Visibility, support, and transparent communication are crucial for addressing technical debt effectively. The team's responsibilities, operating style, and availability should be transparent to product managers.
Principles for Scaling Frontend Application Development
React Summit 2023React Summit 2023
25 min
Principles for Scaling Frontend Application Development
Top Content
Watch video: Principles for Scaling Frontend Application Development
This Talk discusses scaling front-end applications through principles such as tearing down barriers, sharing code in a monorepo, and making it easy to delete code. It also emphasizes incremental migration, embracing lack of knowledge, and eliminating systematic complexity. The Talk highlights the use of automation in code migration and the importance of removing barriers to enable smoother code migration.
Fighting Technical Debt With Continuous Refactoring
React Day Berlin 2022React Day Berlin 2022
29 min
Fighting Technical Debt With Continuous Refactoring
Top Content
Watch video: Fighting Technical Debt With Continuous Refactoring
This Talk discusses the importance of refactoring in software development and engineering. It introduces a framework called the three pillars of refactoring: practices, inventory, and process. The Talk emphasizes the need for clear practices, understanding of technical debt, and a well-defined process for successful refactoring. It also highlights the importance of visibility, reward, and resilience in the refactoring process. The Talk concludes by discussing the role of ownership, management, and prioritization in managing technical debt and refactoring efforts.
Effective Communication for Engineers
TechLead Conference 2023TechLead Conference 2023
36 min
Effective Communication for Engineers
Top ContentPremium
Today's Talk covers the four building blocks of communication: people, message, context, and effective listening. It emphasizes the importance of considering the perspective of others and tailoring messages to the recipient. The Talk discusses different types and channels of communication, and the need to align them with the intended message. It also highlights the significance of soft skills in communication and provides techniques for effective communication and assessing soft skills in tech interviews. Cross-cultural communication and the impact of bluntness are explored as well.

Workshops on related topic

From Engineer to Leader: A Workshop for First-Time Tech Leaders
TechLead Conference 2024TechLead Conference 2024
144 min
From Engineer to Leader: A Workshop for First-Time Tech Leaders
Workshop
Andrew Murphy
Andrew Murphy
Transitioning from an individual contributor role to a leadership position, especially in the fast-paced tech industry, is hugely challenging. Most new leaders don't receive any training at all in the first 10 years of their new responsibilities.Our comprehensive workshop is designed to assist new and emerging tech leaders in understanding their new roles and gaining the skills to make them confident, happy and effective leaders.
Managers Are From Mars, Devs Are From Venus
TechLead Conference 2024TechLead Conference 2024
111 min
Managers Are From Mars, Devs Are From Venus
Workshop
Mo Khazali
Mo Khazali
A Developer’s Guide to Communicating, Convincing, and Collaborating Effectively With Stakeholders
It’s a tale as old as time - collaboration between developers and business stakeholders has long been a challenge, with a lack of clear communication often leaving both sides frustrated. The best developers can deeply understand their business counterparts’ needs, effectively communicate technical strategy without losing the non-technical crowd, and convince the business to make the right decisions. Working at a consultancy, I’ve both failed and succeeded in architecting and “selling” technical visions, learning many lessons along the way.Whether you work at a product company, are a consultant/freelancer, or want to venture beyond just being a developer, the ability to convince and clearly communicate with stakeholders can set you apart in the tech industry. This becomes even more important with the rise of GenAI and the increasingly competitive developer market, as problem-solving and effective communication are key to positioning yourself.In this workshop, I’ll share real-world examples, both good and bad, and guide you through putting the theory into practice through dojos.
How To Design A Sustainable Freelance/Contracting Career
Node Congress 2022Node Congress 2022
39 min
How To Design A Sustainable Freelance/Contracting Career
Workshop
Shane Ketterman
Alexander Weekes
2 authors
Ready to kickstart your freelance career or just getting started on your freelance journey? You’re in the right spot. Learn the tricks of the trade from the industry’s most experienced freelancers.
The independent talent movement is the future of work. If you’re considering leaving full-time employment for a career as a freelancer, now is the time to find your successful space in the independent talent workforce. More people are working freelance today than ever before, with the freelance marketplace now contributing $1.2 trillion to the US economy. Some of the most in-demand roles for freelancers right now are senior developers with professional experience in React, Python, Blockchain, QA, and Node.js.
This workshop will help you design a sustainable and profitable full-time (or part-time) freelancing/contracting career. We will give you tools, tips, best practices, and help you avoid common pitfalls.
Designing A Sustainable Freelance Career
React Advanced 2021React Advanced 2021
145 min
Designing A Sustainable Freelance Career
Workshop
Alexander Weekes
Rodrigo Donini
2 authors
Would you like to pursue your passions and have more control over your career? Would you like schedule and location flexibility and project variety? Would you like the stability of working full-time and getting paid consistently? Thousands of companies have embraced remote work and realize that they have access to a global talent pool. This is advantageous for anyone who has considered or is currently considering freelance work.>> Submit your interest on becoming a freelance engineer with Toptal and get a call with Talent Acquisition specialist <<

Freelancing is no longer an unstable career choice.

This workshop will help you design a sustainable and profitable full-time (or part-time) freelancing career. We will give you tools, tips, best practices, and help you avoid common pitfalls.
Table of contents

Module 1: Dispelling common myths about freelancing
Module 2: What does freelancing look like in 2021 and beyond
Module 3: Freelancing choices and what to look for (and what to avoid)
Module 4: Benefits of freelancing from a freelancer + case study
BREAK
Module 6: How to get started freelancing (experience, resume, preparation)
Module 7: Common paths to full-time freelancing
Module 8: Essentials: setting your rate and getting work
Module 9: Next steps: networking with peers, upskilling, changing the world
Module 10: Freelancer AMA
Out of the Frying Pan, Into the Fire: A Manager's Guide to Helping New Developers Thrive
TechLead Conference 2024TechLead Conference 2024
35 min
Out of the Frying Pan, Into the Fire: A Manager's Guide to Helping New Developers Thrive
Workshop
Andrew Coleburn
Andrew Coleburn
Onboarding to a new project can be difficult, no matter your background and experience. But it can be especially challenging for new developers straight out of school or a coding bootcamp. Drawing on personal experience as a bootcamp grad and JavaScript consultant, this talk will discuss tips and strategies for managers to help the new developers on their teams get their bearings in an unfamiliar codebase, so they can make more of an impact, faster!