I spent this morning sitting by the woodstove, watching the frost cling to the bare branches of the oak trees outside my window. The winter here has a way of quieting the noise of the world, making it the perfect time to pick up my acoustic guitar. I was noodling around with a simple 12-bar blues progression in E, trying to get the feeling just right.
In the blues, there’s a concept called “call and response.” The guitar sings a line—the “call”—and then you leave a little space before the piano or the harmonica answers back. If the answer comes too early, you step on the melody. It creates dissonance. It feels rushed.
As I set the guitar down and walked over to my standing desk to look at some Dart code I’ve been wrestling with, it hit me: this is exactly how we build resilient, joyful software.
You see, back when I was fixing computers in the Army, or even later when I was a VP in charge of designing a massive enterprise system, the goal was always stability. But as a Liberation Technologist entering 2026, the goal is something deeper: harmony.
In modern app development, we use something called asynchronous programming—often dealing with “Futures” or “Promises.” It’s the digital version of that blues progression. One part of your system requests data (the call), and the server eventually sends it back (the response). The trick is orchestrating these moving parts so they don’t crash into each other. If your app freezes up while waiting for an answer, that’s a race condition. That’s the piano player stepping on the singer. It breaks the immersion.
When we orchestrate these calls correctly, we create “system harmony.” The app runs smoothly without hanging. It’s a resolved chord progression. And for me, there is a profound geeky joy in making that happen. It’s not just about making the machine work; it’s about making it sing.
But how do we get there? We don’t play the song perfectly the first time. In music, we “woodshed.” We isolate the difficult measures—the clumsy fingerpicking pattern or the tricky chord change—and we play them slowly, over and over, until they are fluid.
In my 35 years of engineering, I’ve learned that coding is no different. We call it “refactoring.” You take a clumsy, “brute force” function that you wrote at 2:00 AM, and you polish it. You strip away the noise. You make it elegant. You make it performant.
This is where the “Liberation” part of my self-proclaimed, retirement title comes in. I am not just refactoring for the sake of clean code; I am refactoring for freedom. Bloated, inefficient software drains our batteries, steals our data, and wastes our time. Elegant, efficient software respects the user. It acknowledges that technology should serve us, not the other way around.
As the “Architecture of Resistance” report suggests, we are moving toward a “Techno-Moral Synthesis” where we use the arts—like music—to heal and connect. When I refactor a piece of code to be more privacy-focused or more efficient on a mesh network device, I feel like I’m contributing to that synthesis. I’m tuning the instrument of the internet so it plays a cleaner sound.
I try to apply this “refactoring” mindset to my health, too. Recovery has taught me that I don’t have to be perfect; I just have to be willing to look at the “buggy” parts of my routine and polish them. Maybe I need more sleep. Maybe I need to step away from the screen and chop some vegetables for a stew. It’s all part of the maintenance.
So, here is my hope for you today: Don’t be afraid of the rough draft. Whether you are learning a new chord, writing a new script, or trying to build a new habit, give yourself permission to “woodshed.” Isolate the tricky parts. Practice the call and response. Find that rhythm.
When we pursue elegance in our tools and our lives, we aren’t just being productive; we are claiming our freedom. And let me tell you, that sounds like music to MY ears.
