A Blog for the Uninitialized

Should dependencies always be kept up to date?

Tue, 19 May 2026 17:21:43 -0700

Something came up at work today related to the topic I discussed yesterday.

Should dependencies always be kept up to date?

I work in the Developer Experience (DevX) realm right now, and the current perspective on handling the potential security concerns that Mythos is highlighting is that we should immediately update all code (third party) dependencies to their respective, latest versions.

While that perspective is valid for my company right now (there’s so much more to the story there), this isn’t always a valid perspective to take.

Just because you can doesn't mean you should

Mon, 18 May 2026 19:36:33 -0700

Everyone today is, and I say this begrudgingly, rightfully concerned about the new Mythos model announced by Anthropic this past week.

Basically this model is quite advanced to the point where it is discovering bugs and “zero day” (aka unknown) issues on 30 year old tooling that no one has touched for years.

Which is alarming.

I suppose.

At least I know my company is currently freaking out about it. As is nearly every other company inundated with massive amounts of tech debt who have willfully turned a blind eye to it for literal years. Suddenly we all have only six weeks to get ourselves prepared for this (dystopian?) future.

There's a (real) problem with AI compute

Wed, 06 May 2026 16:13:14 -0700

I’ll make no apologies for being an AI skeptic. I maintain that position today, despite being an active subscriber of Google’s Gemini AI. I really like it for guided learning.

Regardless, the primary problem coming for AI is very similar to what caused some issues during the early days of the internet. Back then, the internet was new and companies were scrambling to build a bunch of high throughput fiber optic cable across the US.

A word about company loyalty

Thu, 02 Apr 2026 12:47:15 -0700

Early in my career, I was given a great piece of advice. Advice that I’ve recently lost track of following, unfortunately.

You can be as loyal as you want to a company, they will never be loyal back.

I think it goes without saying in today’s environment, but I think it’s important to reiterate again.

Today, Oracle laid off 30,000 employees, many of whom have been there 30 or more years!

Interviewing in Europe vs the US

Sat, 21 Mar 2026 16:08:11 -0700

Over the last several years, my spouse and myself have often considered the prospect of leaving the USA for somewhere in Europe. We both love to visit and vacation there, and despite the significantly reduced salaries by comparison, people are consistently rated as being happier with their lives.

The EU has stronger labor laws.

This manifests itself in a few ways that maybe you wouldn’t consider.

When interviewing for a European-based company, and one that isn’t necessarily an offshoot of an existing company based out of the US, job interviews tend to be more formal and a bit more tech-direct skills (i.e., not soft skills) focused.

Jensen Huang on AI Layoffs

Fri, 20 Mar 2026 16:56:02 -0700

This is my commentary from a blog post I found here.

Jensen Huang is the current CEO for Nvidia, the man being credited with taking the company to stratopheric heights in the last 10 years. This is mainly because Nvidia creates the best GPUs that are used in the core model training algorithms for anything AI related.

What I wanted to quickly write about was about something he said during a recent interview with Jim Cramer (yes, that Jim Cramer) that reasonated with me.

On Regular Expressions

Fri, 13 Mar 2026 10:48:58 -0700

Way back when, I was primarily a Perl developer. I actually did my first interview for LinkedIn in Perl. I always liked that the language was created by a linguist (I legitimately miss using unless).

Today, though, besides the occasional one-liner, I think Perl is most known for its contributions to how we all (now) use regular expressions (this post isn’t going into what they are or how to use them).

When HashMaps get "slow"

Thu, 12 Mar 2026 14:46:15 -0700

Many years ago, I took a Data Structures class. I wasn’t even in the major that I would later graduate in, but there were a few topics that I actually remembered from back then.

At least to some extent. I remember the content, but the context was a bit, dare I say unknown.

What we were discussing one day were HashMaps. We had previously discussed Linked Lists and a few other types, and I knew of the name “HashMap”, but what exactly were they?

Building strings in Golang

Tue, 10 Mar 2026 15:00:17 -0700

How do I build a string in Golang?

Building a string seems trivial, and it generally is, but it’s a great way to dive into further to understand some of the basics around what makes Golang so interesting.

First of all, let’s note that a string in Golang is immutable. That means whenever you want to append to a string, the existing string plus what you’re appending needs to be copied to a new string in memory. This means that when optimizing code, we need to be mindful when we write code that performs these actions many times.

The STAR Method

Wed, 04 Mar 2026 15:09:44 -0800

I’ve heard about this one for so long, but have never really sat down to look at it in more detail. It’s actually quite simple, so I’m not sure why I waited so long to do this.

When needing to present to an audience, instead of rambling on about what you did, lightning-talk fashion, it’s best to put some structure around it.

STAR is an acronym, pioneered (I think) mostly by Amazon for handling job interviews. But I feel like it’s helpful for any kind of technical presentation or interaction.

The Haversine Formula

Sun, 01 Mar 2026 21:01:44 -0800

While doing some reading tonight, I came across a question.

How do you calculate the distances between two GPS coordinates?

Turns out it’s by using a function called the Haversine formula. And let me tell you, it looks kind of crazy at first.

I ride bikes a lot and use a GPS computer to track my rides - I’ve always wondered how a device, likely emitting data points every second or so - kept track of this information. And then additionally, how services like Strava or Garmin actually overlay that information on to a map to show you where you’ve gone, how fast, at what elevation, etc.

Enshittification

Sat, 28 Feb 2026 15:37:07 -0800

