Keynote: – Training Developers to do Technical Coaching; Experiences So Far

Speaker: Emily Bache

The Samman method is an approach to technical coaching pioneered and developed by Emily Bache together with members of the Samman Technical Coaching Society that she founded. The main idea is that developers improve the way they work through a combination of training and mentoring, and that the unit of change is the development team. A coach works part-time with a team hosting both team ‘learning hour’ and ‘ensemble’ sessions. (Ensemble is also known as ‘Software Teaming’ or ‘Mob programming’). The goal is to increase skill and improve code quality, at the same time as building up the team.

Recently Emily has been working with a large European software company to spread technical coaching more widely, by training developers from the organization to lead coaching sessions. Early results indicate that the teams enjoy the ‘guided learning hours’, find the topics relevant, and they want to continue. However, leading these sessions is only half the work a Samman technical coach usually does with a team. Ensemble is crucial in order to transfer good development practices into the production code. Getting these internal coaches to begin facilitating ensembles with their teams is the next step. In this talk Emily will explain what we’re doing, how it’s going and what we’re trying next.

Title:  Advocating for mob programming to leadership and throughout the organization.

Speaker: Chris Lucian

In today’s fast-paced technological landscape, the ability to rapidly adapt and innovate is paramount for any organization striving for success. This talk delves into the transformative potential of Mob Programming as a catalyst for fostering a culture of collaboration, efficiency, and continuous improvement at the leadership level within the realm of Lean Software Development. We will explore the synergy between Mob Programming and Lean principles, highlighting how this integrated approach can significantly enhance software quality, team dynamics, and overall project outcomes.

The presentation will outline effective strategies for influencing leadership to embrace Mob Programming, emphasizing the importance of demonstrating its alignment with business goals and its capacity to streamline development processes. We will discuss the key role of leadership in championing this paradigm shift, showcasing how executive buy-in can be achieved through a blend of empirical evidence, stakeholder engagement, and alignment with organizational values.

Key topics to be covered include:

• The foundational principles of Mob Programming and its compatibility with Lean Software Development.
• The strategic importance of leadership support in adopting innovative software development methodologies.
• Practical techniques for presenting Mob Programming as a solution to common challenges faced by development teams, such as bottlenecks, knowledge silos, and quality issues.
• Systems and frameworks for facilitating the transition to Mob Programming, including pilot programs, metrics for success, and feedback loops for continuous improvement.
• Real-world case studies demonstrating the impact of Mob Programming on project velocity, quality, and team morale.
• Following the presentation, there will be a Q&A session where attendees can engage with the speaker to explore further insights, share experiences, and discuss strategies for overcoming obstacles in implementing Mob Programming at their organizations.

This talk is designed for organizational leaders, software development managers, Agile coaches, and anyone interested in enhancing their software development practices through collaborative and Lean methodologies. Attendees will leave with a comprehensive understanding of how to advocate for and implement Mob Programming to drive significant improvements in software development processes and outcomes.

Title: Remote Teaming Made Easy with mob.sh

Facilitator: David Batten, co-facilitator: Chris Pipito

Originally, we practiced Software Teaming by gathering in the same place at the same time, using a single computer. This was a fantastic way to collaborate, allowing team members to share typing tasks by rotating members to the code via keyboard and mouse. But then things changed. We were suddenly thrust into a world where we could no longer effectively be in the same space. How then, could we continue to engage collaboratively with each other?

Many tools sprang to life in this new world and after trying a few, we found one we felt was the simplest and most flexible, adopted it and never looked back. That tool is known as mob.sh

If you use Git for source control and you’d like to see how quick and easy remote collaboration can be, come join us for some discussion and hands-on with my favorite remote mobbing tool, mob.sh.

If you would like to participate in some hands-on learning with the mob.sh tool, we will have little time to set everyone up live, so please be prepared with the following:

Your favorite IDE with a Python 3.x environment ready to run tests with unittest (we’re on version 3.12)

Working Git command line environment (we’re on version 2.34.1)

Latest version of the mob.sh command line tool installed (we’re on version 4.5.0). Find it here: https://mob.sh and follow the installation instructions.

Your Github account name, so we can add you to our session repo: https://github.com/battenworks/software-teaming-2024

Title: Capture the Flag Together: Security for Everyone

Facilitator: Lisi Hocke, co-facilitator: Lisa Crispin

“Security” may sound quite intimidating. It represents such a wide area of expertise. There is so much to learn, so

where to even start? If you keep wondering whether you can do this, here’s my answer: yes, you can! You already know more than you might think you do.

In this interactive workshop, we will dive right into security testing by going on a treasure hunt, searching for confidential information in the form of “flags.” This is a fun way to learn how to discover what should have been kept secret, what is needed to protect these valuable assets, and how to figure out a lot more pieces to the whole security puzzle as we go – together.

