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.

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?

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.

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.

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.

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.

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.

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.

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.

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.