Hello, friend. Welcome to my new blog. My name is Charles Emerson, and you’re reading The Wet Run.

“The Wet Run?” you ask.

Yes, The Wet Run. The metaphorical string I’ve chosen to tie together whatever corpus of ideas, be they grandiose or frivolous, that emerge here. A theme to loosely encompass this writing as a whole.

“How is that a theme?”

Well… indulge me.

I’ve produced a lot of code lately.

To be fair, in the last year and a half or so, I’ve produced more code than I could have ever imagined producing in a decade when I first embarked on my computer science journey some years ago. IYKYK.

Anyway, as one does, when I’m working on code, I’m commonly dry running new features in a sandbox before I ship them. If I’m cautious like that, I avoid the demolition of critical databases, or the fracturing of backend pipelines I’ve poured months of work into. We dry run before we wet run, obviously.

With things moving so fast these days, though, it’s easy to get a little loose with it and skip the dry run. In computer science circles today, there’s a pervasive feeling that while every idea might not have been totally gobbled up yet, they very soon will have been. We’ve all got the sense that if we want to leave a mark on the world, we had better throw off some serious weight and sprint like hell now.

“If it goes sideways, Claude will help me fix it,” I sometimes tell myself as I commit an afternoon’s worth of unproven code to the sky with a return stroke. Many times, I’ve gotten away with it. On other occasions? Catastrophe.

Indeed, on other occasions I’ve thought I was on the verge of some beautiful algorithmic breakthrough only to realize too late that I was full-sending myself off a digital cliff; taking a suicidal dive, as it were, into a week-and-a-half-long battle for my life. A battle the duration of which I’d spend desperate just to get back to the place I was two weeks prior to having approached that precipice of arrogance in the first place.

A wet run is the real deal. No parachute.

Don’t go just yet. This blog won’t broadly be about writing code, I promise. Rather, this blog will be about writing life.

Allow me, however, to lay the foundational metaphor just a little deeper here at the outset. My non-tech friends must forgive me.

I’m starting a new blog because, at 41 years old, I finally have a little bit of life to look back on. Which I often do. I often look back and ponder at the tapestry of occurrences that have been these years.

Having recently been unburdened of certain deadening forces in my life, I’ve found myself overwhelmed by that old familiar pull to the quill. I don’t have time right now to write anything bigger, and my goals in writing are not monetary, so a blog seemed the ticket once again.

Thus I was in search of a name for this new enterprise. I came upon the name of this blog while my unquitting mind went off on one of these life-lived ponderings. I’ve had code on the brain, and during this particular ponder session, my brain spun off drawing autonomous parallels between life and a codebase.

Ponder with me.

What if life was a codebase? The metaphor grabs at me.

Imagine life as databases and class structures, functions and variables. Coder, vibe-coder, or luddite, I think you’ll all come to agree with me that, in the codebase of life, there is no “dry run.” In the repo of our years, there is no safe branch in which to iterate experiments the way a developer can with a bunch of Kotlin or Python.

There is only the main branch.

Anything committed goes straight to production.

I shudder at the thought. The complication is compounded by the fact that, as the programmers of our lives, we can never stop coding. Whether you want to or not, we’re writing code all day every day. Every little decision we make is a new character or a new line, and commits happen randomly, automatically, and often.

In life, we can’t dry run huge decisions against different argument scenarios to get a dataset informing our next move.

You can’t pass the function takeOfferedJob() “true” in one terminal and “false” in another and then decide which one worked better and run with that henceforth.

Nope.

You will feed that function one argument one time.

You’re going to take that job or you’re not.

Just the same, you can’t pass little bits of sacrifice into riskToFindDestiny(), running it over and over incrementally until you find the bare minimum set of sacrifices you can make such that it outputs greatness.

If only life were so easy.

No.

You’ll decide what you’ll risk to meet destiny essentially blind, and you won’t be warned before the function fires. Get your arguments in before it does, or forever hold your peace.

The remainder of life is encoded with every decision, no matter its perceived consequence in the moment. And there’s no way to test what the cascade of outputs will be, one way or another, or for how long they will be palpable in the execution. There’s no way to tell which little sign error will amount to nothing and which will cause a complete global meltdown of your system years later when you least expect it. There’s no history of structured commits to roll back to. Each moment, once lived, is inextricably embedded.

No dry runs.

A developer’s nightmare.

If life is a codebase, it is of this very nature, and we’re all bound to it. Today is happening once, right now. Yesterday is gone and unrecoverable. There’s no analog for practice. There are no do-overs. The seconds tick by us in perfect rhythm, and each one takes what we’ve written in it and adds it to the build.

If we’re focused and aware, what we fill the majority of our seconds with are nobility and truth, faith and love. Good, safe, well-commented code.

If we’re sloppy and myopic, though, sometimes what we fill just a few ticks of the system clock with can destroy functionality that took years to build, or poison our codebases such that no subsequent function ever works quite as well as it could have.

You’re with me now, yeah?

This is the Wet Run.

And baby, this life is all wet run, all the time.

So consider this my attempt at commenting anew in my codebase, having realized my attempts in previously shipped years were at best sloppy, and at worst, diabolically misleading.

I’ll use this theme, this format, this writing, to comment my codebase as it sits today, sign errors, mangled class headers and all.

I can’t promise to keep the subject matter on a narrow path, but I promise to always pay credence to the titular theme: the precarious nature of life.

For now, if you dig this vibe, I just ask that you join me in thinking about the moments of life and what we’re writing into them. Join me in noticing how fast they go. Let us perceive how the outputs we get match the arguments we pass - how a moment of discernment, though it requires our focus and effort, can yield a great bounty, or prevent catastrophe.

I hope you’ll find just cause to come back and see what I produce here.

I think this will suffice for an introduction.

Peace and love, friends.

Claude, commit and push.