Together? Yes, you are not alone! None of us will ever know all there is to learn. Yet together, we already know more from the start and can go farther in a shorter time. Let’s study security concepts and hone our skills hands-on as we capture flags together!

Title: Sticky Mob Programming

Facilitator: Lennart Friden

So you have managed a team or two at work to try mob programming. Great! But how do you created the right conditions for it to stick? What more is needed than just introducing the concept to a group of individual developers and software creators and then let them have a go at it?

While there are no silver bullets, there are plenty of pitfalls and lessons to share and learn from. And in this session, we will do just that. Starting with a number of key factors that I believe I’ve identified, we will then open up the discussion to encompass the collective shared knowledge of the session participants to refine and identify more nuggets of wisdom that turns mob programming into a habit that sticks!

Title: Legacy Code Rehab, A Team Refactoring Adventure

Facilitator: Janina Nemec

Embark together in a group on a code refactoring journey, where you will explore and refactor a given legacy codebase with the help of a set of given guidelines.

Working alone on a legacy code base is always a difficult task, especially if no one who wrote the code is available anymore for questioning. Untested code snippets, where the business context is not clear, can be particularly challenging. So instead of tackling this challenge alone, it is very rewarding to approach this task as a whole team.

In this workshop, I want to do a software teaming session together with you. Our starting point will be a legacy code base I will provide. I will act as the driver for this session while the navigator will rotate through the other participants. Our first goal will be to bring this code base under test coverage with the help of Approval Testing. After we achieve this first goal we will start refactoring the legacy code base with the help of some refactoring guidelines to gain a better understanding and readability of the code. Our goal is to get the code into a state where we would be comfortable to add new features.

At the end of this session, you will have gained experience in refactoring a legacy code base so you can start software teaming in your own team.

Key Learnings

• Obtain knowledge of a set of refactoring guidelines

• Learn how to refactor legacy code safely

• Acquire experience in refactoring practices

Title: How Software Teaming helped unlock the potential of our organization

Facilitator: Rickard Westman

Software Teaming is becoming a go to tool for more and more development teams. But did you know Software Teaming can be powerful in setting up a scaled agile operation?

This talk will not only discuss and show real world examples of how Software Teaming solved Swedish Public Service provider SVT’s issues with redundancy and domain knowledge – but also how it opened the door to reshaping SVT’s entire development organization.

Title: Intro to Software Teaming; Playing a Simple Game

Facilitator: Woody Zuill

Software Teaming (Mob Programming) has become a widely accepted approach to teamwork in creating software, and is even being used in hardware design and manufacturing. In this session we’ll demonstrate some of the techniques used In Software Teaming by playing a simple game as a team “hands-on” with a few volunteers. Let’s have some fun while learning.

Title: Provable Refactorings – Safety without Tests

Facilitator: Llewellyn Falco, Jay Bazuzi

Often we find ourselves working with code where the functions are too long, the coding standards are inconsistent, comments are missing or out of date, and the tests are incomplete. Let’s learn how to handle that situation better.

In this hands-on class we’ll take a long, confusing method and show you multiple techniques to refactor it to clean, concise, understandable, and testable code. Commonly this is done by carefully architecting a better solution and then undertaking a rewrite of the code. That’s not what we’re going to do here. Instead, we’ll discover a better solution through a series of small, safe steps that allow you to improve the code even when you only have a little time to spend on it.     

       Learning Outcomes:

• How to Clean code without understanding it
• How to evolve code
• How to improve code without tests
• How to safety refactor without unit tests
• Inverse Provable Refactoring
• Arlo Commit Notation
• Test-Commit-Revert (TCR)
• Mob/Ensemble Programming
• Keyboard Shortcuts
• Following your nose vs. chasing a design
• The value of Obvious Nonsense names

Special Instructions: This session will have a hands-on mob and a viewing section.
If you wish to be part of the hands-on mob, you will need anydesk.

Anydesk can be installed from [here]. You will need to create an account (it is free). You don’t need to give anydesk access to your machine, but we will use it to screen share & control the development machine in the cloud. Please download ahead of time.

Title: Mini-Retros to Accelerate Adoption

Facilitator: Mike Clement, co-facilitator: Chuck Bates

Adopting software teaming/mobbing practices can be challenging. There is often a desire to “do it right”, and when what is assumed to be “the right way” doesn’t work, it can be assumed that the practices can’t work. Additionally, increased interactions among members of a group that may have previously mostly worked in individual silos will likely result in some interpersonal friction. Even with experienced “mobbers”, specific practices will likely need to be tuned to a specific environment. Even if you have regularly scheduled retrospectives, waiting a week or two for a “full size” retro is way too long.

Join us to learn how to overcome these challenges by helping a team to rapidly improve their software teaming practices through mini-retros. It’s a simple, but powerful, practice that will encourage experimentation and learning on a level that few teams achieve.