# William Kennedy

Recent content in Ardan Labs Blog on

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

## 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.

## 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.

## 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.

## 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.

## 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.

## 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.

## Garbage Collection In Go : Part I - Semantics

DevFeed: [Garbage Collection In Go : Part I - Semantics](<https://devfeed.tech/articles/garbage-collection-in-go-part-i-semantics-22140.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2018/12/garbage-collection-in-go-part1-semantics.html>)

Published: 2025-06-10T00: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>), [Programming language](<https://devfeed.tech/topics/programming-language.md>), [Algorithm](<https://devfeed.tech/topics/algorithm.md>), [Software](<https://devfeed.tech/topics/software.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [ardan-labs](<https://devfeed.tech/tags/ardan-labs.md>), [blog](<https://devfeed.tech/tags/blog.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>), [guide](<https://devfeed.tech/tags/guide.md>), [internals](<https://devfeed.tech/tags/internals.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 tutorial explains the semantics of Go's garbage collector, including heap allocation tracking, concurrent tri-color mark-and-sweep collection, and Stop The World events. It presents a behavioral model intended to remain useful despite changes to runtime implementation details.

### Source excerpt

This article was originally published in 2018, yet its core insights into Go's garbage collection model remain highly relevant for developers today. While some implementation details of Go's runtime have evolved, the foundational concepts explored here--such as the semantics of the tri-color mark and sweep algorithm, Stop The World (STW) events, and GC trace interpretation--are still essential to understanding how Go manages memory. Whether you're optimizing performance or deepening your knowledge of Go internals, this post continues to offer a clear and practical guide to working with the garbage collector, not against it.

## JSON - The Fine Print: Part 3 - Zero vs Missing Values

DevFeed: [JSON - The Fine Print: Part 3 - Zero vs Missing Values](<https://devfeed.tech/articles/json-the-fine-print-part-3-zero-vs-missing-values-22281.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2025/05/json-the-fine-print-part-3.html>)

Published: 2025-05-19T00:00:00Z

Content type: tutorial

Language: en

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

Topics: [JSON](<https://devfeed.tech/topics/json.md>), [Go Language](<https://devfeed.tech/topics/go-language.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [api-layers](<https://devfeed.tech/tags/api-layers.md>), [code](<https://devfeed.tech/tags/code.md>), [common-serialization-errors](<https://devfeed.tech/tags/common-serialization-errors.md>), [data-serialization](<https://devfeed.tech/tags/data-serialization.md>), [data-structure-separation](<https://devfeed.tech/tags/data-structure-separation.md>), [data-transmission](<https://devfeed.tech/tags/data-transmission.md>), [data-validation](<https://devfeed.tech/tags/data-validation.md>), [encoding-json](<https://devfeed.tech/tags/encoding-json.md>), [go](<https://devfeed.tech/tags/go.md>), [go-json-types](<https://devfeed.tech/tags/go-json-types.md>), [go-language-serialization](<https://devfeed.tech/tags/go-language-serialization.md>), [go-language-validation](<https://devfeed.tech/tags/go-language-validation.md>), [go-type-mapping](<https://devfeed.tech/tags/go-type-mapping.md>), [json](<https://devfeed.tech/tags/json.md>), [json-best-practices](<https://devfeed.tech/tags/json-best-practices.md>), [json-go-mapping](<https://devfeed.tech/tags/json-go-mapping.md>), [json-marshaling](<https://devfeed.tech/tags/json-marshaling.md>), [json-unmarshaling](<https://devfeed.tech/tags/json-unmarshaling.md>), [json-validation](<https://devfeed.tech/tags/json-validation.md>), [passing-serialized-data](<https://devfeed.tech/tags/passing-serialized-data.md>), [rest-apis](<https://devfeed.tech/tags/rest-apis.md>), [schema-less-data-format](<https://devfeed.tech/tags/schema-less-data-format.md>), [serialization](<https://devfeed.tech/tags/serialization.md>), [serialization-mistakes](<https://devfeed.tech/tags/serialization-mistakes.md>), [serialization-protocols](<https://devfeed.tech/tags/serialization-protocols.md>), [unmarshalling](<https://devfeed.tech/tags/unmarshalling.md>)

### AI overview

This tutorial examines how to distinguish zero values from missing or NULL fields when consuming JSON in Go. It explains basic unmarshalling into structs, notes that absent fields do not cause errors, and introduces DisallowUnknownFields for validating exact JSON input.

### Source excerpt

Introduction In part 1 we took a higher level view on serialization in general and JSON in specific. In part 2 we looked at emitting JSON. In part 3, we'll look at an issue you might encounter when consuming JSON, Zero vs NULL field values. To clarify the definition of NULL, this means the absence of value. So here is the question: Given a field in a Go struct set to its zero value, how do you know that zero value was set by the user or it's zero because it was never provided?

## Scheduling In Go : Part III - Concurrency

DevFeed: [Scheduling In Go : Part III - Concurrency](<https://devfeed.tech/articles/scheduling-in-go-part-iii-concurrency-22142.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2018/12/scheduling-in-go-part3.html>)

Published: 2025-05-12T00:00:00Z

Content type: tutorial

Language: en

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

Topics: [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Go Language](<https://devfeed.tech/topics/go-language.md>), [benchmarking](<https://devfeed.tech/topics/benchmarking.md>), [IO](<https://devfeed.tech/topics/io.md>), [Sorting](<https://devfeed.tech/topics/sorting.md>)

Tags: [ardan-labs](<https://devfeed.tech/tags/ardan-labs.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [blog](<https://devfeed.tech/tags/blog.md>), [concepts](<https://devfeed.tech/tags/concepts.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [go](<https://devfeed.tech/tags/go.md>), [go-programming](<https://devfeed.tech/tags/go-programming.md>), [golang](<https://devfeed.tech/tags/golang.md>), [io](<https://devfeed.tech/tags/io.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [performance](<https://devfeed.tech/tags/performance.md>), [programming](<https://devfeed.tech/tags/programming.md>), [sorting](<https://devfeed.tech/tags/sorting.md>), [technical](<https://devfeed.tech/tags/technical.md>)

### AI overview

This third post in a series about the Go scheduler explains concurrency as out-of-order execution and distinguishes it from parallelism. It discusses how CPU-bound and I/O-bound workloads affect the decision to use concurrency, using practical examples and benchmarks to show that parallelism can improve CPU-bound performance while concurrency alone can benefit I/O-bound work.

### Source excerpt

Although originally written in 2018, the following concepts remain essential for developers working with concurrency. This blogpost focuses on concurrency, distinguishing it from parallelism by defining it as "out of order" execution. It emphasizes the importance of understanding workload types--CPU bound (e.g., summing, sorting) and IO bound (e.g., file reading)--to assess when concurrency is appropriate. Through practical examples and benchmarks, it shows that parallelism boosts performance for CPU bound tasks, while concurrency alone benefits IO bound workloads. The post underscores that identifying workload type is key to applying concurrency effectively without added complexity.

## Scheduling In Go : Part II - Go Scheduler

DevFeed: [Scheduling In Go : Part II - Go Scheduler](<https://devfeed.tech/articles/scheduling-in-go-part-ii-go-scheduler-22138.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2018/08/scheduling-in-go-part2.html>)

Published: 2025-04-14T00: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>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>), [systems](<https://devfeed.tech/topics/systems.md>)

Tags: [ardan-labs](<https://devfeed.tech/tags/ardan-labs.md>), [blog](<https://devfeed.tech/tags/blog.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [context](<https://devfeed.tech/tags/context.md>), [go](<https://devfeed.tech/tags/go.md>), [go-programming](<https://devfeed.tech/tags/go-programming.md>), [golang](<https://devfeed.tech/tags/golang.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [os](<https://devfeed.tech/tags/os.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [programming](<https://devfeed.tech/tags/programming.md>), [scheduler](<https://devfeed.tech/tags/scheduler.md>), [switching](<https://devfeed.tech/tags/switching.md>), [systems](<https://devfeed.tech/tags/systems.md>), [threads](<https://devfeed.tech/tags/threads.md>)

### AI overview

The second article in a three-part series explains the Go scheduler at a semantic level. It covers logical processors, global and local run queues, context switching, work stealing, and synchronous and asynchronous system calls.

### Source excerpt

This blogpost is the second installment in a three-part series exploring the mechanics and semantics of the Go scheduler. Despite being published in 2018, the content remains relevant today, as the Go scheduler's design continues to influence the development of efficient and scalable concurrent systems. In this post, we will go into the inner workings of the Go scheduler, discussing its components, such as the Global Run Queue (GRQ) and Local Run Queue (LRQ), and its behavior, including context switching, work stealing, and the handling of synchronous and asynchronous system calls. By understanding these concepts, developers can make informed decisions about concurrency and optimization in their Go applications.

## Scheduling In Go : Part I - OS Scheduler

DevFeed: [Scheduling In Go : Part I - OS Scheduler](<https://devfeed.tech/articles/scheduling-in-go-part-i-os-scheduler-22137.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2018/08/scheduling-in-go-part1.html>)

Published: 2025-03-04T00: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>), [Operating system](<https://devfeed.tech/topics/operating-system.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Kernel](<https://devfeed.tech/topics/kernel.md>)

Tags: [ardan-labs](<https://devfeed.tech/tags/ardan-labs.md>), [blog](<https://devfeed.tech/tags/blog.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [fundamentals](<https://devfeed.tech/tags/fundamentals.md>), [go](<https://devfeed.tech/tags/go.md>), [go-programming](<https://devfeed.tech/tags/go-programming.md>), [golang](<https://devfeed.tech/tags/golang.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [numa](<https://devfeed.tech/tags/numa.md>), [os](<https://devfeed.tech/tags/os.md>), [programming](<https://devfeed.tech/tags/programming.md>)

### AI overview

This first article in a three-part series explains operating-system scheduling as a foundation for understanding Go's scheduler. It discusses how schedulers interact with multithreaded Go programs and introduces hardware considerations such as processors, CPU caches, and NUMA.

### Source excerpt

Although this blogpost was originally published in 2018, the concepts and principles discussed remain crucial for building efficient and performant multithreaded applications in Go now in 2025 (Go 1.24.0). As the Go ecosystem continues to evolve, understanding how the Go scheduler interacts with the operating system scheduler is more important than ever. This three-part series provides a comprehensive overview of the mechanics and semantics behind Go's scheduling, starting with the fundamentals of the operating system scheduler.

## Context Package Semantics In Go

DevFeed: [Context Package Semantics In Go](<https://devfeed.tech/articles/context-package-semantics-in-go-22150.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2019/09/context-package-semantics-in-go.html>)

Published: 2025-02-10T00: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>), [context](<https://devfeed.tech/topics/context.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Software](<https://devfeed.tech/topics/software.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>), [cancellation](<https://devfeed.tech/tags/cancellation.md>), [go](<https://devfeed.tech/tags/go.md>), [go-programming](<https://devfeed.tech/tags/go-programming.md>), [golang](<https://devfeed.tech/tags/golang.md>), [goroutines](<https://devfeed.tech/tags/goroutines.md>), [latency](<https://devfeed.tech/tags/latency.md>), [pitfalls](<https://devfeed.tech/tags/pitfalls.md>), [programming](<https://devfeed.tech/tags/programming.md>)

### AI overview

This tutorial explains the semantics of Go's Context package, including request-scoped data, deadlines, cancellation signals, and how to introduce contexts early when designing APIs. It also discusses managing goroutine lifetime and latency in services.

### Source excerpt

Although first introduced in 2014, the Context package remains a crucial component of Go programming, enabling efficient management of request-scoped data, deadlines, and cancellation signals. As the Go ecosystem continues to evolve, understanding the Context package's semantics is vital for developing reliable and maintainable software. This blogpost provides an in-depth exploration of the Context package's semantics, highlighting best practices and common pitfalls to help developers effectively leverage this powerful tool.

## JSON - The Fine Print: Part 2 - Emitting JSON

DevFeed: [JSON - The Fine Print: Part 2 - Emitting JSON](<https://devfeed.tech/articles/json-the-fine-print-part-2-emitting-json-22267.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2024/10/json-the-fine-print-part-2.html>)

Published: 2025-02-04T00:00:00Z

Content type: tutorial

Language: en

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

Topics: [JSON](<https://devfeed.tech/topics/json.md>), [API](<https://devfeed.tech/topics/api.md>), [Code](<https://devfeed.tech/topics/code.md>), [Structured-data](<https://devfeed.tech/topics/structured-data.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [api-layers](<https://devfeed.tech/tags/api-layers.md>), [code](<https://devfeed.tech/tags/code.md>), [common-serialization-errors](<https://devfeed.tech/tags/common-serialization-errors.md>), [data](<https://devfeed.tech/tags/data.md>), [data-serialization](<https://devfeed.tech/tags/data-serialization.md>), [data-structure-separation](<https://devfeed.tech/tags/data-structure-separation.md>), [data-transmission](<https://devfeed.tech/tags/data-transmission.md>), [data-validation](<https://devfeed.tech/tags/data-validation.md>), [encoding](<https://devfeed.tech/tags/encoding.md>), [encoding-json](<https://devfeed.tech/tags/encoding-json.md>), [function](<https://devfeed.tech/tags/function.md>), [go-json-types](<https://devfeed.tech/tags/go-json-types.md>), [go-language-serialization](<https://devfeed.tech/tags/go-language-serialization.md>), [go-language-validation](<https://devfeed.tech/tags/go-language-validation.md>), [go-type-mapping](<https://devfeed.tech/tags/go-type-mapping.md>), [http](<https://devfeed.tech/tags/http.md>), [io](<https://devfeed.tech/tags/io.md>), [io-writer](<https://devfeed.tech/tags/io-writer.md>), [json](<https://devfeed.tech/tags/json.md>), [json-best-practices](<https://devfeed.tech/tags/json-best-practices.md>), [json-go-mapping](<https://devfeed.tech/tags/json-go-mapping.md>), [json-marshaling](<https://devfeed.tech/tags/json-marshaling.md>), [json-unmarshaling](<https://devfeed.tech/tags/json-unmarshaling.md>), [json-validation](<https://devfeed.tech/tags/json-validation.md>), [map](<https://devfeed.tech/tags/map.md>), [passing-serialized-data](<https://devfeed.tech/tags/passing-serialized-data.md>), [properties](<https://devfeed.tech/tags/properties.md>), [rest-apis](<https://devfeed.tech/tags/rest-apis.md>), [schema](<https://devfeed.tech/tags/schema.md>), [schema-less-data-format](<https://devfeed.tech/tags/schema-less-data-format.md>), [serialization](<https://devfeed.tech/tags/serialization.md>), [serialization-mistakes](<https://devfeed.tech/tags/serialization-mistakes.md>), [serialization-protocols](<https://devfeed.tech/tags/serialization-protocols.md>), [standard](<https://devfeed.tech/tags/standard.md>), [structure](<https://devfeed.tech/tags/structure.md>), [writing](<https://devfeed.tech/tags/writing.md>)

### AI overview

This tutorial explains how to emit JSON in Go using the encoding/json package. It compares json.Marshal, which returns bytes, with json.Encoder, which writes to an io.Writer, and discusses error handling in HTTP handlers. It also demonstrates marshaling maps and structs and using field tags to control JSON property names.

### Source excerpt

Introduction In part 1 we took a high-level view on serialization and JSON. In this part, we'll roll our sleeves and start working with JSON, focused on emitting JSON. You might think this is a basic topic, but there is much more to it than just calling json.Marshal. json.Marshal vs json.Encoder The encoding/json package has two main APIs: Marshal and NewEncoder. The Marshal function returns a []byte while the NewEncoder function will write to an io.Writer. The question is: When should you use one API over the other?

## Optimizing Databases on Kubernetes: Kubernetes Backup and Recovery with CNPG and ZFS Snapshots

DevFeed: [Optimizing Databases on Kubernetes: Kubernetes Backup and Recovery with CNPG and ZFS Snapshots](<https://devfeed.tech/articles/optimizing-databases-on-kubernetes-kubernetes-backup-and-recovery-with-cnpg-and-zfs-snapshots-22280.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2025/01/optimizing-databases-on-kubernetes-ep5-kubernetes-backup-and-recovery-with-cnpg-and-zfs-snapshots.html>)

Published: 2024-12-30T00:00:00Z

Content type: tutorial

Language: en

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

Topics: [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [Kubernetes](<https://devfeed.tech/topics/kubernetes.md>), [Database](<https://devfeed.tech/topics/database.md>), [Automation](<https://devfeed.tech/topics/automation.md>), [Replication](<https://devfeed.tech/topics/replication.md>), [Compression](<https://devfeed.tech/topics/compression.md>), [Cloud](<https://devfeed.tech/topics/cloud.md>)

Tags: [automation](<https://devfeed.tech/tags/automation.md>), [backup](<https://devfeed.tech/tags/backup.md>), [cloud-block-storage-benchmarking](<https://devfeed.tech/tags/cloud-block-storage-benchmarking.md>), [compression](<https://devfeed.tech/tags/compression.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [kubernetes-database-performance](<https://devfeed.tech/tags/kubernetes-database-performance.md>), [kubernetes-database-throughput](<https://devfeed.tech/tags/kubernetes-database-throughput.md>), [kubernetes-local-storage-pros-and-cons](<https://devfeed.tech/tags/kubernetes-local-storage-pros-and-cons.md>), [kubernetes-production-grade-storage](<https://devfeed.tech/tags/kubernetes-production-grade-storage.md>), [kubernetes-storage-benchmarking](<https://devfeed.tech/tags/kubernetes-storage-benchmarking.md>), [kubernetes-storage-efficiency](<https://devfeed.tech/tags/kubernetes-storage-efficiency.md>), [kubernetes-storage-trade-offs](<https://devfeed.tech/tags/kubernetes-storage-trade-offs.md>), [kubernetes-zfs-advantages](<https://devfeed.tech/tags/kubernetes-zfs-advantages.md>), [optimizing-postgresql-on-kubernetes](<https://devfeed.tech/tags/optimizing-postgresql-on-kubernetes.md>), [pgbench-kubernetes-testing](<https://devfeed.tech/tags/pgbench-kubernetes-testing.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [provisioning](<https://devfeed.tech/tags/provisioning.md>), [rancher-local-path-performance](<https://devfeed.tech/tags/rancher-local-path-performance.md>), [recovery](<https://devfeed.tech/tags/recovery.md>), [replication](<https://devfeed.tech/tags/replication.md>), [s3](<https://devfeed.tech/tags/s3.md>), [snapshots](<https://devfeed.tech/tags/snapshots.md>), [zfs-compression-benefits](<https://devfeed.tech/tags/zfs-compression-benefits.md>), [zfs-lz4-compression](<https://devfeed.tech/tags/zfs-lz4-compression.md>), [zfs-vs-cloud-storage](<https://devfeed.tech/tags/zfs-vs-cloud-storage.md>)

### AI overview

This final episode in the Optimizing Databases on Kubernetes series demonstrates PostgreSQL backup and recovery with CNPG and ZFS snapshots. It covers WAL shipping to S3-compatible object stores, automated backups, point-in-time recovery, and rapid database cloning using compressed ZFS snapshots.

### Source excerpt

Introduction: In the final episode of the Optimizing Databases on Kubernetes series, Jérôme Petazzoni dives into advanced backup and recovery techniques for PostgreSQL, showcasing how CNPG (Cloud Native PostgreSQL) and ZFS snapshots ensure durability and fast recovery in production environments. This episode focuses on safeguarding data with comprehensive backup strategies, point-in-time recovery, and rapid database cloning, while leveraging ZFS's efficiency for optimized storage performance. Comprehensive Backup Strategies: Exploring backups with CNPG, including write-ahead logs (WAL) and volume snapshots.

## Optimizing Databases on Kubernetes Ep.4: Kubernetes Storage: Benchmarking ZFS, Cloud Disks, and Local Paths

DevFeed: [Optimizing Databases on Kubernetes Ep.4: Kubernetes Storage: Benchmarking ZFS, Cloud Disks, and Local Paths](<https://devfeed.tech/articles/optimizing-databases-on-kubernetes-ep-4-kubernetes-storage-benchmarking-zfs-cloud-disks-and-local-paths-22276.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2024/12/optimizing-databases-on-kubernetes-ep4-kubernetes-storage-benchmarking-zfs-cloud-disks-and-local-paths.html>)

Published: 2024-12-23T00: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>), [Kubernetes](<https://devfeed.tech/topics/kubernetes.md>), [benchmarking](<https://devfeed.tech/topics/benchmarking.md>), [Compression](<https://devfeed.tech/topics/compression.md>), [rancher](<https://devfeed.tech/topics/rancher.md>), [Cloud](<https://devfeed.tech/topics/cloud.md>), [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>)

Tags: [benchmarking](<https://devfeed.tech/tags/benchmarking.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [cloud-block-storage-benchmarking](<https://devfeed.tech/tags/cloud-block-storage-benchmarking.md>), [comparisons](<https://devfeed.tech/tags/comparisons.md>), [compression](<https://devfeed.tech/tags/compression.md>), [databases](<https://devfeed.tech/tags/databases.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [kubernetes-database-performance](<https://devfeed.tech/tags/kubernetes-database-performance.md>), [kubernetes-database-throughput](<https://devfeed.tech/tags/kubernetes-database-throughput.md>), [kubernetes-local-storage-pros-and-cons](<https://devfeed.tech/tags/kubernetes-local-storage-pros-and-cons.md>), [kubernetes-production-grade-storage](<https://devfeed.tech/tags/kubernetes-production-grade-storage.md>), [kubernetes-storage-benchmarking](<https://devfeed.tech/tags/kubernetes-storage-benchmarking.md>), [kubernetes-storage-efficiency](<https://devfeed.tech/tags/kubernetes-storage-efficiency.md>), [kubernetes-storage-trade-offs](<https://devfeed.tech/tags/kubernetes-storage-trade-offs.md>), [kubernetes-zfs-advantages](<https://devfeed.tech/tags/kubernetes-zfs-advantages.md>), [optimizing-postgresql-on-kubernetes](<https://devfeed.tech/tags/optimizing-postgresql-on-kubernetes.md>), [performance](<https://devfeed.tech/tags/performance.md>), [pgbench-kubernetes-testing](<https://devfeed.tech/tags/pgbench-kubernetes-testing.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [rancher](<https://devfeed.tech/tags/rancher.md>), [rancher-local-path-performance](<https://devfeed.tech/tags/rancher-local-path-performance.md>), [zfs-compression-benefits](<https://devfeed.tech/tags/zfs-compression-benefits.md>), [zfs-lz4-compression](<https://devfeed.tech/tags/zfs-lz4-compression.md>), [zfs-vs-cloud-storage](<https://devfeed.tech/tags/zfs-vs-cloud-storage.md>)

### AI overview

Episode 4 of the Optimizing Databases on Kubernetes series benchmarks cloud block storage, ZFS, and Rancher's Local Path provisioner for database workloads. It compares transaction rates, storage efficiency, durability, and scalability, reporting higher throughput and lower disk usage with ZFS compression in the described tests.

### Source excerpt

Introduction: In Episode 4 of the Optimizing Databases on Kubernetes series, Jérôme Petazzoni benchmarks the performance of various Kubernetes storage classes, including cloud block storage, ZFS, and Rancher's Local Path provisioner. This episode dives into the practical aspects of measuring transactions per second, storage efficiency, and durability, offering insights into selecting the right storage solution for database workloads. Through detailed performance comparisons, Jérôme highlights how features like ZFS compression can optimize resource usage and boost database throughput.

## Optimizing Databases on Kubernetes Ep.3: Exploring Kubernetes Storage with OpenEBS and ZFS

DevFeed: [Optimizing Databases on Kubernetes Ep.3: Exploring Kubernetes Storage with OpenEBS and ZFS](<https://devfeed.tech/articles/optimizing-databases-on-kubernetes-ep-3-exploring-kubernetes-storage-with-openebs-and-zfs-22275.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2024/12/optimizing-databases-on-kubernetes-ep3-exploring-kubernetes-storage-with-openebs-and-zfs.html>)

Published: 2024-12-18T00: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>), [Kubernetes](<https://devfeed.tech/topics/kubernetes.md>), [Filesystems](<https://devfeed.tech/topics/filesystems.md>), [Compression](<https://devfeed.tech/topics/compression.md>), [benchmarking](<https://devfeed.tech/topics/benchmarking.md>), [configuration](<https://devfeed.tech/topics/configuration.md>)

Tags: [automated-zfs-setup-kubernetes](<https://devfeed.tech/tags/automated-zfs-setup-kubernetes.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [benchmarking](<https://devfeed.tech/tags/benchmarking.md>), [comparing-zfs-and-block-storage](<https://devfeed.tech/tags/comparing-zfs-and-block-storage.md>), [compression](<https://devfeed.tech/tags/compression.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [databases](<https://devfeed.tech/tags/databases.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [kubernetes-advanced-storage-solutions](<https://devfeed.tech/tags/kubernetes-advanced-storage-solutions.md>), [kubernetes-local-provisioners-efficiency](<https://devfeed.tech/tags/kubernetes-local-provisioners-efficiency.md>), [kubernetes-storage-optimization-zfs](<https://devfeed.tech/tags/kubernetes-storage-optimization-zfs.md>), [kubernetes-storage-provisioners-comparison](<https://devfeed.tech/tags/kubernetes-storage-provisioners-comparison.md>), [kubernetes-volume-management-zfs](<https://devfeed.tech/tags/kubernetes-volume-management-zfs.md>), [kubernetes-zfs-performance-tuning](<https://devfeed.tech/tags/kubernetes-zfs-performance-tuning.md>), [openebs-localpv-zfs](<https://devfeed.tech/tags/openebs-localpv-zfs.md>), [proxmox-zfs-database-management](<https://devfeed.tech/tags/proxmox-zfs-database-management.md>), [scalable-storage-kubernetes-zfs](<https://devfeed.tech/tags/scalable-storage-kubernetes-zfs.md>), [storage](<https://devfeed.tech/tags/storage.md>), [storage-classes-benchmarking-zfs](<https://devfeed.tech/tags/storage-classes-benchmarking-zfs.md>), [zfs-compression-and-encryption](<https://devfeed.tech/tags/zfs-compression-and-encryption.md>), [zfs-daemonset-deployment](<https://devfeed.tech/tags/zfs-daemonset-deployment.md>), [zfs-deduplication-k8s](<https://devfeed.tech/tags/zfs-deduplication-k8s.md>), [zfs-file-system-features](<https://devfeed.tech/tags/zfs-file-system-features.md>), [zfs-integration-with-kubernetes](<https://devfeed.tech/tags/zfs-integration-with-kubernetes.md>), [zfs-pools-in-k8s](<https://devfeed.tech/tags/zfs-pools-in-k8s.md>), [zfs-snapshots-and-compression](<https://devfeed.tech/tags/zfs-snapshots-and-compression.md>), [zfs-vs-rancher-local-path-provisioner](<https://devfeed.tech/tags/zfs-vs-rancher-local-path-provisioner.md>)

### AI overview

Episode 3 of the Optimizing Databases on Kubernetes series introduces ZFS and demonstrates how to integrate it with Kubernetes using OpenEBS LocalPV. It covers automated setup, storage class configuration, compression and deduplication, and comparisons with block storage and other local provisioners.

### Source excerpt

Introduction: In Episode 3 of the Optimizing Databases on Kubernetes series, Jérôme Petazzoni introduces ZFS, a versatile file system renowned for its features like compression, deduplication, and snapshots. Leveraging ZFS with Kubernetes, Jérôme demonstrates how to create efficient and flexible storage solutions, complete with automated setup and configuration using tools like OpenEBS LocalPV. This episode showcases the potential of ZFS to optimize storage performance and reliability in containerized environments. Overview of ZFS: Exploring the features of this advanced file system, from snapshots to RAID configurations.

## Optimizing Databases on Kubernetes Ep.2: Automating Database Maintenance with Kubernetes and CNPG

DevFeed: [Optimizing Databases on Kubernetes Ep.2: Automating Database Maintenance with Kubernetes and CNPG](<https://devfeed.tech/articles/optimizing-databases-on-kubernetes-ep-2-automating-database-maintenance-with-kubernetes-and-cnpg-22274.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2024/12/optimizing-databases-on-kubernetes-ep2-automating-database-maintenance-with-Kubernetes-and-cnpg.html>)

Published: 2024-12-12T00: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>), [Kubernetes](<https://devfeed.tech/topics/kubernetes.md>), [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [Automation](<https://devfeed.tech/topics/automation.md>)

Tags: [application-performance-during-failovers](<https://devfeed.tech/tags/application-performance-during-failovers.md>), [automated-failover-with-cnpg](<https://devfeed.tech/tags/automated-failover-with-cnpg.md>), [automation](<https://devfeed.tech/tags/automation.md>), [cloud-native-postgresql-automation](<https://devfeed.tech/tags/cloud-native-postgresql-automation.md>), [cnpg-for-large-scale-deployments](<https://devfeed.tech/tags/cnpg-for-large-scale-deployments.md>), [cnpg-node-maintenance](<https://devfeed.tech/tags/cnpg-node-maintenance.md>), [cnpg-secondary-promotion](<https://devfeed.tech/tags/cnpg-secondary-promotion.md>), [connection-pooling-for-failovers](<https://devfeed.tech/tags/connection-pooling-for-failovers.md>), [connection-resets-during-failover](<https://devfeed.tech/tags/connection-resets-during-failover.md>), [consistency](<https://devfeed.tech/tags/consistency.md>), [database](<https://devfeed.tech/tags/database.md>), [database-reliability-with-kubernetes](<https://devfeed.tech/tags/database-reliability-with-kubernetes.md>), [database-synchronization-kubernetes](<https://devfeed.tech/tags/database-synchronization-kubernetes.md>), [failover](<https://devfeed.tech/tags/failover.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [kubernetes-cordoning-and-pdb](<https://devfeed.tech/tags/kubernetes-cordoning-and-pdb.md>), [kubernetes-database-failover](<https://devfeed.tech/tags/kubernetes-database-failover.md>), [kubernetes-failover-strategies](<https://devfeed.tech/tags/kubernetes-failover-strategies.md>), [kubernetes-primary-database-failover](<https://devfeed.tech/tags/kubernetes-primary-database-failover.md>), [maintaining-data-consistency-k8s](<https://devfeed.tech/tags/maintaining-data-consistency-k8s.md>), [minimizing-downtime-kubernetes](<https://devfeed.tech/tags/minimizing-downtime-kubernetes.md>), [pdb-for-database-maintenance](<https://devfeed.tech/tags/pdb-for-database-maintenance.md>), [performance](<https://devfeed.tech/tags/performance.md>), [pod-disruption-budgets-kubernetes](<https://devfeed.tech/tags/pod-disruption-budgets-kubernetes.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [process](<https://devfeed.tech/tags/process.md>), [scalable-database-management-k8s](<https://devfeed.tech/tags/scalable-database-management-k8s.md>), [seamless-database-maintenance-kubernetes](<https://devfeed.tech/tags/seamless-database-maintenance-kubernetes.md>)

### AI overview

This video explains how Kubernetes and Cloud Native PostgreSQL (CNPG) automate database maintenance during node drains. It covers failover to a secondary node, pod disruption budgets, connection resets, connection pooling, and synchronization to preserve data consistency and limit application disruption.

### Source excerpt

Introduction: In this episode, Jérôme Petazzoni explores how Kubernetes and CNPG (Cloud Native PostgreSQL) work seamlessly to manage database operations during node maintenance. With real-world demonstrations, Jérôme highlights the power of Kubernetes' automation features, such as failover mechanisms and pod disruption budgets, ensuring minimal downtime and maximum reliability for database applications. Automated Failover with CNPG: How Kubernetes handles database switchover during node drains. Pod Disruption Budgets (PDBs): Ensuring critical pods remain unaffected during maintenance.

## Optimizing Databases on Kubernetes Ep.1: Provisioning a Cluster and Configuring PostgreSQL on Kubernetes

DevFeed: [Optimizing Databases on Kubernetes Ep.1: Provisioning a Cluster and Configuring PostgreSQL on Kubernetes](<https://devfeed.tech/articles/optimizing-databases-on-kubernetes-ep-1-provisioning-a-cluster-and-configuring-postgresql-on-kubernetes-22273.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2024/12/optimizing-databases-on-kubernetes-ep1-provisioning-a-cluster-and-configuring-postgresql-on-kubernetes.html>)

Published: 2024-12-09T00:00:00Z

Content type: tutorial

Language: en

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

Topics: [Kubernetes](<https://devfeed.tech/topics/kubernetes.md>), [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [Provisioning](<https://devfeed.tech/topics/provisioning.md>), [CloudNativePG](<https://devfeed.tech/topics/cloudnativepg.md>), [postgresql clusters](<https://devfeed.tech/topics/postgresql-clusters.md>), [Linode](<https://devfeed.tech/topics/linode.md>), [Replication](<https://devfeed.tech/topics/replication.md>), [hosting](<https://devfeed.tech/topics/hosting.md>)

Tags: [backups](<https://devfeed.tech/tags/backups.md>), [build-vs-buy-database-solutions](<https://devfeed.tech/tags/build-vs-buy-database-solutions.md>), [cloudnativepg](<https://devfeed.tech/tags/cloudnativepg.md>), [cloudnativepg-setup](<https://devfeed.tech/tags/cloudnativepg-setup.md>), [clusters](<https://devfeed.tech/tags/clusters.md>), [cnpg-postgresql-operator](<https://devfeed.tech/tags/cnpg-postgresql-operator.md>), [cost-efficient-kubernetes-clusters](<https://devfeed.tech/tags/cost-efficient-kubernetes-clusters.md>), [cost-optimization](<https://devfeed.tech/tags/cost-optimization.md>), [database-infrastructure-on-linode](<https://devfeed.tech/tags/database-infrastructure-on-linode.md>), [database-optimization-on-kubernetes](<https://devfeed.tech/tags/database-optimization-on-kubernetes.md>), [efficient-storage-with-zfspv](<https://devfeed.tech/tags/efficient-storage-with-zfspv.md>), [high-availability-postgresql-kubernetes](<https://devfeed.tech/tags/high-availability-postgresql-kubernetes.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [kubernetes-for-databases](<https://devfeed.tech/tags/kubernetes-for-databases.md>), [kubernetes-for-startups](<https://devfeed.tech/tags/kubernetes-for-startups.md>), [linode](<https://devfeed.tech/tags/linode.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [postgresql-clusters](<https://devfeed.tech/tags/postgresql-clusters.md>), [postgresql-clusters-on-kubernetes](<https://devfeed.tech/tags/postgresql-clusters-on-kubernetes.md>), [postgresql-replication-on-k8s](<https://devfeed.tech/tags/postgresql-replication-on-k8s.md>), [production](<https://devfeed.tech/tags/production.md>), [production-ready-postgresql-on-k8s](<https://devfeed.tech/tags/production-ready-postgresql-on-k8s.md>), [provisioning](<https://devfeed.tech/tags/provisioning.md>), [provisioning-kubernetes-clusters](<https://devfeed.tech/tags/provisioning-kubernetes-clusters.md>), [rancher](<https://devfeed.tech/tags/rancher.md>), [rancher-local-path-persistent-volumes](<https://devfeed.tech/tags/rancher-local-path-persistent-volumes.md>), [reducing-hosting-costs-with-kubernetes](<https://devfeed.tech/tags/reducing-hosting-costs-with-kubernetes.md>), [replication](<https://devfeed.tech/tags/replication.md>), [scalable-databases-on-kubernetes](<https://devfeed.tech/tags/scalable-databases-on-kubernetes.md>), [scalable-postgresql-deployments](<https://devfeed.tech/tags/scalable-postgresql-deployments.md>), [self-hosted-databases-vs-managed-services](<https://devfeed.tech/tags/self-hosted-databases-vs-managed-services.md>), [setting-up-postgresql-on-kubernetes](<https://devfeed.tech/tags/setting-up-postgresql-on-kubernetes.md>)

### AI overview

This introductory video demonstrates how to provision a Kubernetes cluster on Linode and configure production-ready PostgreSQL clusters on Kubernetes using CloudNativePG, including replication and backups. It also discusses storage, cost control, and build-versus-buy trade-offs.

### Source excerpt

Introduction: In this introductory episode, Jérôme Petazzoni walks through the critical steps of provisioning a Kubernetes cluster tailored for running databases like PostgreSQL. Leveraging his extensive experience, Jérôme demonstrates practical tools and techniques to establish a scalable, cost-efficient database infrastructure while laying the groundwork for future optimizations covered in this series. Provisioning Kubernetes Clusters: A step-by-step guide to creating a reliable cluster using Linode. Setting Up PostgreSQL with CNPG: Deploying production-ready PostgreSQL clusters with built-in replication and backups.

## Fearless Concurrency Ep.7: Lock-Free Structures and Channels for Scalable Rust Code

DevFeed: [Fearless Concurrency Ep.7: Lock-Free Structures and Channels for Scalable Rust Code](<https://devfeed.tech/articles/fearless-concurrency-ep-7-lock-free-structures-and-channels-for-scalable-rust-code-22272.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2024/12/fearless-concurrency-ep7-lock-free-structures-and-channels-for-scalable-rust-code.html>)

Published: 2024-12-05T00:00:00Z

Content type: tutorial

Language: en

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

Topics: [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Code](<https://devfeed.tech/topics/code.md>), [systems](<https://devfeed.tech/topics/systems.md>)

Tags: [advanced-rust-concurrency](<https://devfeed.tech/tags/advanced-rust-concurrency.md>), [alternatives](<https://devfeed.tech/tags/alternatives.md>), [backpressure](<https://devfeed.tech/tags/backpressure.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [concurrency-in-rust](<https://devfeed.tech/tags/concurrency-in-rust.md>), [crossbeam-crate-rust](<https://devfeed.tech/tags/crossbeam-crate-rust.md>), [efficient-multithreading-rust](<https://devfeed.tech/tags/efficient-multithreading-rust.md>), [fearless-concurrency-rust](<https://devfeed.tech/tags/fearless-concurrency-rust.md>), [lock-free](<https://devfeed.tech/tags/lock-free.md>), [lock-free-data-structures-rust](<https://devfeed.tech/tags/lock-free-data-structures-rust.md>), [managing-shared-resources-rust](<https://devfeed.tech/tags/managing-shared-resources-rust.md>), [mpsc-channels-rust](<https://devfeed.tech/tags/mpsc-channels-rust.md>), [one-shot-channels-rust](<https://devfeed.tech/tags/one-shot-channels-rust.md>), [optimizing-concurrency-in-rust](<https://devfeed.tech/tags/optimizing-concurrency-in-rust.md>), [performance](<https://devfeed.tech/tags/performance.md>), [robust-multithreaded-rust-apps](<https://devfeed.tech/tags/robust-multithreaded-rust-apps.md>), [rust](<https://devfeed.tech/tags/rust.md>), [rust-atomiccell](<https://devfeed.tech/tags/rust-atomiccell.md>), [rust-bounded-channels](<https://devfeed.tech/tags/rust-bounded-channels.md>), [rust-concurrency](<https://devfeed.tech/tags/rust-concurrency.md>), [rust-dashmap-dashset](<https://devfeed.tech/tags/rust-dashmap-dashset.md>), [rust-high-concurrency-techniques](<https://devfeed.tech/tags/rust-high-concurrency-techniques.md>), [rust-thread-multiplexing](<https://devfeed.tech/tags/rust-thread-multiplexing.md>), [rust-thread-safe-work-queues](<https://devfeed.tech/tags/rust-thread-safe-work-queues.md>), [rust-timeout-options](<https://devfeed.tech/tags/rust-timeout-options.md>), [scalable-rust-applications](<https://devfeed.tech/tags/scalable-rust-applications.md>), [thread](<https://devfeed.tech/tags/thread.md>), [thread-communication-rust](<https://devfeed.tech/tags/thread-communication-rust.md>)

### AI overview

The seventh and final episode of a Rust concurrency series covers lock-free data structures, channels for communication between threads, and techniques for managing shared resources. It discusses tools including DashMap, DashSet, Crossbeam, MPSC and one-shot channels, multiplexing, bounded channels, backpressure, memory usage, and timeouts.

### Source excerpt

Introduction: Welcome to Episode 7 of the Fearless Concurrency in Rust series! In this final episode, we explore advanced concurrency techniques that enable efficient, scalable, and robust multithreaded applications in Rust. The focus is on leveraging tools like lock-free data structures, channels for thread communication, and strategies for safely managing shared resources in complex systems. These approaches ensure developers can push the limits of Rust's concurrency model while maintaining safety and performance.

## Scalable JSON Streaming with HTTP and Go - Ep.5

DevFeed: [Scalable JSON Streaming with HTTP and Go - Ep.5](<https://devfeed.tech/articles/scalable-json-streaming-with-http-and-go-ep-5-22271.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2024/11/scalable-json-streaming-with--http-and-go.html>)

Published: 2024-11-25T00: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>), [Streaming](<https://devfeed.tech/topics/streaming.md>), [JSON](<https://devfeed.tech/topics/json.md>), [HTTP](<https://devfeed.tech/topics/http.md>), [Error Handling](<https://devfeed.tech/topics/error-handling.md>), [datasets](<https://devfeed.tech/topics/datasets.md>)

Tags: [chunked-transfer-json](<https://devfeed.tech/tags/chunked-transfer-json.md>), [code](<https://devfeed.tech/tags/code.md>), [data](<https://devfeed.tech/tags/data.md>), [data-transmission](<https://devfeed.tech/tags/data-transmission.md>), [decoding](<https://devfeed.tech/tags/decoding.md>), [decoding-json-streams](<https://devfeed.tech/tags/decoding-json-streams.md>), [efficient-json-handling](<https://devfeed.tech/tags/efficient-json-handling.md>), [encoding-json](<https://devfeed.tech/tags/encoding-json.md>), [encoding-json-in-go](<https://devfeed.tech/tags/encoding-json-in-go.md>), [error-handling](<https://devfeed.tech/tags/error-handling.md>), [examples](<https://devfeed.tech/tags/examples.md>), [go](<https://devfeed.tech/tags/go.md>), [go-json-encoding](<https://devfeed.tech/tags/go-json-encoding.md>), [go-json-memory-management](<https://devfeed.tech/tags/go-json-memory-management.md>), [handling-large-json-files](<https://devfeed.tech/tags/handling-large-json-files.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [http](<https://devfeed.tech/tags/http.md>), [http-chunked-encoding](<https://devfeed.tech/tags/http-chunked-encoding.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [json](<https://devfeed.tech/tags/json.md>), [json-chunked-transfer](<https://devfeed.tech/tags/json-chunked-transfer.md>), [json-error-logging](<https://devfeed.tech/tags/json-error-logging.md>), [json-for-engineers](<https://devfeed.tech/tags/json-for-engineers.md>), [json-lines-format](<https://devfeed.tech/tags/json-lines-format.md>), [json-lines-ndjson](<https://devfeed.tech/tags/json-lines-ndjson.md>), [json-streaming](<https://devfeed.tech/tags/json-streaming.md>), [json-streaming-in-go](<https://devfeed.tech/tags/json-streaming-in-go.md>), [memory-efficient-data-transmission](<https://devfeed.tech/tags/memory-efficient-data-transmission.md>), [memory-efficient-json](<https://devfeed.tech/tags/memory-efficient-json.md>), [real-time-data-streaming](<https://devfeed.tech/tags/real-time-data-streaming.md>), [real-time-json-streaming](<https://devfeed.tech/tags/real-time-json-streaming.md>), [scalable-json-processing](<https://devfeed.tech/tags/scalable-json-processing.md>), [streaming](<https://devfeed.tech/tags/streaming.md>), [streaming-json-over-http](<https://devfeed.tech/tags/streaming-json-over-http.md>), [streaming-large-json-datasets](<https://devfeed.tech/tags/streaming-large-json-datasets.md>)

### AI overview

The final episode of the JSON for Engineers series explains how to stream large JSON datasets efficiently using JSON Lines, Go's encoding/json package, and HTTP/1.1 chunked transfer encoding. It covers incremental encoding and decoding, memory usage, response flushing, and logging errors after streaming begins.

### Source excerpt

Introduction: Welcome to the final episode of the JSON for Engineers series! In this concluding session, we tackle the challenges of working with large JSON datasets, exploring efficient strategies for streaming data while minimizing memory usage. These techniques enable developers to handle massive payloads without overburdening system resources, ensuring scalable and cost-effective applications. JSON Streaming: Using JSON Lines for memory-efficient data transmission. HTTP Chunked Encoding: Leveraging HTTP/1.1 chunked transfer encoding for streaming large datasets. Practical Error Handling: Logging and managing errors in streaming JSON responses. This episode starts by addressing the inefficiencies of constructing large JSON objects in memory when working with massive datasets, such as database query results. Instead of consuming significant memory to create one monolithic JSON object, the recommended approach involves using JSON Lines (NDJSON), a format where each line represents a separate JSON object. This method reduces memory requirements by transmitting data incrementally. Using Go's encoding/json package, developers can easily encode and stream multiple JSON objects, as it automatically appends newlines between objects. On the receiving end, decoding JSON streams requires careful looping to handle incoming data dynamically while avoiding memory reuse issues, which could lead to errors or stale data.

[Next page](<https://devfeed.tech/sources/william-kennedy.md?cursor=WyIyMDI0LTExLTI1VDAwOjAwOjAwKzAwOjAwIiwgIjFlMWRlYjQxLWE5YjQtNDEzMi05YmY2LWExZGEzZGY1MDNhNSJd>)