The Applied Go Weekly Newsletter

The Applied Go Weekly Newsletter

Archives
Subscribe
November 15, 2026

17 Years of Go ... and Going • The Applied Go Weekly Newsletter 2026-11-15

AppliedGoNewsletterHeader640.png

Your weekly source of Go news, tips, and projects

17 Years of Go ... and Going

Hi ,

Now, that's quite a number: 17 years. I remember that when Go started, Java was considered one of the old, established languages. Java was 18 in 2009 when Go was publicly announced.

However, Go is far from getting old. It's still thriving, among all the crazy changes going on nowadays. Even LLMs seem to love Go. Whatever I tell the bot to build in Go, it does so without errors. Some weird coding decisions every now and then, but nothing that affects functionality or cannot be fixed with another prompt.

Still, some risk of code rot remains when letting LLMs generate code, so it remains crucial to remain (a) knowledgeable at software development fundamentals (such as probabilistic data structures, featured article #2) and (b) skilled in coming up with new strategies and designs that improve upon existing solutions (see featured article #3).

Talking of skills, risks, and LLMs: if you delegate programming, you risk losing skills in the long haul. Luckily, you can stay fit in programming in various ways, as outlined in this episode's spotlight (part of my series "Still Writing Go: A skeptic's field guide to AI-assisted Go development).

Looking forward to the next 17 years!

–Christoph

Featured articles

Go Turns 17

17 Years! And even just the last one was exciting enough: better generics, better JSON, a better GC, better SIMD support, better crypto (post-quantum!) a better go fix, a better gopls... and Go 1.28 is around the corner.

Probabilistic data structures in Go

A probabilistic data structure is optimized for speed or space at the expense of precision. A Bloom filter, for example, is a set (that is, a bag of values) that you can ask if it contains a particular value. The filter can give you two answers: Either, the value is definitely not in the set, or it probably is. This fuzziness allows the Bloom filter to use much less space than a regular set. And yes, Bloom filters do have use cases.

Got curious? Then Anton Zhiyanov has a few more probabilistic data structures for you.

Field pointers as column names: compile-checked Go queries without codegen | ant

How to design type-safe, compiler-controllable database interactions? Alberts Liepiņš, author and maintainer of Ant, a Go ORM, uses pointers to struct fields to reference database columns. This way, the compiler can catch misspelled columns, wrong value types, and bad relations—all of this without a code generator.

Podcast corner

Don't Mess with C++

Not really related to Go, but reading this episode's teaser, I got reminded of one of the reasons why Go was invented in the first place.

Waiting for the break of day as Go turns 17

Seems as if Jonathan and Shay didn't want to miss Go's 17th birthday. While waiting for the break of day, they talk about a proposal to add netip.Addr.To6() to the standard library, the upcoming FOSDEM 2027 in Brussels, and the debut of the Golang SF channel on YouTube. Also, Jonathan launched a free observability course on Boot.dev covering slog, Prometheus, and Grafana.

My favorite five-star feedback to this course: "this was a pain." I believe Jonathan meant it to be that way. Observability is not for the faint of heart.

Spotlight: AI Will Make You Dumber (if You Let It)

It's commonly agreed upon that you can't unlearn swimming or riding a bicycle. Once learned, the movements are burned deep into the muscle memory.

That's not entirely true for skills that are "brain heavy" with little muscle movement involved. Learning languages is such a skill. If you don't practice speaking a language you learned, you'll lose it.

Skills aren't forever

I experienced this when we planned to take our little ones to Corsica for vacation. Having learned French at school as the second language (besides English), I thought, "well, I'll buy a refresher course that will bring me back into the language quickly." A beginners course deemed utterly boring. Boy, was I wrong! I put the CD into the player (yes, in the 2000s, these discs were quite popular), started listening to the first lesson... and I didn't understand anything. Instantly, I realized I bought the wrong course, and I got one of those beginners courses that teach you enough broken French to get you through your visit. (If the phrase "pardon my French" wasn't already taken, I would have said it before every French sentence I had to utter.)

The saying is so true: Use it or lose it.

Now transpose this to even more abstract skills like software development. Not only do you have to be fluent in at least one programming language; you also need to understand, and be able to apply, wagonloads of computer science's theories: algorithms, data structures, relational databases, graph databases, Big-O, P versus NP, numerical mathematics, various models of concurrent and distributed programming, and so on and so forth.

If you're an experienced developer, you probably have nodded along when reading this list. (If you're just starting into software development, that's a glimpse of what you'll be learning along your journey.) Software development done right requires having a broad range of skills and the ability to apply them in the right way.

