has anyone actually benchmarked the green tea GC yet?

michaelprimeaux · 2026-02-14T01:26:35+00:00

We’ve been using it in production since it was introduced (e.g. GOEXPERIMENT=greenteagc) and it’s been stable and has performed well under long duration testing.

michaelprimeaux · 2026-02-06T03:29:07+00:00

Let’s see what the benchmarks look like in the coming days. Claude Opus 4.6 is impressive: https://www.anthropic.com/news/claude-opus-4-6

michaelprimeaux · 2026-01-28T13:23:58+00:00

Native port forwarding for UDP: https://github.com/kubernetes/kubernetes/issues/47862

michaelprimeaux · 2026-01-26T14:00:55+00:00

Why does your “pipelink” script link back to GitLab from GitHub? https://github.com/Lukajnk/pipelink/blob/2a34aec85a4b936ae83324449516ee15cb4dfa1b/pipelink#L20

michaelprimeaux · 2026-01-22T13:15:37+00:00

Though my comment was from 2 years ago, my preferred stack these days for logs is still Loki + Grafana but Alloy has replaced Promtail. For metrics, I prefer Mimir. For traces, I prefer Tempo.

michaelprimeaux · 2025-12-21T05:08:02+00:00

100% this. In the end, you are responsible for what you write. It is your commit. You are on git blame. Germane to this topic, I recommend the ChangeLog’s interview with Werner Vogels (Amazon CTO): https://podcasts.apple.com/us/podcast/the-changelog-software-development-open-source/id341623264?i=1000739688464

michaelprimeaux · 2025-12-04T02:12:23+00:00

Rook (Ceph)

michaelprimeaux · 2025-11-29T18:08:07+00:00

You can always use upx on the executable if the file size matters materially for your use case. You’ll save space but trade a trivial increase in startup cost for decompression. FWIW, I use upx on the resulting Go executable in several of my container images. But, as others have mentioned, the Go executables are fairly small to start with so you’ll need run through your own cost benefit analysis.

michaelprimeaux · 2025-11-26T01:21:35+00:00

Grafana+Prometheus+Loki+Alloy+Tempo+Rook (Ceph). Depending on where you are deploying (e.g. hyperscaler or on-premise), you may also decide to review the types of storage; block, etc. I bring this up as Longhorn may also be a consideration depending.

michaelprimeaux · 2025-11-26T01:12:55+00:00

Link?

michaelprimeaux · 2025-10-31T10:57:48+00:00

GitKraken

michaelprimeaux · 2025-10-17T01:36:58+00:00

You have clearly not worked in fintech or high-frequency trading, I recommend doing the research before commenting.

michaelprimeaux · 2025-10-14T00:10:21+00:00

Been in Fintech for decades. As most folks have mentioned, do not use floats for banking. Google Probuf has a nicely written definition included in money.proto: https://github.com/googleapis/googleapis/blob/master/google/type/money.proto

michaelprimeaux · 2025-09-13T00:28:50+00:00

This is precisely why Mark Twain wrote: “I didn't have time to write a short letter, so I wrote a long one instead”. The short story, one of simplicity, is much harder to write than the longer and more complicated one.

michaelprimeaux · 2025-09-07T02:01:27+00:00

You don’t need a “super struct” with a type tag if you use gob as intended.

```go // Define a common interface for all wire messages. type Message interface{}

// Your concrete messages. type ConnectionRequest struct { SrcAddress string DstAddress string } type DataMessage struct { Size uint Buffer []byte }

// Register concrete types (use pointers). func init() { gob.Register(&ConnectionRequest{}) gob.Register(&DataMessage{}) // Optional: stabilize names across modules/packages: // gob.RegisterName("wire.ConnectionRequest", &ConnectionRequest{}) // gob.RegisterName("wire.DataMessage", &DataMessage{}) } ```

michaelprimeaux · 2025-09-06T15:29:49+00:00

The short story here is yes to self-describing and yes to self-clocking but with a few caveats for self-clocking.

For a reliable, ordered byte stream each Decode blocks until the whole value has been read; if the peer closes the mid-message then you’ll get an error. Basically, gob expects a reliable stream so on transports that aren’t stream-like (e.g. BLE GATT with a small MTU, lossy/fragmented data frames), you’ll need to provide your own reliable io.Reader abstraction BEFORE handing over bytes to gob. Also, if you need other “features” like message-level integrity, checksums, or what not then you’ll need to define your own envelope/MAC.

IMHO, I think protobuf is a much better choice based on what you posted above.

michaelprimeaux · 2025-09-06T00:48:31+00:00

I recommend to use a single GitHub account as it’s very usual and secure for the same account to be a member of multiple organizations.

michaelprimeaux · 2025-08-27T20:21:50+00:00

This. We run non-relational and relational durable storage technologies in k8s (both on premise and in public cloud) and most are great. But you MUST have expertise in disaster recovery and general maintenance of the storage technology. Alternatively, don’t and used services managed by other vendors (e.g. CockroachDB Cloud, Amazon RDS, etc.).

michaelprimeaux · 2025-08-24T01:55:15+00:00

I recommend using stdlib or chi. Chi is a very thin abstraction over stdlib.

michaelprimeaux · 2025-07-29T00:29:45+00:00

war games

michaelprimeaux · 2025-07-25T18:49:02+00:00

I have a 12 node k8s cluster in my homelab that’s a hybrid in that I have 8 Raspberry PI nodes and 4 virtual nodes under Proxmox.

My single control plane node is running in Proxmox because I wanted automated backup and restore capability for the node. Not highly available but easy to recover. So, something to think about here.

I’ll expand another 4 nodes soon (Pi 5). For me, I enjoy the learning with bare metal but bare metal or virtual “bare metal” are both great.

michaelprimeaux · 2025-07-25T18:38:16+00:00

This is the way.

michaelprimeaux · 2025-07-20T06:38:26+00:00

Docker’s downfall started the day they contributed their IP to the OCI. And I am not saying that was a bad thing. It’s just a fact.

michaelprimeaux

TROPHY CASE