Just a not-so-humble reminder that the best way to add interactive examples to your product docs, online course, or blog is with Codapi. It's lightweight, battle-tested, and open source.

I've been working with the errors package for a while, but I only recently noticed that it has an ErrUnsupported sentinel (Go 1.21+). It indicates that the requested operation can't be performed because it's not supported. Have you ever used ErrUnsupported?

All jokes aside, I've implemented promises and async/await in Go. Just make sure you NEVER use them.

P.S. I totally made that up. Here's your async/await implementation, though :). Performed by a highly trained individual; DO NOT try this at home.

Good news for JavaScript and Python folks: async/await is coming to Go, so you'll feel right at home!

The new chapter of my interactive Go Concurrency book covers signaling, one-time execution, and object pools. If you think channels are the only way for goroutines to communicate, check it out!.

I've updated the list of Go features by version. Now, each feature has ➀ a link to the documentation, ➁ a link to the proposal, and ➂ a link to the commits. It's fascinating to see how Go has changed over the years.

I asked several hundred Go developers what they like most about the upcoming 1.25 release. Here are the results:. ➀ JSON v2.➁ GOMAXPROCS, synctest, new GC.➂ WaitGroup.Go

Going back to testing, yet another example is the testify/assert package. Similar to Python's TestCase, it has functions like Equal, NotEqual, EqualError, Error, NoError, ErrorAs, ErrorIs, etc. Even Greater and GreaterOrEqual!. While designing my own test assertions package, I

Another example of a wide interface is Go's Regexp. Here's a sneak peak:. FindAllString.FindAllStringIndex.FindAllStringSubmatch.FindAllStringSubmatchIndex.FindString.FindStringIndex.FindStringSubmatch.FindStringSubmatchIndex. Compare to a third-party regexp2 package:.

One crucial piece of advice John Ousterhout gives in his book "Philosophy of Software Design" is about deep modules. Module depth is a way of thinking about cost versus benefit. The benefit provided by a module is its functionality. The cost of a module (in terms of system.

You don't need testify/assert to write clear, simple, and expressive Go tests.

Okay, I did it again. I reimplemented Redis using Postgres. Key/value, expiration, maps, lists, sets, and sorted sets — everything in your favorite database. With a Redis-compatible API and wire protocol.

The SQL syntax for SQLite and Postgres is *very* similar. Out of the 21 most complex SQLite queries that handle sorted set operations, I only need to change one to make it work with Postgres. The others work as they are.

I made it through the blockchain hype wave, but I'm not so sure about the current one. I understand the excitement, but I'd rather see 1/10 of the AI-related posts I see now. Maybe even 1/50.

Maintaining razor-sharp focus and saying "no" all the time is not what we are good at. But recognizing this is the first step toward achieving simplicity.

Another reason why simple is difficult is that you have to pick your battles carefully. Nothing is easier than saying "yes" to every feature, but that just leads to a complex, half-baked mess.

Creating simple products is hard. Most of us have no idea what "simple" really means (not "easy"!), or how to achieve it. We're taught to embrace complexity and even enjoy it.

It's such a relief to switch from standard library assertions to more concise ones 😅

Not only is @boyter's scc a great tool for counting lines of code, but it also values my work more than anyone ever will. $22,607 for a two-file Go package! That's why I appreciate it so much :)

How about a micro test assertions Go package with flexible error checking?. Only 100 loc. I've named it "be" :).