And you have to keep your skills active. Even if you're a senior developer who delegates tasks to juniors, you still have to review their PRs, judge their work, and help them in becoming better. Only those who change into management can afford to gradually lose their technical abilities: They aren't required anymore to know all the details about the software being produced; their job is to support those who do.

And now comes AI

As LLMs are getting better and better at writing software, it's like everyone has now a tireless junior programmer at their disposal. Delegating the boring parts to a bot can feel liberating (believe me, I've tried it): You just need to explain what you want to have, and the bot goes pottering around for a few minutes and delivers a ready-to-merge PR. You can review it or have another bot review it for you. The amount of PRs an AI is able to produce within a short time may push you towards the latter, sooner or later.

And suddenly, your brain is no longer involved in the part of the development process.

Like a developer who got promoted into management, your programming skills slowly degrade. You mutate from an active developer to a mere bystander.

Train your brain

I want to be clear: If your plan is to do less development and more planning, managing, or customer communication, letting some skills fade away is a legitimate way to open your brain to acquire new skills. As I said earlier, it can be liberating to boss the clankers around. But remember you still own the outcome. If you want to remain able to reason about LLM-generated code and steer LLM output into the right directions, honing your development skills pays off.

How to fight brain rot? By training, of course. As with fitness training, you have to block time to work on code without AI.

Here are some tips to get started:

Structure your project work into "heavy" and "volume" days

Extract the difficult parts of the project and assign them to yourself. Work on them without AI help, or let the AI in only after you're finished. Wrap your brains around the problem until you have understood it well, then come up with, and implement, the solution. These are the "hard" days, and they are intentionally hard to have a learning effect. After all, you don't go to the gym and let a bot lift the weights for you, do you?

During the "volume" days, let the bots crunch through the boring parts. Throughput is relevant for every project, after all. Letting the bots do the easy, boring parts saves time and bears less risk of receiving bad bot code. (Bad code costs more time than the bots save while producing it.)

Shift your skills

Become brutally good at writing precise requirements and interface contracts. Draft designs and discuss them with your peers and the AI.

Write the tests yourself (and a bit more)

Establish Test-Driven Development (TDD) where writing tests stays with you. Tests in TDD are the bridge from specification to implementation. They allow you to think through each decision made in the spec and design the module, package, and function layout. Another plus: LLMs may write tests that describe technical details. What you want are tests that describe the behavior intended by the spec.

You can even go one step further and write out all types and function signatures. Filling the function bodies remains the only part left to the bot. Prompt it to not create any new function or type without your consent. This way, you can do all the thinking except for the actual function implementation. Moreover, the bot has little room for causing code bloat or diluting your design.

Do coding exercises (and have some fun)

Pick a topic you always wanted to explore deeper. Start a side project and code away. This could be a specialized tool for your workflow, a TinyGo program for a microcontroller-based tool or interactive artwork, or how about reimplementing a small thing from the standard library? Try a sync.Pool() or a new Hash implementation. Or pick a coding kata. Whatever you feel like doing.

Stay sharp!

Even in times of AI, there are ways of keeping your skills, or at least find new skills to replace fading ones. Above are but a few tips. The next article in this series is about increasing your code ownership and will contain a few more thoughts in this direction.

Quote of the Week: Learning versus Mastering

"When learning, explore widely.

When mastering, focus narrowly.

– James Clear

More articles, videos, talks

How hard could implementing DTLS 1.3 possibly be? | Jo Turk

Datagram Transport Layer Security (DTLS) is base on TLS but drops the requirements of order protection and replayability. The Pion team worked on implementing DTLS in Pion for ten months; here's their logbook.

The State of Go in 2026: What Changed In the Golang Ecosystem Since Last Year

JetBrains extracted the Gopher responses from their JetBrains Developer Ecosystem survey. A fact that mildly surprised me: Gophers are a bit more AI-affine than the rest of the respondents. Is it because Go works so well with AI?

I Load Tested Go's New JSON v2 - YouTube

JSON v2 is up to ten times faster! But is it? Huseyin Babal wanted to find out how much of the cleanroom measurements remain under real-world conditions.

Go 1.27.4 security release: cgo flags and a net/http fix | ImportStatic

Go is famous for its backward compatibility promise: Code written with Go 1.0 still compiles with the latest Go version. But there is a notable exception: Security fixes may break backward compatibility if necessary. In this case, the benefit of fixed security outweighs the drawbacks of failing backward compatibility.

In times of AI, exploits have become a dime a dozen, and so, as if to acknowledge not only the rising number of expoits but also the phrase "a dime a dozen", Go 1.27.4 fixes no less than a dozen CVEs. The fixes break two flags: --sysroot= and -target trigger an "invalid flag" error that stops the build. This article inspects the reasons and available fixes.

