Atom by Atom by Atom

Hi ,

Ancient Greek philosophers assumed that matter cannot be infinitely divisible. In the 19th century, John Dalton discovered a behavior of chemical substances that he could only explain by assuming an "ultimate particle" that he named "atom", based on the Greek word "atomos", which means indivisible.

Later, researchers discovered subatomic particles—electrons, protons, and neutrons. Today, we know seventeen elementary, subatomic particles. Atoms weren't the ultimate, indivisible particle anymore. Still, things that cannot be taken apart further are often called "atomic", and everyone knows what it means.

Today, software developers frequently discover that seemingly atomic operations, like a++, fall apart into sub-atomic operations, if they look close enough: Copy a's value from RAM into a register, increase the value, copy the new value back to RAM.

Concurrent operations can stumble upon this "non-atomicity", but luckily, languages with support for concurrency that are worth their money offer a way out: truly atomic operations.

On a macroscopic scale, other patterns emerge, such as the Repository pattern that helps to keep separate concerns separated and the world (of your apps) stable.

And when patterns aren't sufficient anymore, it is always possible to expand the universe (of a programming language), given that there's enough energy available (to extend the Go compiler).

Enjoy this mid-spring/autumn issue of the Applied Go Weekly Newsletter!

–Christoph

Featured articles

Atomic Operations in Go • Asaduzzaman Pavel

Atomic operations explained through practical use cases. Bookmark-worthy.

Repository pattern in Go service | pawelgrzybek.com

The idea is: simple. Isolate business logic from storage details. The way to do this well is: in this article.

I extended the Go compiler to support conditional expression, native tuples, and declarative API over iterators

It's one thing to complain about shortcomings of a language. It's a completely different thing to take action and implement the features that seem missing.

Podcast corner

081: Weird Redis bug and we talk text editors

Another episode of go podcast(), with Dominic and Morten. Morten is using Neovim, which is also my favorite editor for the shell (and I never use VSCodium without the Vim extension).

A Nil by any other name

GopherCon Singapore, a handful of proposals—the good, the bad, and the ugly ones?—, and a new live course on testing: another steaming hot cup of Go!

More articles, videos, talks

Error translation in Go services | Redowan's Reflections

When errors bubble up the call chain, they take quite some low-level information with them. Often, that's desired, and it's ok if the top caller logs them in a controlled way. However, if logs (or other error output channels) are visible to clients, or the top layer starts accumulating dependencies to lower layers it has no business with, solely for the purpose of handling low-level error types, you will want to transform low-level errors into high-level errors at layer boundaries.

Native Go ML Inference: Porting Weights for Microsecond Latency | Hyperion

No, it's not another "Go is faster than Python" story. The culprit was a HTTP and serialization layer between Go and an external Python service. But removing this layer meant more than just replacing an exernal service by an internal function. The Go core had to "learn the maths of our specific algorithms."

Many-Step Sequences in Go

Chris Lesiw refines a 2011 idea from Rob Pike to adapt Go to writing shell-script-like flows (that is, a linear sequence of commands).

How do Wake-On-Lan works?

Save money and put your servers to sleep when idle. But how to wake them up from a distance? Send them a magic wakeup packet. Here's how to do it in plain Go.

Validating data in Go

...specifically, in HTTP handlers. The idea: a Validator interface allows retrieving a map from field names to problems identified with these fields' values, which the handler can turn into an informative HTTP error.

go tool task | Task

A strong argument for using make instead of modern alternatives is that it's readily available on virtually all Unix flavors and distributions.

go get -tool invalidates this argument—at least, in Go environments. Here is how to install and run Taskfile, a task runner with make-like features (such as skipping a step if a source file didn't change (which sets it apart from other task runners)) using only the Go toolchain.

Tiny Go and Rust programs appear to start equally fast (on some machines)

A quick, non-scientific comparison of Go and Rust app startup times.

Peeking into Go struct tags

Did you know that you an can evaluate struct field tags at runtime and compile time? This article covers this and more information about struct tags.

Projects

Libraries

bhope/hedge: Adaptive hedged requests for Go. Cut your p99 latency with zero configuration. Based on Google's "The Tail at Scale" paper.

Imagine a request being sent to multiple backends (for example, to query a sharded database). All backend services respond within milliseconds—except one that takes a second or two to respond. Hedged requests can reduce this latency dramatically, by sending a duplicated request. The response that returns first is used; the other request gets cancelled. Smart!

Tools and applications

mr-vaibh/park: Pause a process and free its TCP port. Resume later, same PID and memory intact. Ctrl+Z for servers.

Dev machines can be busy like mad, and just when you have to test a service on port 1234, that port is occupied by a server you can't stop right now.

The solution: deep-freeze the server and grab the port. Easy-peasy... if you use park.

Completely unrelated to Go

Fun with an indecisive AI coding agent

I have seen this with smaller models, but not with Opus 4.6 so far: When Ben Hoyt asked the model to fix a (not so complex) bug in GoAWK, it went into an endless thinking loop.

Does your DSL little language really need operator precedence?

A "YAGNI" for all designers of domain-specific mini languages: Consider dropping operator precendence, because most probably You Ain't Gonna Need It.

The machines are fine. I'm worried about us.

Alice learns the classic way, Bob uses a bot...