This blog post is a great reference for "when to actually handle the nil case in Go" (and I think these ideas can even be applied to other languages), but there's nothing pushing anyone towards doing it the correct way in Go other than a documented team coding standard or an AGENTS.md/SKILL.md file.

In older Java applications there's also nothing pushing developers towards "correct null handling." A legacy Java application has a bunch of POJOs with getters and setters where all the fields start as null. That's why I think using records+JSpecify+NullAway is incredibly powerful in a Java project. NullAway really forces you to correctly and fully null annotate your code.

Self-discipline is great but static analysis tools actually enforce doing something "the right way." Things slip through code review, but a failing pipeline has to be fixed before the merge can happen.

It reminds me of the original intention of checked exceptions in Java: checked exceptions are for things you force the caller to handle, unchecked exceptions are for "you the programmer messed up". In reality checked exceptions are pretty unpopular and can't be used in many situations, so people fall back to unchecked exceptions.

If we equate unchecked exceptions with panics in Go, falling back to panics would be an anti-pattern in many cases.

NPEs in Java have become rarer and rarer recently with the introduction of records (to easily create immutable classes, which are easier to validate for null against). Plus JSpecify annotations get you null denotation that's almost as good as Kotlin's. Combine that with NullAway are you have compile time null safety. Go has nilaway [0]. One interesting thing about nilaway is that you don't null-annotate your code, it just detects nilness when you run nilaway. That makes nilaway a decent tool to get feedback right away, but it doesn't force you to document the intention behind parameters and fields for whether they are nullable or not, which I would argue is one of the advantages to null-annotating Java code with JSpecify.

[0] https://github.com/uber-go/nilaway

Most people are too non-technical to understand why this is a bad thing even when it's explained to them. Plus, whatever administration is in power in the US has a lot of influence.

Trump has already said that he wouldn't tolerate regulation that affects American companies [1], painting regulation that happens in another country as something that will affect US citizens. (I mean if you use the GDPR as an example, it's not wrong. Think of cookie pop ups while browsing the web in the US)

I would like the the EU would go harder with their regulations, because it usually results in other countries or states following their lead, but I dont see that happening. Regulation has been painted as "bad", and we have at least 3 more years until that changes.

[1] https://www.cnn.com/2026/01/12/tech/us-eu-tech-regulation-fi...

I've seen legacy code bases during code review where someone will ask "should we have a null check there?" and often no-one knows the answer. The solution is to use nullability annotations IMO.

It's easy to just say "oh this is just something a junior would say", but come on, have an actual discussion about it rather than implying anyone who has that opinion is inexperienced.

What's gross to me is the language:

> all newly created Development Mode Client IDs will be created under the updated Development Mode rules and will have the following restrictions applied by default > Development Mode use will require a Spotify Premium account

The language acts as if it's possible to have some sort of non-development mode application. If you look further, you'll see that a non-development mode application must be owned by an organization with more than 250k users.

I think the two things that make this a big deal are: callable from the command line (which means it can integrate with CI/CD or AI tools) and like I mentioned, the fact this is built into Go itself.

Even though I don't like Go, I acknowledge that tooling like this built right into the language is a huge deal for language popularity and maturity. Other languages just aren't this opinionated about build tools, testing frameworks, etc.

I suspect that as newer languages emerge over the years, they'll take notes from Go and how well it integrates stuff like this.

As I get more personal projects under my belt, I believe I'll be able to stand up projects more and more quickly, although it's never perfect. Even though I've been using a similar stack among my side projects for a couple of years now, dependencies get outdated. Sometimes you gotta jump to a new major version. Sometimes you wanna try out the "new way".

I like the idea of building up my own personal stack of tooling, frameworks, and patterns that I use, and could even encourage the use of at $dayjob, but for the reasons outlined above, I agree with the conclusion of the article, which is that an "IKEA of software" doesn't exist currently.

For now I'll keep happily tinkering in my side projects. This article was a good read.

Plus if you damage a CD, simply rip it and burn it to a CDr. (did I mention that ripping a damaged CD usually works?)

You are right about vinyl sleeves being more attractive, though. I think that's its main selling point.

Enshittification also usually implies that switching to an alternative is difficult (usually because creating a competing service is near impossible because you'd have to get users on it). That flaw doesn't really apply to self hosting like it does with centralized social media. You can just switch to Jellyfin or Garage or Zulip. Migration might be a pain, but it's doable.

You can't as easily stop using LinkedIn or GitHub or Facebook, etc.

So it's not about which one is worse, it's about not supporting something that could lead to corruption or an unfair system.

There don't seem to be many automated tools out there that fit my need for this, so building out my own solution I have complete control over makes sense. It's a lot of fun to build this out exactly as I want to, rather than trying to configure a bunch of tools that I'm not familiar with and that don't meet my needs exactly.

The tooling I'm building up around this should hopefully make it easier for myself to get my playlists and track ratings off of Plex if I ever decide to abandon it for music listening.

If you get a high quality SD card with more storage than you'll ever need (64GB, 128GB), you can have a stable system for a while until the SD card becomes corrupt. The larger SD cards help with longevity because it means the SD card can spread writes out over a larger area, which means it'll take longer for the SD card to go bad.

Make sure to always have RAM logging enabled on your Pi! DietPi defaults to RAM logging.

If you introduce a mocking library to the test portion of the codebase, most developers will start to use it as a way to shortcut any refactoring they don't want to do. I think articles like this that try to explain how to better use mocks in tests are useful, although I wish they weren't necessary.

A few well defined interfaces have the advantage of being easy to understand and see usages around the codebase without the overhead of many different variants of an interface. This is extremely important if you are not familiar with a given codebase.

I'm not against segregated interfaces, but I feel like over abstracting can result in code that's harder to understand. There's a balance to be had and thought should go into introducing new interfaces, especially when working on a project with many other devs contributing.

I'm a Java dev, so I'm biased. I love being to easily understand and reason about the type system. I understand that an interface is about a set of behaviors, but when I've worked with Go code I've found it much more difficult to get my IDE to point out all the different ways some interface could be implemented. I see the advantages that Go style interfaces bring, but I personally find it harder to keep a mental model when working with Go.

Proper exception handling in Java can feel verbose. In general you should not be adding checked exceptions to method signatures to make the compiler happy. You should be catching them and rethrowing if you cannot handle them.

Yeah, not much to maintain, but Picard does keep my tags up to date if necessary.

I use the "lookup CD" feature in Picard, which gives me a selection of releases to choose from. Among the choices, I usually see a release matching the catalog number on my CD's case. When I don't see a matching release, I will typically add the disc ID to an existing release, or I will create a new release, or sometimes even creating a new release + new release group and add the necessary metadata to MusicBrainz.

I haven't tried any automatic tagging process like the ripping program the article talks about does, mostly because I want to use Picard to make sure the metadata is correct or contribute to MusicBrainz if it isn't.

I like MusicBrainz a lot because applications like Plex use it very well to group release groups together and will (usually) deduplicate identical recordings so that identical tracks can share a rating. It's a really great database and is kept up to date pretty well.

With that in place, I wonder if that could ever be abused by these pirate sites. Imagine temporarily pointing your pirate site domain name at a valid IP address. When you do that, in theory ISPs (and now VPNs) would automatically block perfectly valid IPs.

This would only happen if the owners of the pirate site domains actually try to do something malicious like that, but I know there are instances in the past of ISPs blocking cloudflare IPs (which is a separate issue, but the scenario I just made up reminds me of it).