Projects

Libraries

libtmux for Go: a typed tmux library. No runtime dependencies, plus an MCP server for agents.

Tmux, the classic terminal multiplexer on Unices, isn't quite dead yet. I can assure you of that, as I use it on a daily basis.

libtmux-go lets you remote-control a Tmux instance from Go. Also included: An MCP server for agents.

ws: RFC6455 WebSocket implementation in Go.

Unlike other Websocket libraries, ws stays fairly low-level, in order to allow uses do things like reusing I/O buffers between connections.

everanium/itb: Experimental symmetric cipher construction

Even the "accessible explanation" of the barrier's construction is above my head, so I'll leave it as an exercise for the reader.

As always, use non-mainstream crypto at your own risk. The README is honest about the experimental status up front, which is a good sign.

cattlecloud/litesql: litesql is a Go library for convenient, easy, and performant use of SQLite3 databases in Go programs

SQLite is already easy to use, but there are a few things Go developers have to keep in mind when working with SQLite. litesql wants to get these things out of the dev's mind and into code: It pools connections for read transactions, isolates a dedicated write connection for writes, sets pragma values to more reasonable defaults, and, as a goodie on top, provides the ability to create periodic snapshots with retention policies.

Small drawback: The current version hardcodes mattn/sqlite3 as database driver and hence requires CGO.

Tools and applications

sanda0/vps_pilot: One self-hosted dashboard for the handful of Linux servers you run. A single Go binary with the UI built in, plus a tiny Rust agent on each server. You stay in control of what it can do.

A linux server monitor with low-profile Rust workers on each monitored node. The author looks for contributors.

kevincoder-co-za/scriptables

Conduct your Ubuntu orchestra: Scriptables is a web-based control panel for Ubuntu servers with various goodies: install common apps, manage ufw firewall rules, schedule cron jobs, and more.

runwisp/runwisp: Cron job manager + process supervisor in a single binary. Web dashboard, TUI, retries, failure notifications. crond/supervisord replacement

Manage jobs and processes with style. RunWisp bakes crond and supervisord functionality into one UI. Or rather, two: a web UI and a TUI. Bring your own config or import crond and supervisord configurations.

ProjectMeru/sumeru: Sumeru is an open-source, modular ERP framework written in Go. Every business function contacts, products, CRM, sales, invoicing — is an addon: a folder with a manifest, some Go models and some XML. The kernel discovers it, resolves its dependencies, creates its tables and wires its menus.

ERP, or Enterprise Resource Planning, is a software category that their vendors usually made millions with. Sumeru is the open source answer. (Alpha status.)

Completely unrelated to Go

The future of Software Engineering is boring

Will programming degenerate into reviewing machine-generated code? Will codebases become bloated and unmaintainable? Will developers become housekeepers of code, rather than creatively solving problems? Alex Pliutau muses about programming in a Sam-and-Dario world.

Software has no value

Software traditionally has been expensive to build, hence it must have an intrinsic value, right? Wrong. Like any other tool, software has only value if it helps the user achieve something that would be harder or impossible without it. But then, in the face of collapsing software build cost, is software still worth buying if only 10% of it are actually used?

Happy coding! ʕ◔ϖ◔ʔ

Questions or feedback? Drop me a line. I'd love to hear from you.

Best from Munich, Christoph

Not a subscriber yet?

If you read this newsletter issue online, or if someone forwarded the newsletter to you, subscribe for regular updates to get every new issue earlier than the online version, and more reliable than an occasional forwarding. 

Find the subscription form at the end of this page.

How I can help

If you're looking for more useful content around Go, here are some ways I can help you become a better Gopher (or a Gopher at all):

On AppliedGo.net, I blog about Go projects, algorithms and data structures in Go, and other fun stuff.

Or visit the AppliedGo.com blog and learn about language specifics, Go updates, and programming-related stuff. 

My AppliedGo YouTube channel hosts quick tip and crash course videos that help you get more productive and creative with Go.

Enroll in my Go course for developers that stands out for its intense use of animated graphics for explaining abstract concepts in an intuitive way. Numerous short and concise lectures allow you to schedule your learning flow as you like.

Check it out.


Christoph Berger IT Products and Services
Dachauer Straße 29
Bergkirchen
Germany

Don't miss what's next. Subscribe to The Applied Go Weekly Newsletter:
Older → About Perspectives • The Applied Go Weekly Newsletter 2026-11-08
Share this email:
Share on LinkedIn Share on Mastodon
Mastodon
LinkedIn
Powered by Buttondown, the easiest way to start and grow your newsletter.