Bookmarks (198)

Benchmarking Different Go SQLite Drivers (Again) — An update of a benchmark we first linked a year ago. As with any benchmark results, maintain a critical eye here, but the author found significant differences between the now eight options (previously seven).

Go Protobuf and the New Opaque API — The existing protobuf module is here to stay, but now we get an additional API that provides a more loosely coupled abstraction for working with protobufs without being tied to their underlying in-memory representations. The benefits? Memory efficiency, lazy decoding, and fewer opportunities for bugs.

Go 1.24 Release Candidate 1 Released — This announcement isn’t particularly exciting, but if you want to get ahead of what’s coming in February 2025 with the final Go 1.24 release, the holidays aren't a bad time to have a play. The draft Go 1.24 release notes go into more detail.

8. Go Performance from Version 1.0 to 1.22 — Two years ago we enjoyed the author’s Go performance analysis from Go 1.2 to 1.18. This was an update taking things from Go 1.0 through to 1.22 (the latest version back in April).

6. Why People are 'Angry' Over Go 1.23 Iterators — ‘Angry’ is a little OTT, but there was much robust debate about Go’s proposed new iterator helpers earlier this year. The creator of the Odin language chimed in with his thoughts, opining that Go should stay unapologetically imperative.

5. Learning Go in 2024; From Beginner to Senior — Matt brought together six years of bookmarks (and YouTube history) to point to something for everyone hoping to pick up some new Go skills in 2024.

4. Rust vs Go in 2024? — A perennially popular post from yesteryear was tweaked for 2024 with a comparison of the ‘both awesome’ languages including what they’re both good at, their key differences, and some trade-offs to consider. More recently, however, John has asserted that Rust and Go are better off together than apart.

3. Interactive Release Notes for Go 1.23 — If you find traditional release notes hard going, this interactive alternative with inline executable code snippets might help you get a grip on 1.23, still the latest major version of Go. Anton also had a similar set of notes for Go 1.22.

1. Cogent Core: A New GUI Framework for Go — I was surprised this was by far the most clicked link as news tends to trump frameworks/libraries. Cogent is a “code once, run everywhere” GUI framework aiming to be simpler than Gio and more powerful than Fyne. Cogent’s site itself is built with the framework and compiled to WASM to run on the Web. It...

What's Missing from Go's Generics? — Follow-up to an article we recently linked that posited that Go’s generics are ‘incomplete’ which spurred some lively discussion. Here, Nick responds to that discussion with specific features and how Go may or may not benefit from their inclusion.

Master the Basics of Go — Join Maximiliano Firtman for this detailed video course covering the fundamentals of all things Go. You'll gain a thorough understanding of structures, goroutines, channels, async API calls, and much much more.

Templ vs Gomponents vs html/template — A comparison of three view related libraries for Go, including old favorite html/template (which, perhaps unfairly, gets a one star rating).

Soft Serve 0.8: A Self-Hostable Go-Powered Git Server — Another handy project from the folks at Charm. Soft Serve is a self-hostable Git server that offers up a nice terminal UI (TUI) over SSH, has various access control features for collaborative use cases, and even supports Git LFS.

⚙️ Orchestrion: Compile-Time Auto-Instrumentation for Go — Instrumenting code is tedious and inconsistent when done manually, but automating it is difficult. Enter Orchestrion, which injects instrumentation at compile-time and supports many third-party libraries so you can instrument your code, create tracers, etc. without changing the dev process.

go-wasm-http-server 2.0: Embed Go HTTP Handlers in a Service Worker — Embed your Go HTTP handlers in a Service Worker using WebAssembly and emulate an HTTP server browser-side. Some of the examples might give you some inspiration.

gARM: An ARM64 Compiler for Go — The author thinks we can do better than Go’s assembly approach for high performance ARM64 use cases, so has set out to make his own approach. It's early days, however.

Zero Ops Apache Kafka Replication and Data Mirroring — Moving to WarpStream to reduce your Kafka costs by 80+% and simplify ops is easy with 1:1 replication provided by Orbit.

GTML: Make Writing HTML in Go a Breeze — This package touts itself with “Think of it like JSX for Go,” allowing you to take an HTML-like syntax and generate a StringBuilder that renders it in Go code.

Echo: Extensible, Minimalist Go Web Framework — Though it’s not too minimal, offering HTTP routing, automatic TLS, data binding, templating, middleware, and different ways to render data out of the box. v4.13.0 removes the JWT middleware from Echo core due to security issues. GitHub repo.

Goverter: A Type-Safe Go Converter Generator — Generate type-safe converters by writing signatures of the type conversions and then Goverter will write the code you need to make it happen. GitHub repo.

🕒 Coming in Go 1.24: An Experiment for Time and Concurrency Testing — A look at another feature coming to Go 1.24 early next year. This time it’s the experimental testing/synctest package which opens up some added opportunities for testing code involving time or concurrency: “It seems that testing/synctest will significantly improve testing code that involves time or concurrency. At work, I’ve already tried it on...

🪨 Pebble: RocksDB/LevelDB Inspired Key-Value Database in Go — A key-value store focused on performance that uses RockDB’s file format but adds a few extra features that CockroachDB needs. It’s used at scale within CockroachDB and is considered stable and production ready.

The Draft Go 1.24 Release Notes — Last week, we enjoyed Daniel Martí’s slidedeck on what’s coming in Go 1.24 early in 2025 – we’ve now noticed the draft release notes are coming along well and give a thorough bulletpoint-heavy roundup of what we can expect.

Weak Pointers in Go: Why They Matter Now — A look at a feature expected to land properly in Go 1.24 (via the weak package). Weak pointers are a low-level primitive that enable the creation of certain memory-efficient structures and Phuong explains the basics of how they work.

