TL;DR: Programming isn't just about writing code; a significant part involves debugging. However, traditional debugging methods are time-consuming. At RedCorner, we focus on using unit tests for more efficient and accurate debugging. Good developer experience is crucial, and we aim to optimize it with specific benchmarks like quick setup times and rapid test runs. RedCorner offers audits and action plans to transform your team's development experience.
Hey there! Ever heard the joke, "Only half of programming is coding, the other 90% is debugging"? Well, in some bizarre world, that math actually makes sense. Today, I want to chat about a topic close to every developer's heart: the ever-so-tricky art of debugging.
Debugging: A Necessary Evil
Every programmer knows that debugging isn't just a part of the job; it's practically an art form. Each system has its own quirks, and every team has unique policies about how to tackle bugs. But let's be honest: the classic approach to debugging in software development feels a bit... archaic. Sure, we can attach a breakpoint and step through the code to see where things go awry. But, wow, isn't that a snail-paced process?
The RedCorner Approach: Unit Tests Over Traditional Debugging
Enter RedCorner, the team I work with. We're often called in to lead and manage development teams, and we've got a somewhat unorthodox approach: we prioritize unit tests over traditional debugging. Why? Because it's faster, more productive, and, when done right, more accurate.
The Power of Unit Testing
Whether you're a fan of Test-Driven Development (TDD) or not, there's no denying the efficiency of unit tests. They can save you hundreds of hours that would otherwise be spent on debugging once you get the hang of them. But the catch is that writing these tests needs to be easy, running them simpler, and your setup responsive enough to provide almost instant feedback.
Crafting the Perfect Developer Experience
The first thing we do at RedCorner when we onboard a new team is to assess the developer experience. A smooth, friction-free dev experience is key to getting the team on board with our processes. Every solution is unique, so I won't dive into specifics here (that's for another video). Instead, let me share with you the minimum key performance indicators (KPIs) we aim for to create an optimal dev experience:
From Zero to Coding (New Setup): 10 minutes
From Zero to Coding (New Branch): 30 seconds
Unit Test Run: 5 seconds or less
Local DB Migration: 5 seconds or less
Local DB Seeding: 5 seconds or less
These benchmarks might seem a bit ambitious, but with the right scripting and automation, they're totally achievable. And trust me, your developers will thank you for it.
The Role of Leadership in Developer Experience
As a CTO, VP, Director, or Engineering Manager, it's your job to ensure that your teams' dev experience is as seamless as possible. The goal is to make the job easy enough that when your team works hard, they produce more. You want to avoid a scenario where the job is hard and progress is slow.
How RedCorner Can Help
Worried about your team's developer experience? That's where RedCorner steps in. We can conduct a thorough audit for you, present an action plan, and even assign an interim Fractional CTO (FCTO) to oversee your team's transformation into an engineering powerhouse.
So, if you're ready to take your team to the next level, RedCorner is just a call away. Let's make debugging less of a chore and more of a strategic, efficient process. Together, we can create the best engineering team in the world!
Remember, programming isn't just about writing lines of code; it's about solving problems efficiently. And sometimes, the best solution lies in rethinking our approach to debugging.