thepudds

@thepudds.bsky.social

Go contributor. Posts tend to be about #golang, performance, fuzzing, and Go Modules. He/him. https://github.com/thepudds

Great milestone for us! We had been working on this hard! If you using @golang.org and collect observability signals from your services check it out! Our goal is to add as much as integrations as possible so that you can automagically collect all the signals!

OpenTelemetry@opentelemetry.io · 3w ago

Go Compile-Time Instrumentation just hit v1! 🎉 Add OpenTelemetry to your Go services with zero code changes. Swap go build for otelc go build and get automatic instrumentation for your app, dependencies & the standard library. opentelemetry.io/blog/2026/go...

This is a fun one: I just sent go.dev/cl/790740, which elides method wrappers for embedded types at offset zero, common for mixins/inherited data types. Doing this removes 60 _thousand_ method wrappers from tsgo's AST package, dropping the compilation of our main exe from 49s to 28s on my machine.

Benchmark 1: go build -a ./cmd/tsgo
  Time (mean ± σ):     48.992 s ±  0.274 s    [User: 345.152 s, System: 12.545 s]
  Range (min … max):   48.702 s … 49.478 s    10 runs
 
Benchmark 2: ~/work/go/bin/go build -a ./cmd/tsgo
  Time (mean ± σ):     28.323 s ±  0.133 s    [User: 141.277 s, System: 4.853 s]
  Range (min … max):   28.075 s … 28.555 s    10 runs
 
Summary
  ~/work/go/bin/go build -a ./cmd/tsgo ran
    1.73 ± 0.01 times faster than go build -a ./cmd/tsgo

I have also found exe.dev to be exceedingly pleasant to use (and I’ve reduced my personal GCE spend as a result 😅). Easy out of the box, but also very hackable. The people working on it have been displaying nice taste and judgment.

Sam Rose@samwho.dev · 2mo ago

Phenomenally impressed with exe.dev so far. Moved a few of my sites over to it. It’s definitely early, some bumps and blips here and there, but I completely see the vision. Not sponsored but I do have invites for a free month if you wanna try it. Don’t think I get anything for you using them.

I'm working on cargo-semver-checks, and I realized that an edge case of one of my edge cases has an edge case that breaks my planned design. That means that so far, I'm having an average Saturday in cargo-semver-checks land 😅

Go’s push iterators can be strange at first but they are so much easier to write when the algorithm to visit the elements has nontrivial control flow (recursion or conditionals) such as for a tree; you just call yield. In Java/C++ one must explicitly materialize all state implied by your SP and PC.

I've spent the past couple months hand crafting a new B-tree map implementation for Go. It's fast. Faster than Rust's BTreeMap. Faster than the fastest C++ (frozenca/btree). And about 2x faster than my current Go btree (tidwall/btree).

Bild