Cory Doctorow coined this term a while back and even wrote a book about it.

“Enshittification” is the gradual degradation of online platforms, where services initially provide high-quality, free, or cheap value to attract users, then pivot to prioritize advertisers, and finally extract all value for themselves, ultimately harming both users and business customers.

I love this term.

It describes so much of what I’ve seen in tech over my lifetime. Seriously great products and processes enabled by the “world wide web” of the mid to late 90’s, eventually to succumb to ads, paywalls, popups, and “nickel and dime” schemes in both physical and online products.

Using the "done" channel in Go

Fri, 27 Feb 2026 14:29:51 -0800

I wanted to document how a done channel is most commonly used.

Mainly because I’ve personally found it to be more confusing than it should be.

It usually looks a bit like this, when following a worker pattern:

func main() {
  var doneCh = make(chan struct{})

  // Perform some concurrent work
  // ...

  // Wait on that work
  for i := 0; i < 10; i++ {
    <-doneCh
  }
  
  // complete
}

I intentially left out a bit here to highlight what a “done” channel actually looks like.

The Worker Pattern

Thu, 26 Feb 2026 16:09:17 -0800

I really like using a worker pattern with unbuffered channels.

API calls, especially when each can be handled separately and independently, are easily implemented with this pattern, and I’ve seen it help tremendously when downloading artifacts for building in CI, for example.

Instead of setting up a buffered channel with a capacity of 10 in an attempt to concurrently handle 10 requests, you can create an unbuffered channel and read from it using 10 workers.

Golang's unbuffered and buffered channels

Wed, 25 Feb 2026 16:40:18 -0800

From the official Go Blog:

Do not communicate by sharing memory; instead, share memory by communicating.

They’re awesome because they enable concurrency support “out of the box”.

They’re basically their own type that implements concurrent safe logic of sharing memory locations of data without the explicit usage of mutexes or locks. The example in the blog link above has some code blocks that show this quite well, actually.

They can be buffered or unbuffered.

A thought on debugging

Tue, 24 Feb 2026 13:48:08 -0800

Everyone knows that debugging is twice as hard as writing a program in the first place. So if you’re as clever as you can be when you write it, how will you ever debug it?

Brian W. Kernighan is attributed to that quote, and it (regularly) reasonates a lot with me.

I think sometimes as engineers, we actually like complexity. It feels fun to build something really interesting and technical in scope, and we often confuse simple topics like “simple”, “technical”, or even “beautiful”, “clean”, “elegant”…the list goes on.

Azure and rsync

Mon, 23 Feb 2026 17:05:10 -0800

I’m not actually referring to the rsync command that a lot of us know and love.

I’m referring to azcopy sync.

I sometimes use this to copy over files from the generated public/ folder that Hugo creates for me to my Azure blob store. That’s where this site is stored.

In another post, I wrote about a handy VSCode plugin that I use when uploading changes to this site. Unfortunately, this one deletes everything and re-uploads everything.

Thoughts on Pushing Back on Management

Sun, 22 Feb 2026 16:43:50 -0800

I recently learned about a man by the name of Roger Boisjoly, who, in the 80’s, was involved in the Challenger shuttle project. In 2012, NPR put together some information about him and his involvement in the project.

If you’re unfamiliar, this was the shuttle that blew up on its way up out of our atmosphere. I remember less of the actual event myself, but was well aware of it because my elementary school was named after Christa McAuliffe. She was to be the first teacher in space.

A Golang Slice gotcha that...got me

Sat, 21 Feb 2026 12:33:28 -0800

I was doing some self study the other day, feeling relatively confident building out a Trie for an autocomplete function. When checking my work with Gemini, I was recommended something like this as a possible function signature:

func (t *Trie) collect(n *TrieNode, pfx string, results *[]string) {
  // ...
}

Where I started to spiral was the *[]string type in the final input parameter.

That’s weird looking, isn’t it?

In Golang, slices and arrays are often confused. You may say: “But aren’t slices copied by reference?”

Azure (currently) runs this site

Fri, 20 Feb 2026 17:36:02 -0800

In the world of cloud providers, there are generally three big ones - Google Cloud Platform (GCP), Microsoft Azure, and, of course, Amazon Web Services (AWS). AWS has by far the lion’s share of the market, but mainly because they were the first to said market.

Each have enabled all kinds of development from small to medium companies so that they don’t have to set up a bunch of servers, letting them sit idle most of the time.

"Clever" Has No Place in CI

Thu, 19 Feb 2026 20:18:15 -0800

I wanted to share this separately on my site because, well, it made quite the impression over on LinkedIn, where I initially posted it.

Hot take: the code used in infrastructure engineering shouldn’t be complicated, nor should it be clever. It actually should be rather dumb.

If something goes wrong, you want it to be with the code you’re trying to build or ship, not an unexpected effect of an overly complex CI system.

Recovering from a Nil Pointer

Thu, 19 Feb 2026 15:04:21 -0800

welcomeBytes, err := os.ReadFile("blogIntro.txt")
if err != nil {
	panic(err)
}
fmt.Println(string(welcomeBytes))

In most coding languages, the concept of null is pretty ubiqitous. It’s kind of like the number 0 in number theory - it’s kind of…nothing. It’s often a far more complex topic than most realize.

So when encountering a null, particularly a null pointer exception (or as I like to call it, “the joy of working in Java”), it’s usually indicative that you’ve done something wrong. Then the compiler or runtime will immediately stop what it’s doing and bail completely.