If I think back a number of years, I can remember sitting in a software shop and feeling like the iconic stranger in a strange land. I valued writing clean code, practicing TDD, refactoring away from procedural, legacy cruft, and generally improving my craft. This was not otherwise common. There were architects in that place that were long on seniority and opinions but short on chops, and they really, really liked them some global state. And class size? The bigger the better.
I seriously felt like I was in some kind of weird, parallel reality. We’d have lunch & learns and watch things like Uncle Bob videos or talks from Channel 9 or whatever, and I would leave thinking that some kind of brainwashing A/B trick had resulted in me watching a different video from everyone else. It was discouraging.
I made progress in fits and starts. I’d refactor a method here, kill a singleton there, inject an interface here, delete some dead code there. But, then I’d go for a long weekend trip and come back to find a new singleton with more global state than its recently deceased cousin. It was two steps forward and one step backward on a good week. Like wading upstream against a raging, waist-high river, it was slow, exhausting progress.
I remember thinking that it’d be great if I could plead with one of the speakers in the video to come in and talk to people in this shop. Maybe if one of the folks from the video was there, speaking live to them, something would finally get through. Or maybe the video hero would take pity on me and offer me a job. But I also knew that this was a pipe dream because hiring a consultant like this would be wildly expensive.
A lot of years have passed since then, and my life has evolved considerably. I make most of my living doing coaching and helping improve software development craft. Other parts of my living come from making videos and writing books about the same. And through it all, I’ve never forgotten that feeling — a feeling with which, I’d imagine, many reading are familiar.
I’ve recently piloted with great success a new coaching model. Think of the Chess TDD series, but imagine that instead of building a (non-trivial) toy application, I was doing a codecast in which I refactored some nasty legacy method in your code base to make it testable and narrated over it, explaining what I was doing and why. The beauty of this approach is that we can pick some problems that are representative of your code base, and you can refer to the videos for context when doing refactorings from then forward.
This has proven to be a good option for small shops because it’s low touch. It doesn’t require much if any synchrony, and, perhaps more importantly, it doesn’t require flights, hotels, a multi-day engagement fee with opportunity cost, or advanced schedule clearing. It’s really just a matter of billable hours, which winds up being something like three hours per hour of video footage. And five-ten hours of video footage is a surprisingly large, helpful amount.
Think of it this way. It’s like someone recording a Pluralsight course wherein they refactor your code. So if you’re reading this, and you think your code base and/or team could use a kick in the pants, feel free to reach out, even if it seems like a long shot. There’s no charge for us to talk and even for me to sign an NDA and take a look at your code. You can tell your boss or whomever that I really just kind of jump into problem solving mode and only start to think about billing arrangements once I’m convinced that I can contribute meaningful value to you.
Because, honestly, it’s also a lot of fun.