We Put the Go in Google Gemini — Google Gemini 1.5 Flash 8B for Go has a 1M token context window, capable of processing more than 30,000 lines of code via screencast or logfiles in seconds for a fraction of the cost. Build today using the Google API Quickstart in Go.

Why Go Slices Still Surprise Me — Slices are a common source of confusion and bugs, and this could be due to the merging of two different use cases into one concept. Sometimes, it’s a 'fat pointer'; sometimes, it’s a dynamic array. Confusing the two is where the pain starts.

Go-App: A Package to Build Progressive Web Apps with Go and WebAssembly — An intriguing way to build webapps entirely in Go (including the frontend UI). astextract is a Go-source-to-AST app that demonstrates the concept. GitHub repo.

Diving into eBPF: Building a Process Tracer from Scratch — This is certainly a deep dive down a technical Linux rabbit hole, but this sort of post is gold for when you need to plumb such depths.

Running a Simple Go Web Service on NixOS — “I only just started using NixOS modules to manage my personal services, but I’m excited at how well they work for so little investment.”

Vince: Go-Powered, Self Hosted Web Analytics System — Web stats, link tracking, and more, for unlimited sites and in a single binary. It can even act as a drop-in replacement for Plausible and use the same scripts. There’s an example of a live dashboard. GitHub repo.

🔊 go-taglib: Read/Write Audio Metadata Tags — Read and write metadata tags for audio files (like MP3, FLAC, and OGG) including support for multi-valued tags. Portable with no external runtime dependencies (it embeds a WASM version of the C++-based taglib). (Note: LGPL licensed.)

Rill 0.6: A Composable Concurrency Toolkit for Go — A collection of functions for streaming, parallel processing, and pipeline construction – all aiming to make it “easier to build concurrent programs from simple, reusable parts.”

🕸️ Katana: A Web Crawling and Spidering Framework — A flexible Go-powered Web crawling tool (which can also be used as a library from Go) that can work in both headless and non-headless modes and has lots of customizable features.

shortuuid 4.2: Generate Concise, Unambiguous and URL-Safe Unique IDs — These aren’t standardized UUIDs, but for when you want short, non-sequential user-facing IDs (e.g. KwSysDpxcBU9FNhGkn2dCf).

Quill 0.5: Sign Mac Binaries from Any Platform — Give it a signing private key and certificate from Apple, Quill does the rest to sign and notarize macOS binaries.

GoMLX: ML in Go without Python — Eli recently wrote about Go’s suitability as a glue language for calling out to third party machine learning services and Python ‘sidecars’, but could you just do the heavy lifting from Go itself? GoMLX provides one option.

Sequin: Human-Readable ANSI Sequences — The latest work from the folks at Charm (well known for Bubble Tea, Lip Gloss and other libraries) interprets ANSI sequences into something you can actually understand..

Porcupine 1.0: A Fast Linearizability Checker — You write a spec for a system in Go, provide a concurrent history, and Porcupine figures out if the history is linearizable with respect to the spec. There’s a 2017 blog post that explains more.

♻︎ recur: Retry a Command with Exponential Backoff and Jitter — A Go-powered command line tool for retrying shell based commands in a controlled way until a condition (or success) is met.

superfile: A Terminal-Based File Manager App — Built with Go and Bubble Tea, it combines a visually appealing design with the simplicity of terminal tools, providing a fresh, accessible approach to file management.

Inside Bluesky’s Engineering Culture — A writeup from May 2024 that’s perhaps become more relevant with Bluesky’s recent rapid ascent. Go sits at the heart of the social network’s backend.

▶  WASI to Go: Write Once, Go Anywhere — A talk from the recent WASMCon event exploring Go’s relationship with WebAssembly and how WASM can help ‘Go go anywhere.’ A pretty good primer on the topic as things currently stand.

Are Go's Generics Simple or Incomplete? A Design Study — Some argue that Go’s generic implementation only added complexity to the language, while others disagree. Nick takes us through a complex problem that he struggled to solve with generics, eventually ending up with a solution that works but felt a bit harder than necessary. Some commenters on Reddit felt that his approach was more...

Go! Unlock Your Tech Potential with Ardan Labs Consulting — Struggling with skill gaps, development speed or complex tech challenges? Ardan Labs specializes in Go, Rust, Docker and K8s to accelerate your software development, optimize architecture, and manage tech debt. Let us supercharge your team!

📊  What's Coming in Go 1.24 — A 52-slide deck that goes through language, tooling, and standard library changes coming to Go 1.24 (expected in January or February 2025). There’s quite a bit here, including generic type aliases, weak pointers, and an experimental test package for concurrent code.

Signls: A Non-Linear, Generative MIDI Sequencer — If you like noodling with music, you’ll enjoy this. It’s a Go-powered MIDI sequencer that runs in the terminal (cross-platform) and lets you create dynamic, generative music that evolves and changes over time. The author also created Sektron, a Go-powered MIDI step sequencer. GitHub repo.

gosax: Libary for XML SAX (Simple API for XML) Parsing — A read-only XML parsing library focused on being ‘efficient and memory-conscious.’

Git Town: Extra Commands for More Structured Git Usage — Provides additional git commands to automate the creation, synchronization, shipping, and cleanup of branches. Compatible with popular workflows, mono-repos, and trunk-based development. GitHub repo.

Act: Run Your GitHub Actions Locally — Run act and it looks at your repo’s GitHub Actions, uses Docker to grab the necessary images, and runs the tasks locally.

Go sync.Once is Simple, But How Does It Work? — “The sync.Once is probably the easiest sync primitive to use, but there’s more under the hood than you might think..”