# golang

Published articles for golang.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## I Rebuilt a Minimal BitTorrent Client in Go to Understand Peer-to-Peer Choking Algorithms

DevFeed: [I Rebuilt a Minimal BitTorrent Client in Go to Understand Peer-to-Peer Choking Algorithms](<https://devfeed.tech/articles/i-rebuilt-a-minimal-bittorrent-client-in-go-to-understand-peer-to-peer-choking-algorithms-39584.md>)

Original publisher: [Read original article](<https://ankit-rana.com/logs/32-minimal-bittorrent-choking-algorithms-go/>)

Author: hello@ankit-rana.com

Published: 2026-08-02T00:00:00Z

Content type: tutorial

Language: en

Sources: [Ankit Rana | Mechanical Sympathy](<https://devfeed.tech/sources/ankit-rana-mechanical-sympathy.md>)

Topics: [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [P2P](<https://devfeed.tech/topics/p2p.md>), [Go Language](<https://devfeed.tech/topics/go-language.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Network](<https://devfeed.tech/topics/network.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [bittorrent](<https://devfeed.tech/tags/bittorrent.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [go](<https://devfeed.tech/tags/go.md>), [golang](<https://devfeed.tech/tags/golang.md>), [network](<https://devfeed.tech/tags/network.md>), [networking](<https://devfeed.tech/tags/networking.md>), [p2p](<https://devfeed.tech/tags/p2p.md>), [peer-to-peer](<https://devfeed.tech/tags/peer-to-peer.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [system-design](<https://devfeed.tech/tags/system-design.md>)

### AI overview

A hands-on explanation of BitTorrent choking algorithms through rebuilding a minimal client in Go. The article describes choking as a decentralized bandwidth-allocation mechanism, explains the choked and interested states, and shows how upload capacity affects peer prioritization.

### Source excerpt

The BitTorrent spec explains choking in two paragraphs; implementing it in Go and watching every peer choke you within 60 seconds is what makes it stick. Choking is a bandwidth allocator running independently on every node, not a courtesy flag. Upload is the scarce resource on an asymmetric link, and each connection carries just two booleans, choked and interested, whose four combinations drive the entire fairness policy of the swarm.

## How the controller-runtime Cache Actually Works, and Why Your Controller Does Not Crash the API Server

DevFeed: [How the controller-runtime Cache Actually Works, and Why Your Controller Does Not Crash the API Server](<https://devfeed.tech/articles/how-the-controller-runtime-cache-actually-works-and-why-your-controller-does-not-crash-the-api-server-4568.md>)

Original publisher: [Read original article](<https://kubernetes.io/blog/2026/07/29/controller-runtime-cache-explained/>)

Author: Andrei Kvapil; Timofei Larkin

Published: 2026-07-29T18:00:00Z

Content type: article

Language: en

Sources: [Kubernetes Blog](<https://devfeed.tech/sources/kubernetes-blog.md>)

Topics: [Kubernetes](<https://devfeed.tech/topics/kubernetes.md>), [Go Language](<https://devfeed.tech/topics/go-language.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [Caching](<https://devfeed.tech/topics/caching.md>)

Tags: [article](<https://devfeed.tech/tags/article.md>), [cache](<https://devfeed.tech/tags/cache.md>), [go](<https://devfeed.tech/tags/go.md>), [golang](<https://devfeed.tech/tags/golang.md>), [internals](<https://devfeed.tech/tags/internals.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [memory](<https://devfeed.tech/tags/memory.md>), [network](<https://devfeed.tech/tags/network.md>)

### AI overview

This article explains how the controller-runtime cache works in Kubernetes controllers written in Go. It describes the local in-memory cache populated by list and watch operations, contrasts cached reads with direct API-server access, and examines the practical effects on memory usage, network traffic, read consistency, and reconciler behavior.

### Source excerpt

This article has been revised since it was first published, to correct several significant technical inaccuracies in the original text. Kubernetes has long been the default platform for distributed workloads, and writing your own controller for it is now a matter of a few hours. The common path -- Golang, using kubebuilder on top of controller-runtime -- gives you a project scaffold, types, and a reconciler. For typical scenarios that is more than enough. But as soon as load grows or the controller starts behaving in ways you did not expect, a whole class of edge cases shows up. Most of them trace back to the same root cause: a fuzzy mental model of how controller-runtime works inside. If you write Kubernetes controllers in Go, this article should help you build a coherent picture and avoid expensive surprises in production. This article walks through the internals of controller-runtime and, along the way, shows which architectural decisions are baked into Kubernetes itself. The starting point is how controllers actually read objects from the Kubernetes API. A common misconception goes like this: r.Get() inside Reconcile queries kube-apiserver directly; r.List() returns a fresh, live view of the world; and after r.Update() you can re-read the object and immediately see the new state. In practice the model is the opposite: controller-runtime operates against a local copy of the data populated through list + watch. Reads inside a reconciler cost almost nothing and do not load the control plane even at hundreds of calls per second -- but the price of this design is that a controller can quietly consume gigabytes of memory, perform hidden O(n) scans, and regularly trip over stale reads. This post is aimed at engineers who already write controllers in Go with controller-runtime but want to consolidate the pieces into a single mental model rather than carry around a bag of isolated observations. The focus is the practical impact on production clusters: memory, network traffi

## RAG in Go: A Vulnerability Research Tool

DevFeed: [RAG in Go: A Vulnerability Research Tool](<https://devfeed.tech/articles/rag-in-go-a-vulnerability-research-tool-22285.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2026/04/rag-in-go-a-vulnerability-research-tool/>)

Published: 2026-04-20T00:00:00Z

Content type: tutorial

Language: en

Sources: [William Kennedy](<https://devfeed.tech/sources/william-kennedy.md>)

Topics: [Retrieval Augmented Generation (RAG)](<https://devfeed.tech/topics/retrieval-augmented-generation-rag.md>), [Go Language](<https://devfeed.tech/topics/go-language.md>), [vulnerability](<https://devfeed.tech/topics/vulnerability.md>), [DuckDB](<https://devfeed.tech/topics/duckdb.md>), [JSON](<https://devfeed.tech/topics/json.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [ardan-labs](<https://devfeed.tech/tags/ardan-labs.md>), [blog](<https://devfeed.tech/tags/blog.md>), [code](<https://devfeed.tech/tags/code.md>), [database](<https://devfeed.tech/tags/database.md>), [duckdb](<https://devfeed.tech/tags/duckdb.md>), [embedding](<https://devfeed.tech/tags/embedding.md>), [go](<https://devfeed.tech/tags/go.md>), [go-programming](<https://devfeed.tech/tags/go-programming.md>), [golang](<https://devfeed.tech/tags/golang.md>), [json](<https://devfeed.tech/tags/json.md>), [llm](<https://devfeed.tech/tags/llm.md>), [programming](<https://devfeed.tech/tags/programming.md>), [rag](<https://devfeed.tech/tags/rag.md>), [retrieval](<https://devfeed.tech/tags/retrieval.md>), [technical](<https://devfeed.tech/tags/technical.md>), [vulnerability](<https://devfeed.tech/tags/vulnerability.md>)

### AI overview

This tutorial demonstrates how to build a retrieval-augmented generation tool in Go using the Go Vulnerability Database as internal documents. It covers ingesting zipped JSON data, generating vector embeddings, storing them in DuckDB, and retrieving documents relevant to a user query.

### Source excerpt

Introduction In the previous post, you saw how you can use tools to add information to an LLM query. In this post, we'll see another method of adding information to an LLM called RAG, or Retrieval-Augmented Generation. The idea of RAG is that you want the LLM to have access to information that wasn't available to it when it was initially trained. You do it by storing documents in your own database along with their embedding. I won't go into the technical details of embedding, but think of it as a way to convert a piece of text into a vector. The magic is that if two pieces of text have similar meaning, an embedding model can create vectors that mathematically show they are similar.

## Go 1.26.2: Security Fixes, Regression Patches, Upgrade Playbook

DevFeed: [Go 1.26.2: Security Fixes, Regression Patches, Upgrade Playbook](<https://devfeed.tech/articles/go-1-26-2-security-fixes-regression-patches-upgrade-playbook-33339.md>)

Original publisher: [Read original article](<https://blog.ratnesh-maurya.com/blog/Go-1-26-2-Released-Security-Fixes-Regression-Patches-and-Upgrade-Playbook>)

Author: ratneshmaurya2311@gmail.com (Ratnesh Maurya)

Published: 2026-04-09T00:00:00Z

Content type: release

Language: en

Sources: [Ratn Labs](<https://devfeed.tech/sources/ratn-labs.md>)

Topics: [Go Language](<https://devfeed.tech/topics/go-language.md>), [upgrade](<https://devfeed.tech/topics/upgrade.md>), [patches](<https://devfeed.tech/topics/patches.md>), [Security](<https://devfeed.tech/topics/security.md>)

Tags: [backend](<https://devfeed.tech/tags/backend.md>), [beginner](<https://devfeed.tech/tags/beginner.md>), [go](<https://devfeed.tech/tags/go.md>), [go-security-backend-release-engineering](<https://devfeed.tech/tags/go-security-backend-release-engineering.md>), [golang](<https://devfeed.tech/tags/golang.md>), [patches](<https://devfeed.tech/tags/patches.md>), [release-engineering](<https://devfeed.tech/tags/release-engineering.md>), [security](<https://devfeed.tech/tags/security.md>), [technical](<https://devfeed.tech/tags/technical.md>), [upgrade](<https://devfeed.tech/tags/upgrade.md>)

### AI overview

This article covers the Go 1.26.2 release, including its security fixes and regression patches, and provides guidance for upgrading safely in production.

### Source excerpt

A beginner-friendly and technical deep dive into Go 1.26.2: what changed, why it matters, and how to upgrade safely in production.

## From Custom to Open: Scalable Network Probing and HTTP/3 Readiness with Prometheus

DevFeed: [From Custom to Open: Scalable Network Probing and HTTP/3 Readiness with Prometheus](<https://devfeed.tech/articles/from-custom-to-open-scalable-network-probing-and-http-3-readiness-with-prometheus-145.md>)

Original publisher: [Read original article](<https://slack.engineering/from-custom-to-open-scalable-network-probing-and-http-3-readiness-with-prometheus/>)

Author: Carlo Preciado

Published: 2026-03-31T17:00:39Z

Content type: article

Language: en

Sources: [Engineering at Slack](<https://devfeed.tech/sources/engineering-at-slack.md>)

Topics: [telemetry](<https://devfeed.tech/topics/telemetry.md>)

Tags: [aws](<https://devfeed.tech/tags/aws.md>), [go](<https://devfeed.tech/tags/go.md>), [golang](<https://devfeed.tech/tags/golang.md>), [http](<https://devfeed.tech/tags/http.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [metrics](<https://devfeed.tech/tags/metrics.md>), [monitoring](<https://devfeed.tech/tags/monitoring.md>), [networking](<https://devfeed.tech/tags/networking.md>), [observability](<https://devfeed.tech/tags/observability.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [prometheus](<https://devfeed.tech/tags/prometheus.md>), [uncategorized](<https://devfeed.tech/tags/uncategorized.md>)

### AI overview

Slack added and open-sourced QUIC support for Prometheus Blackbox Exporter to enable configurable HTTP/3 probes and restore client-side observability for its HTTP/3 endpoints.

### Source excerpt

The Problem: Legacy Tooling and Its Limitations Currently, Slack utilizes a hybrid approach to network measurement, incorporating both internal (such as traffic between AWS Availability Zones) and external (monitoring traffic from the public internet into Slack's infrastructure) solutions. These tools comprise a combination of commercial SaaS offerings and custom-built network testing solutions developed by our...

## Using Tools: A Meeting Scheduler

DevFeed: [Using Tools: A Meeting Scheduler](<https://devfeed.tech/articles/using-tools-a-meeting-scheduler-22284.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2026/03/using-tools-a-meeting-scheduler/>)

Published: 2026-03-16T00:00:00Z

Content type: tutorial

Language: en

Sources: [William Kennedy](<https://devfeed.tech/sources/william-kennedy.md>)

Topics: [Tool](<https://devfeed.tech/topics/tool.md>), [LLMs](<https://devfeed.tech/topics/llms.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [ardan-labs](<https://devfeed.tech/tags/ardan-labs.md>), [blog](<https://devfeed.tech/tags/blog.md>), [function-calling](<https://devfeed.tech/tags/function-calling.md>), [go](<https://devfeed.tech/tags/go.md>), [go-programming](<https://devfeed.tech/tags/go-programming.md>), [golang](<https://devfeed.tech/tags/golang.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [llms](<https://devfeed.tech/tags/llms.md>), [programming](<https://devfeed.tech/tags/programming.md>), [server](<https://devfeed.tech/tags/server.md>), [tools](<https://devfeed.tech/tags/tools.md>)

### AI overview

A tutorial on using LLM function calling to build a meeting-scheduling agent. It explains how tool calls work, covers the setup with the Kronk Model Server, and introduces the system prompt and tool definition.

### Source excerpt

Introduction LLMs are great, but they are trained on public data sets. In some cases, you need the LLM to use data that's not publicly available or that's frequently changing. There are several ways to make such data available to LLMs: Tool/function calls Retrieval-augmented generation (aka RAG) MCP In coding agents, you can also add skills. In this post we'll focus on function calling. How Does It Work? When interacting with an LLM, you can provide a description of available tools if the model supports tool calling. If the LLM reasons that the best answer is to use one of the tools, it will return a reply that contains a tool call with the parameters to use. Then you make the function call and return the answer back to the LLM.

## Range-Over Functions in Go

DevFeed: [Range-Over Functions in Go](<https://devfeed.tech/articles/range-over-functions-in-go-22234.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2024/04/range-over-functions-in-go.html>)

Published: 2026-02-16T00:00:00Z

Content type: article

Language: en

Sources: [William Kennedy](<https://devfeed.tech/sources/william-kennedy.md>)

Topics: [Go Language](<https://devfeed.tech/topics/go-language.md>), [Programming language](<https://devfeed.tech/topics/programming-language.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>)

Tags: [ardan-labs](<https://devfeed.tech/tags/ardan-labs.md>), [blog](<https://devfeed.tech/tags/blog.md>), [code](<https://devfeed.tech/tags/code.md>), [examples](<https://devfeed.tech/tags/examples.md>), [generators](<https://devfeed.tech/tags/generators.md>), [go](<https://devfeed.tech/tags/go.md>), [go-programming](<https://devfeed.tech/tags/go-programming.md>), [golang](<https://devfeed.tech/tags/golang.md>), [programming](<https://devfeed.tech/tags/programming.md>), [programming-language](<https://devfeed.tech/tags/programming-language.md>), [syntax](<https://devfeed.tech/tags/syntax.md>)

### AI overview

This article explains Go's range-over-functions experiment, which proposes a standardized iterator model while preserving the familiar for range syntax. It introduces the iter package and sequence abstractions, compares iteration patterns, and uses stack examples to show how iterator logic can be implemented.

### Source excerpt

Iteration has long been one of the more fragmented areas of Go, with developers relying on ad hoc patterns to traverse custom data structures. This article explores the range-over-functions experiment, a proposed evolution of the language that introduces a standardized iterator model while preserving Go's familiar for range syntax. Using the new iter package and sequence abstractions, it shows how iteration logic can be expressed more clearly, flexibly, and idiomatically. Originally published in April 2024, the concepts remain highly relevant as Go continues to evolve toward more expressive yet simple language features.

## Query Database Using Plain English

DevFeed: [Query Database Using Plain English](<https://devfeed.tech/articles/query-database-using-plain-english-22283.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2026/02/query-database-using-plain-english/>)

Published: 2026-02-11T00:00:00Z

Content type: tutorial

Language: en

Sources: [William Kennedy](<https://devfeed.tech/sources/william-kennedy.md>)

Topics: [Databases](<https://devfeed.tech/topics/databases.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [SQL](<https://devfeed.tech/topics/sql.md>), [Code](<https://devfeed.tech/topics/code.md>), [DuckDB](<https://devfeed.tech/topics/duckdb.md>), [Ollama](<https://devfeed.tech/topics/ollama.md>), [context](<https://devfeed.tech/topics/context.md>), [GitHub](<https://devfeed.tech/topics/github.md>), [API](<https://devfeed.tech/topics/api.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [ardan-labs](<https://devfeed.tech/tags/ardan-labs.md>), [blog](<https://devfeed.tech/tags/blog.md>), [code](<https://devfeed.tech/tags/code.md>), [context](<https://devfeed.tech/tags/context.md>), [database](<https://devfeed.tech/tags/database.md>), [duckdb](<https://devfeed.tech/tags/duckdb.md>), [github](<https://devfeed.tech/tags/github.md>), [go](<https://devfeed.tech/tags/go.md>), [go-programming](<https://devfeed.tech/tags/go-programming.md>), [golang](<https://devfeed.tech/tags/golang.md>), [llms](<https://devfeed.tech/tags/llms.md>), [ollama](<https://devfeed.tech/tags/ollama.md>), [programming](<https://devfeed.tech/tags/programming.md>), [sql](<https://devfeed.tech/tags/sql.md>)

### AI overview

This tutorial shows how to build a system that lets users query a relational database using plain English. It uses an LLM to generate SQL, executes the query against a database, and then uses the query results to generate an answer. The example uses the Austin Bike Share dataset, Kronk Model Server, and DuckDB, while noting that other model servers and SQL databases can be used.

### Source excerpt

Introduction In this post you'll see how you can create a system that allows users to query a relational database using plain English. This allows users not familiar with SQL or business intelligence systems to get insights from data. Setting Up If you want to follow along, you'll need to clone the code from the GitHub repo. This will download the code, and the database file containing the data (bikes.ddb) Note: The data is from the Austin Bike Share dataset.

## Kubernetes Memory Limits and Go

DevFeed: [Kubernetes Memory Limits and Go](<https://devfeed.tech/articles/kubernetes-memory-limits-and-go-22232.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2024/02/kubernetes-memory-limits-go.html>)

Published: 2026-01-27T00:00:00Z

Content type: article

Language: en

Sources: [William Kennedy](<https://devfeed.tech/sources/william-kennedy.md>)

Topics: [Go Language](<https://devfeed.tech/topics/go-language.md>), [Kubernetes](<https://devfeed.tech/topics/kubernetes.md>), [configuration](<https://devfeed.tech/topics/configuration.md>), [container](<https://devfeed.tech/topics/container.md>), [Testing](<https://devfeed.tech/topics/testing.md>)

Tags: [configuration](<https://devfeed.tech/tags/configuration.md>), [container](<https://devfeed.tech/tags/container.md>), [experiment](<https://devfeed.tech/tags/experiment.md>), [go](<https://devfeed.tech/tags/go.md>), [golang](<https://devfeed.tech/tags/golang.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [load-testing](<https://devfeed.tech/tags/load-testing.md>), [memory](<https://devfeed.tech/tags/memory.md>), [performance](<https://devfeed.tech/tags/performance.md>)

### AI overview

This article examines how Kubernetes memory limits interact with the Go runtime. Through controlled load testing, it investigates how out-of-memory events arise under hard limits and how GOMEMLIMIT, Kubernetes requests, and limits may help align Go services with container memory boundaries. The author notes that the results are experimental and may not apply directly to every service.

### Source excerpt

Kubernetes memory limits introduce a subtle but critical interaction with the Go runtime that can determine whether a service runs efficiently or fails under load. This article explores how Go manages memory under normal conditions and what changes when Kubernetes enforces hard memory constraints. Using controlled load testing, it shows why Go is generally excellent at self regulating memory, how OOM events emerge once limits are imposed, and how tools like GOMEMLIMIT can be used to align the runtime with container boundaries. Originally published in July 2024, the guidance remains highly relevant for teams running Go services in containerized environments where stability and throughput are tightly coupled to memory configuration.

## Rust Questions Answered in a JetBrains Livestream with Herbert Wolverson

DevFeed: [Rust Questions Answered in a JetBrains Livestream with Herbert Wolverson](<https://devfeed.tech/articles/everything-you-wanted-to-ask-about-rust-answered-by-herbert-wolverson-22282.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2026/01/everything-you-wanted-to-ask-about-rust-answered-by-herbert-wolverson/>)

Published: 2026-01-07T00:00:00Z

Content type: article

Language: en

Sources: [William Kennedy](<https://devfeed.tech/sources/william-kennedy.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [ardan-labs](<https://devfeed.tech/tags/ardan-labs.md>), [blog](<https://devfeed.tech/tags/blog.md>), [developers](<https://devfeed.tech/tags/developers.md>), [go](<https://devfeed.tech/tags/go.md>), [go-programming](<https://devfeed.tech/tags/go-programming.md>), [golang](<https://devfeed.tech/tags/golang.md>), [jetbrains](<https://devfeed.tech/tags/jetbrains.md>), [livestream](<https://devfeed.tech/tags/livestream.md>), [programming](<https://devfeed.tech/tags/programming.md>), [repo](<https://devfeed.tech/tags/repo.md>), [rust](<https://devfeed.tech/tags/rust.md>), [talk](<https://devfeed.tech/tags/talk.md>)

### AI overview

This article summarizes 23 questions discussed in a JetBrains livestream with Herbert Wolverson about Rust. Topics include his new book, Rust's memory model, the language's learning curve, and whether beginners should learn C first.

### Source excerpt

In a recent livestream with JetBrains, Vitaly Bragilevsky sat down with Herbert Wolverson, our Lead Rust Consultant and Instructor here at Ardan Labs, to talk about everything Rust developers - beginners and pros alike - are curious about. Watch the full livestream replay on the Ardan Labs Channel and check out the GitHub repo with Herbert's prepared answers and code samples. Below is a short summary of the 23 questions that were covered during the livestream.

## go.sum Is Not a Lockfile

DevFeed: [go.sum Is Not a Lockfile](<https://devfeed.tech/articles/go-sum-is-not-a-lockfile-20696.md>)

Original publisher: [Read original article](<https://words.filippo.io/gosum/>)

Author: Filippo Valsorda

Published: 2026-01-05T20:06:30Z

Content type: article

Language: en

Sources: [Filippo Valsorda](<https://devfeed.tech/sources/filippo-valsorda.md>)

Topics: [Go Language](<https://devfeed.tech/topics/go-language.md>), [modules](<https://devfeed.tech/topics/modules.md>), [Security](<https://devfeed.tech/topics/security.md>), [supply chain attacks](<https://devfeed.tech/topics/supply-chain-attacks.md>)

Tags: [dependencies](<https://devfeed.tech/tags/dependencies.md>), [go](<https://devfeed.tech/tags/go.md>), [golang](<https://devfeed.tech/tags/golang.md>), [modules](<https://devfeed.tech/tags/modules.md>), [security](<https://devfeed.tech/tags/security.md>), [supply-chain-attacks](<https://devfeed.tech/tags/supply-chain-attacks.md>)

### AI overview

The article explains that Go's go.sum is a local cache of cryptographic hashes for the Go Checksum Database, not a lockfile and not part of version resolution. It contrasts go.sum with go.mod, which lists the precise dependency versions used to build the main module and its tests.

### Source excerpt

In Go, go.mod acts as both manifest and lockfile. There is never a reason to look at go.sum.

## Getting Friendly With CPU Caches

DevFeed: [Getting Friendly With CPU Caches](<https://devfeed.tech/articles/getting-friendly-with-cpu-caches-22223.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2023/07/getting-friendly-with-cpu-caches.html>)

Published: 2025-10-21T00:00:00Z

Content type: tutorial

Language: en

Sources: [William Kennedy](<https://devfeed.tech/sources/william-kennedy.md>)

Topics: [CPU Cache](<https://devfeed.tech/topics/cpu-cache.md>), [Go Language](<https://devfeed.tech/topics/go-language.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Hardware](<https://devfeed.tech/topics/hardware.md>), [Caching](<https://devfeed.tech/topics/caching.md>)

Tags: [cache](<https://devfeed.tech/tags/cache.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [data](<https://devfeed.tech/tags/data.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [efficiency](<https://devfeed.tech/tags/efficiency.md>), [go](<https://devfeed.tech/tags/go.md>), [golang](<https://devfeed.tech/tags/golang.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [intel](<https://devfeed.tech/tags/intel.md>), [latency](<https://devfeed.tech/tags/latency.md>), [memory](<https://devfeed.tech/tags/memory.md>), [performance](<https://devfeed.tech/tags/performance.md>), [processor](<https://devfeed.tech/tags/processor.md>), [programming](<https://devfeed.tech/tags/programming.md>), [speed](<https://devfeed.tech/tags/speed.md>)

### AI overview

This tutorial explains how CPU cache behavior and data locality affect application performance. Using a Go case study, it shows that replacing a large embedded array in a user struct with a slice reduced cache misses and improved benchmark performance by more than 40 times.

### Source excerpt

Understanding how your data structures interact with hardware is one of the most powerful ways to improve application performance. This blogpost explores how CPU caches influence speed and how thoughtful struct design in Go can yield massive gains. Through a real-world case study, it shows how replacing a large embedded array with a slice improved performance by more than 40 times by reducing cache misses and improving data locality. Originally published in July 2023, its lessons remain highly relevant today for developers optimizing for memory efficiency and cache-aware programming.

## "Like night and day": How Auditzy made queries 33x faster by switching from Postgres to ClickHouse

DevFeed: ["Like night and day": How Auditzy made queries 33x faster by switching from Postgres to ClickHouse](<https://devfeed.tech/articles/like-night-and-day-how-auditzy-made-queries-33x-faster-by-switching-from-postgres-to-clickhouse-4969.md>)

Original publisher: [Read original article](<https://clickhouse.com/blog/auditzy-33x-faster-clickhouse-vs-postgres>)

Author: Mayank Joshi, Co-Founder and CTO, Auditzy

Published: 2025-10-09T00:00:00Z

Content type: article

Language: en

Sources: [ClickHouse Blog](<https://devfeed.tech/sources/clickhouse-blog.md>)

Topics: [clickhouse](<https://devfeed.tech/topics/clickhouse.md>), [data-architecture](<https://devfeed.tech/topics/data-architecture.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [Back end](<https://devfeed.tech/topics/backend.md>), [data](<https://devfeed.tech/topics/data.md>), [real-time](<https://devfeed.tech/topics/real-time.md>), [datasets](<https://devfeed.tech/topics/datasets.md>), [Amazon Web Services](<https://devfeed.tech/topics/aws.md>), [Azure](<https://devfeed.tech/topics/azure.md>), [browser](<https://devfeed.tech/topics/browser.md>), [Operating system](<https://devfeed.tech/topics/operating-system.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [aws](<https://devfeed.tech/tags/aws.md>), [azure](<https://devfeed.tech/tags/azure.md>), [backend](<https://devfeed.tech/tags/backend.md>), [browser](<https://devfeed.tech/tags/browser.md>), [clickhouse](<https://devfeed.tech/tags/clickhouse.md>), [compression](<https://devfeed.tech/tags/compression.md>), [data](<https://devfeed.tech/tags/data.md>), [data-architecture](<https://devfeed.tech/tags/data-architecture.md>), [datasets](<https://devfeed.tech/tags/datasets.md>), [geolocation](<https://devfeed.tech/tags/geolocation.md>), [golang](<https://devfeed.tech/tags/golang.md>), [india](<https://devfeed.tech/tags/india.md>), [latency](<https://devfeed.tech/tags/latency.md>), [metrics](<https://devfeed.tech/tags/metrics.md>), [performance](<https://devfeed.tech/tags/performance.md>), [postgres](<https://devfeed.tech/tags/postgres.md>), [real-time](<https://devfeed.tech/tags/real-time.md>), [scalable-architecture](<https://devfeed.tech/tags/scalable-architecture.md>), [switching](<https://devfeed.tech/tags/switching.md>)

### AI overview

Auditzy migrated from a Postgres-based architecture to ClickHouse after query latency and ingestion problems emerged as data volumes grew. The migration delivered queries that were 33x faster and 10x better compression, supporting scalable, real-time website performance analytics.

### Source excerpt

When Mumbai-based startup Auditzy hit Postgres performance limits, they switched to ClickHouse--and saw queries run 33x faster with 10x better compression.

## Kubernetes CPU Limits and Go

DevFeed: [Kubernetes CPU Limits and Go](<https://devfeed.tech/articles/kubernetes-cpu-limits-and-go-22231.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2024/02/kubernetes-cpu-limits-go.html>)

Published: 2025-09-22T00:00:00Z

Content type: article

Language: en

Sources: [William Kennedy](<https://devfeed.tech/sources/william-kennedy.md>)

Topics: [Kubernetes](<https://devfeed.tech/topics/kubernetes.md>), [Go Language](<https://devfeed.tech/topics/go-language.md>), [configuration](<https://devfeed.tech/topics/configuration.md>)

Tags: [configuration](<https://devfeed.tech/tags/configuration.md>), [go](<https://devfeed.tech/tags/go.md>), [golang](<https://devfeed.tech/tags/golang.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [performance](<https://devfeed.tech/tags/performance.md>), [yaml](<https://devfeed.tech/tags/yaml.md>)

### AI overview

This article explains how Kubernetes CPU limits and throttling can affect the performance of Go services. It examines millicore-based CPU settings, including a 250m limit, and discusses why services may run less efficiently when they are not configured for the assigned CPU scope.

### Source excerpt

Kubernetes CPU limits can look straightforward on the surface, but their impact on application performance is anything but simple. This article unpacks how Go services interact with Kubernetes CPU throttling and why a seemingly harmless configuration such as setting a limit of 250m can dramatically constrain performance in production. First published in February 2024, its insights remain just as relevant today for anyone running Go applications in containerized environments and for developers who want to avoid costly slowdowns.

## Inside Go - Part 3: Garbage Collection

DevFeed: [Inside Go - Part 3: Garbage Collection](<https://devfeed.tech/articles/inside-go-part-3-garbage-collection-39765.md>)

Original publisher: [Read original article](<https://furkankolcu.com/post/inside-go-part-3-garbage-collection>)

Author: Furkan Kolcu

Published: 2025-09-16T14:30:04Z

Content type: tutorial

Language: en

Sources: [Furkan Kolcu - Software Engineer Blog](<https://devfeed.tech/sources/furkan-kolcu-software-engineer-blog.md>)

Topics: [Go Language](<https://devfeed.tech/topics/go-language.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [garbage-collection](<https://devfeed.tech/tags/garbage-collection.md>), [go](<https://devfeed.tech/tags/go.md>), [go-garbage-collector](<https://devfeed.tech/tags/go-garbage-collector.md>), [gogc](<https://devfeed.tech/tags/gogc.md>), [golang](<https://devfeed.tech/tags/golang.md>), [inside-go](<https://devfeed.tech/tags/inside-go.md>), [performance](<https://devfeed.tech/tags/performance.md>), [runtime](<https://devfeed.tech/tags/runtime.md>), [technology](<https://devfeed.tech/tags/technology.md>)

### AI overview

This tutorial explains the evolution of Go's garbage collector from stop-the-world pauses to mostly concurrent collection. It introduces tri-color marking, explains the purpose of write barriers, and indicates that it will cover GOGC tuning.

### Source excerpt

How Go's GC grew from full pauses to mostly concurrent, what the tri-color algorithm does, why write barriers matter, and how to tune GC with GOGC without shooting yourself in the foot are how we will walk through in this part.

## Inside Go -- Part 2: Memory Management in Go

DevFeed: [Inside Go -- Part 2: Memory Management in Go](<https://devfeed.tech/articles/inside-go-part-2-memory-management-in-go-39764.md>)

Original publisher: [Read original article](<https://furkankolcu.com/post/inside-go-part-2-memory-management-in-go>)

Author: Furkan Kolcu

Published: 2025-09-12T16:30:37Z

Content type: tutorial

Language: en

Sources: [Furkan Kolcu - Software Engineer Blog](<https://devfeed.tech/sources/furkan-kolcu-software-engineer-blog.md>)

Topics: [Go Language](<https://devfeed.tech/topics/go-language.md>), [escape analysis](<https://devfeed.tech/topics/escape-analysis.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>)

Tags: [compiler](<https://devfeed.tech/tags/compiler.md>), [escape-analysis](<https://devfeed.tech/tags/escape-analysis.md>), [garbage-collection](<https://devfeed.tech/tags/garbage-collection.md>), [go](<https://devfeed.tech/tags/go.md>), [go-memory-management](<https://devfeed.tech/tags/go-memory-management.md>), [golang](<https://devfeed.tech/tags/golang.md>), [heap](<https://devfeed.tech/tags/heap.md>), [memory](<https://devfeed.tech/tags/memory.md>), [memory-management](<https://devfeed.tech/tags/memory-management.md>), [performance](<https://devfeed.tech/tags/performance.md>), [stack](<https://devfeed.tech/tags/stack.md>), [technology](<https://devfeed.tech/tags/technology.md>)

### AI overview

This tutorial explains how Go manages memory through stack and heap allocation, escape analysis, and garbage collection. It also shows how compiler decisions affect performance and how to inspect escape analysis results.

### Source excerpt

A deep dive into how Go handles memory behind the scenes. Learn the difference between stack and heap, how escape analysis works, and why memory management plays a key role in performance.

## Inside Go -- Part 1: The Compilation Pipeline

DevFeed: [Inside Go -- Part 1: The Compilation Pipeline](<https://devfeed.tech/articles/inside-go-part-1-the-compilation-pipeline-39763.md>)

Original publisher: [Read original article](<https://furkankolcu.com/post/inside-go-part-1-the-compilation-pipeline>)

Author: Furkan Kolcu

Published: 2025-09-11T10:34:38Z

Content type: tutorial

Language: en

Sources: [Furkan Kolcu - Software Engineer Blog](<https://devfeed.tech/sources/furkan-kolcu-software-engineer-blog.md>)

Topics: [Go Language](<https://devfeed.tech/topics/go-language.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [Parsing](<https://devfeed.tech/topics/parsing.md>), [Parser](<https://devfeed.tech/topics/parser.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>), [Code generation](<https://devfeed.tech/topics/code-generation.md>), [Assembly](<https://devfeed.tech/topics/assembly.md>)

Tags: [assembly](<https://devfeed.tech/tags/assembly.md>), [ast](<https://devfeed.tech/tags/ast.md>), [code-generation](<https://devfeed.tech/tags/code-generation.md>), [compilation](<https://devfeed.tech/tags/compilation.md>), [go](<https://devfeed.tech/tags/go.md>), [go-ast](<https://devfeed.tech/tags/go-ast.md>), [go-compilation](<https://devfeed.tech/tags/go-compilation.md>), [go-compiler](<https://devfeed.tech/tags/go-compiler.md>), [go-internals](<https://devfeed.tech/tags/go-internals.md>), [go-lexer](<https://devfeed.tech/tags/go-lexer.md>), [go-parser](<https://devfeed.tech/tags/go-parser.md>), [go-ssa](<https://devfeed.tech/tags/go-ssa.md>), [golang](<https://devfeed.tech/tags/golang.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [parsing](<https://devfeed.tech/tags/parsing.md>), [ssa](<https://devfeed.tech/tags/ssa.md>), [technology](<https://devfeed.tech/tags/technology.md>)

### AI overview

This tutorial explains how Go source code is transformed into a native executable. It covers lexing and parsing, abstract syntax trees, type checking, SSA, optimization, code generation, and linking, with simple examples and analogies.

### Source excerpt

In this first part of the "Inside Go" series, I'll walk through how Go source code transforms into a binary. From lexing and parsing to ASTs, SSA, and optimizations, we'll explore the steps of the Go compilation pipeline with simple code examples and analogies to make sense of it all.

## Inside Go -- How It Really Works: Series Kickoff

DevFeed: [Inside Go -- How It Really Works: Series Kickoff](<https://devfeed.tech/articles/inside-go-how-it-really-works-series-kickoff-39762.md>)

Original publisher: [Read original article](<https://furkankolcu.com/post/inside-go-how-it-really-works-series-kickoff>)

Author: Furkan Kolcu

Published: 2025-09-11T10:16:52Z

Content type: article

Language: en

Sources: [Furkan Kolcu - Software Engineer Blog](<https://devfeed.tech/sources/furkan-kolcu-software-engineer-blog.md>)

Topics: [Go Language](<https://devfeed.tech/topics/go-language.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Code](<https://devfeed.tech/topics/code.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>), [escape analysis](<https://devfeed.tech/topics/escape-analysis.md>), [generics](<https://devfeed.tech/topics/generics.md>), [modules](<https://devfeed.tech/topics/modules.md>), [reproducible builds](<https://devfeed.tech/topics/reproducible-builds.md>)

Tags: [compilation](<https://devfeed.tech/tags/compilation.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [deep-dive](<https://devfeed.tech/tags/deep-dive.md>), [generics](<https://devfeed.tech/tags/generics.md>), [go](<https://devfeed.tech/tags/go.md>), [go-compiler](<https://devfeed.tech/tags/go-compiler.md>), [go-concurrency](<https://devfeed.tech/tags/go-concurrency.md>), [go-performance](<https://devfeed.tech/tags/go-performance.md>), [go-runtime](<https://devfeed.tech/tags/go-runtime.md>), [golang](<https://devfeed.tech/tags/golang.md>), [how-go-works](<https://devfeed.tech/tags/how-go-works.md>), [inside-go](<https://devfeed.tech/tags/inside-go.md>), [internals](<https://devfeed.tech/tags/internals.md>), [memory-management](<https://devfeed.tech/tags/memory-management.md>), [performance](<https://devfeed.tech/tags/performance.md>), [technology](<https://devfeed.tech/tags/technology.md>)

### AI overview

This article launches a technical series about how Go works internally. The planned installments cover compilation, memory management, garbage collection, concurrency, the runtime, performance tuning, interfaces, generics, modules, and reproducible builds, with code examples and runtime experiments.

### Source excerpt

A deep-dive series into Go's internals. From compilation to memory management, concurrency, and performance tuning, each part unpacks how Go operates under the hood with clear explanations and real-life code examples.

## Whodunit: LLM Murder Mysteries

DevFeed: [Whodunit: LLM Murder Mysteries](<https://devfeed.tech/articles/whodunit-llm-murder-mysteries-37524.md>)

Original publisher: [Read original article](<https://blog.apartment304.com/whodunit-llm-murder-mysteries/>)

Author: James Heller

Published: 2025-08-26T07:00:00Z

Content type: article

Language: en

Sources: [Apartment 304](<https://devfeed.tech/sources/apartment-304.md>)

Topics: [LLM Techniques](<https://devfeed.tech/topics/llm-techniques.md>), [Go Language](<https://devfeed.tech/topics/go-language.md>)

Tags: [ai-authored](<https://devfeed.tech/tags/ai-authored.md>), [apartment-304](<https://devfeed.tech/tags/apartment-304.md>), [custom-software-solutions](<https://devfeed.tech/tags/custom-software-solutions.md>), [devops](<https://devfeed.tech/tags/devops.md>), [devops-engineer](<https://devfeed.tech/tags/devops-engineer.md>), [go](<https://devfeed.tech/tags/go.md>), [golang](<https://devfeed.tech/tags/golang.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [large-language-models](<https://devfeed.tech/tags/large-language-models.md>), [llm](<https://devfeed.tech/tags/llm.md>), [logic](<https://devfeed.tech/tags/logic.md>), [models](<https://devfeed.tech/tags/models.md>), [puzzle](<https://devfeed.tech/tags/puzzle.md>), [puzzles](<https://devfeed.tech/tags/puzzles.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [software-engineer](<https://devfeed.tech/tags/software-engineer.md>), [strategies](<https://devfeed.tech/tags/strategies.md>), [test](<https://devfeed.tech/tags/test.md>)

### AI overview

This article describes building Whodunit, a low-tech murder-mystery game whose mysteries are written with large language models. It discusses developing a mental model for calling LLMs, testing LLM services and Go libraries, improving logical soundness through trial and error, and managing unreliable LLM APIs.

### Source excerpt

Can Large Language Models write engaging mysteries? Find out in this week's episode of "Whodunit?"

## Garbage Collection In Go : Part III - GC Pacing

DevFeed: [Garbage Collection In Go : Part III - GC Pacing](<https://devfeed.tech/articles/garbage-collection-in-go-part-iii-gc-pacing-22148.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2019/07/garbage-collection-in-go-part3-gcpacing.html>)

Published: 2025-08-26T00:00:00Z

Content type: tutorial

Language: en

Sources: [William Kennedy](<https://devfeed.tech/sources/william-kennedy.md>)

Topics: [Go Language](<https://devfeed.tech/topics/go-language.md>), [benchmarking](<https://devfeed.tech/topics/benchmarking.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Code](<https://devfeed.tech/topics/code.md>), [Latency](<https://devfeed.tech/topics/latency.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [ardan-labs](<https://devfeed.tech/tags/ardan-labs.md>), [blog](<https://devfeed.tech/tags/blog.md>), [code](<https://devfeed.tech/tags/code.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [garbage-collection](<https://devfeed.tech/tags/garbage-collection.md>), [go](<https://devfeed.tech/tags/go.md>), [go-programming](<https://devfeed.tech/tags/go-programming.md>), [golang](<https://devfeed.tech/tags/golang.md>), [latency](<https://devfeed.tech/tags/latency.md>), [low-latency](<https://devfeed.tech/tags/low-latency.md>), [memory](<https://devfeed.tech/tags/memory.md>), [performance](<https://devfeed.tech/tags/performance.md>), [programming](<https://devfeed.tech/tags/programming.md>)

### AI overview

This third article in a three-part series explains how Go's garbage collector paces itself according to workload demands. It uses sequential and concurrent examples to examine adaptive behavior and emphasizes reducing allocations per unit of work to reduce garbage-collection latency and improve application performance.

### Source excerpt

Go's garbage collector is designed not only to manage memory safely but also to pace itself intelligently, striking a balance between low latency and high throughput. This blogpost explores how the GC adapts its pace to workload demands, demonstrated through both sequential and concurrent program examples, and why reducing allocations per unit of work is the most effective way to lighten its load. Originally published in 2019, its core principles remain just as relevant today, offering Go developers a deeper understanding of the runtime's adaptive behavior and confidence that the GC can find the right rhythm without extensive manual tuning.

## August 2025 newsletter

DevFeed: [August 2025 newsletter](<https://devfeed.tech/articles/august-2025-newsletter-4892.md>)

Original publisher: [Read original article](<https://clickhouse.com/blog/202508-newsletter>)

Author: Mark Needham

Published: 2025-08-22T00:00:00Z

Content type: news

Language: en

Sources: [ClickHouse Blog](<https://devfeed.tech/sources/clickhouse-blog.md>)

Topics: [data-processing](<https://devfeed.tech/topics/data-processing.md>), [ai observability](<https://devfeed.tech/topics/ai-observability.md>)

Tags: [claude](<https://devfeed.tech/tags/claude.md>), [clickhouse](<https://devfeed.tech/tags/clickhouse.md>), [community](<https://devfeed.tech/tags/community.md>), [golang](<https://devfeed.tech/tags/golang.md>), [llm](<https://devfeed.tech/tags/llm.md>), [mapping](<https://devfeed.tech/tags/mapping.md>), [observability](<https://devfeed.tech/tags/observability.md>), [real-time](<https://devfeed.tech/tags/real-time.md>), [updates](<https://devfeed.tech/tags/updates.md>), [vector](<https://devfeed.tech/tags/vector.md>)

### AI overview

The August 2025 ClickHouse newsletter covers ClickHouse 25.7 updates, LLM observability with ClickStack, a Gemini-versus-Claude SQL comparison, and a community example for serving geospatial vector tiles from ClickHouse.

### Source excerpt

Welcome to the August 2025 ClickHouse newsletter, which will round up what's happened in real-time data warehouses over the last month.

## We built an MCP server so Claude can access your incidents

DevFeed: [We built an MCP server so Claude can access your incidents](<https://devfeed.tech/articles/we-built-an-mcp-server-so-claude-can-access-your-incidents-12059.md>)

Original publisher: [Read original article](<https://incident.io/blog/we-built-an-mcp-server-so-claude-can-access-your-incidents>)

Author: Tom Wentworth

Published: 2025-08-04T14:14:54Z

Content type: article

Language: en

Sources: [The incident.io Blog](<https://devfeed.tech/sources/the-incident-io-blog.md>)

Topics: [Model Context Protocol](<https://devfeed.tech/topics/model-context-protocol.md>), [MCP Server](<https://devfeed.tech/topics/mcp-server.md>), [incident management](<https://devfeed.tech/topics/incident-management.md>), [Claude](<https://devfeed.tech/topics/claude.md>), [API](<https://devfeed.tech/topics/api.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [claude](<https://devfeed.tech/tags/claude.md>), [golang](<https://devfeed.tech/tags/golang.md>), [incident](<https://devfeed.tech/tags/incident.md>), [incident-channel](<https://devfeed.tech/tags/incident-channel.md>), [incident-management](<https://devfeed.tech/tags/incident-management.md>), [incident-response](<https://devfeed.tech/tags/incident-response.md>), [mcp](<https://devfeed.tech/tags/mcp.md>), [mcp-server](<https://devfeed.tech/tags/mcp-server.md>), [outage](<https://devfeed.tech/tags/outage.md>), [post-mortem](<https://devfeed.tech/tags/post-mortem.md>), [slack-incident](<https://devfeed.tech/tags/slack-incident.md>)

### AI overview

incident.io built an MCP server that connects Claude and other MCP-compatible AI assistants to incident.io, allowing users to retrieve, create, manage, search, and analyze incidents through natural-language conversations. The article explains its Golang bridge architecture, which maps tools to incident.io API endpoints and formats returned data for Claude. It also notes that the legacy server was open source and MIT licensed, while an official hosted MCP server is now available.

### Source excerpt

We built an open-source MCP server that lets Claude directly access and manage your incident.io incidents through natural conversation. Instead of switching between tools when things break, you can now ask Claude to create incidents, update statuses, and pull context, all while staying in your existing workflow.

## Garbage Collection In Go : Part II - GC Traces

DevFeed: [Garbage Collection In Go : Part II - GC Traces](<https://devfeed.tech/articles/garbage-collection-in-go-part-ii-gc-traces-22145.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2019/05/garbage-collection-in-go-part2-gctraces.html>)

Published: 2025-07-14T00:00:00Z

Content type: tutorial

Language: en

Sources: [William Kennedy](<https://devfeed.tech/sources/william-kennedy.md>)

Topics: [Go Language](<https://devfeed.tech/topics/go-language.md>), [Traces](<https://devfeed.tech/topics/traces.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [App](<https://devfeed.tech/topics/app.md>), [web applications](<https://devfeed.tech/topics/web-applications.md>)

Tags: [ardan-labs](<https://devfeed.tech/tags/ardan-labs.md>), [article](<https://devfeed.tech/tags/article.md>), [blog](<https://devfeed.tech/tags/blog.md>), [go](<https://devfeed.tech/tags/go.md>), [go-programming](<https://devfeed.tech/tags/go-programming.md>), [golang](<https://devfeed.tech/tags/golang.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [latency](<https://devfeed.tech/tags/latency.md>), [performance](<https://devfeed.tech/tags/performance.md>), [programming](<https://devfeed.tech/tags/programming.md>), [techniques](<https://devfeed.tech/tags/techniques.md>), [traces](<https://devfeed.tech/tags/traces.md>)

### AI overview

Part two of a three-part series on Go's garbage collector explains how to generate and interpret GC traces and application profiles. It shows how to identify allocation hotspots and reduce unnecessary allocations to improve latency and throughput.

### Source excerpt

Originally published in 2019, this article is part two of a three-part series exploring Go's garbage collector. Though the Go runtime has continued to evolve, the performance principles covered here remain highly relevant today. This installment focuses on practical techniques for analyzing and reducing garbage collection (GC) overhead in real-world Go applications. It walks through how to interpret GC traces using GODEBUG=gctrace=1 and uncover allocation hotspots with pprof, with a clear message: reducing unnecessary allocations, especially in tight loops, has a direct and measurable impact on latency and throughput. Whether you're optimizing high-performance services or just becoming GC-aware, the insights here are as applicable now as ever.

## Golang and Let's Encrypt: a free software story

DevFeed: [Golang and Let's Encrypt: a free software story](<https://devfeed.tech/articles/golang-and-let-s-encrypt-a-free-software-story-36217.md>)

Original publisher: [Read original article](<https://dotat.at/@/2025-06-28-boulder.html>)

Published: 2025-06-26T01:41:49Z

Content type: opinion

Language: en

Sources: [Tony Finch's blog](<https://devfeed.tech/sources/tony-finch-s-blog.md>)

Topics: [let's encrypt](<https://devfeed.tech/topics/let-s-encrypt.md>), [free software](<https://devfeed.tech/topics/free-software.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [CASE](<https://devfeed.tech/topics/casejs.md>), [Testing](<https://devfeed.tech/topics/testing.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [bug](<https://devfeed.tech/tags/bug.md>), [continuous-integration](<https://devfeed.tech/tags/continuous-integration.md>), [free-software](<https://devfeed.tech/tags/free-software.md>), [golang](<https://devfeed.tech/tags/golang.md>), [let-s-encrypt](<https://devfeed.tech/tags/let-s-encrypt.md>), [pull-request](<https://devfeed.tech/tags/pull-request.md>), [review](<https://devfeed.tech/tags/review.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

The author recounts fixing a Let's Encrypt Boulder bug involving mail-domain validation as a newcomer to Golang. They describe relying on Let's Encrypt's cloud test setup, submitting a small pull request, and seeing it merged into production within a few days.

### Source excerpt

Here's a story from nearly 10 years ago. the bug I think it was my friend Richard Kettlewell who told me about a bug he encountered with Let's Encrypt in its early days in autumn 2015: it was failing to validate mail domains correctly. the context At the time I had previously been responsible for Cambridge University's email anti-spam system for about 10 years, and in 2014 I had been given responsibility for Cambridge University's DNS. So I knew how Let's Encrypt should validate mail domains. Let's Encrypt was about one year old. Unusually, the code that runs their operations, Boulder, is free software and open to external contributors. Boulder is written in Golang, and I had not previously written any code in Golang. But its reputation is to be easy to get to grips with. So, in principle, the bug was straightforward for me to fix. How difficult would it be as a Golang newbie? And what would Let's Encrypt's contribution process be like? the hack I cloned the Boulder repository and had a look around the code. As is pretty typical, there are a couple of stages to fixing a bug in an unfamiliar codebase: work out where the problem is try to understand if the obvious fix could be better In this case, I remember discovering a relatively substantial TODO item that intersected with the bug. I can't remember the details, but I think there were wider issues with DNS lookups in Boulder. I decided it made sense to fix the immediate problem without getting involved in things that would require discussion with Let's Encrypt staff. I faffed around with the code and pushed something that looked like it might work. A fun thing about this hack is that I never got a working Boulder test setup on my workstation (or even Golang, I think!) - I just relied on the Let's Encrypt cloud test setup. The feedback time was very slow, but it was tolerable for a simple one-off change. the fix My pull request was small, +48-14. After a couple of rounds of review and within a few days, it was merged

[Next page](<https://devfeed.tech/tags/golang.md?cursor=WyIyMDI1LTA2LTI2VDAxOjQxOjQ5KzAwOjAwIiwgIjBiMjBiYjAwLWE0MGItNGUyNi05OTA3LWZiMTU3MGI0YzljOCJd>)