Ardan Labs Blog on

npub177majwd0qqxvllkzw858ecufclh8ergqycd4zcdqpcqam2esdfsqhpjhqk@drss.io

RAG in Go: A Vulnerability Research Tool

20 Apr 2026

## Introduction In [the previous post](https://www.ardanlabs.com/blog/2026/03/using-tools-a-meeting-scheduler/), you saw how you can use tools to add information to an LLM query. In this post,

Using Tools: A Meeting Scheduler

16 Mar 2026

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

Range-Over Functions in Go

16 Feb 2026

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

Query Database Using Plain English

11 Feb 2026

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

Kubernetes Memory Limits and Go

27 Jan 2026

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

Everything You Wanted to Ask About Rust – Answered by Herbert Wolverson

7 Jan 2026

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 –

Getting Friendly With CPU Caches

21 Oct 2025

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

Kubernetes CPU Limits and Go

22 Sep 2025

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

Garbage Collection In Go : Part III - GC Pacing

26 Aug 2025

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

Garbage Collection In Go : Part II - GC Traces

14 Jul 2025

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

Garbage Collection In Go : Part I - Semantics

10 Jun 2025

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

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

19 May 2025

### Introduction In [part 1](https://www.ardanlabs.com/blog/2024/10/json-the-fine-print-part-1.html) we took a higher level view on serialization in general and JSON in specific. In [part

Scheduling In Go : Part III - Concurrency

12 May 2025

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

Scheduling In Go : Part II - Go Scheduler

14 Apr 2025

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

Scheduling In Go : Part I - OS Scheduler

4 Mar 2025

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

Context Package Semantics In Go

10 Feb 2025

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

JSON - The Fine Print: Part 2 - Emitting JSON

4 Feb 2025

### Introduction In [part 1](https://www.ardanlabs.com/blog/2024/10/json-the-fine-print-part-1.html) we took a high-level view on serialization and JSON. In this part, we’ll roll our sleeves and

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

30 Dec 2024

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

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

23 Dec 2024

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

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

18 Dec 2024

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

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

12 Dec 2024

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

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

9 Dec 2024

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

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

5 Dec 2024

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

Scalable JSON Streaming with HTTP and Go - Ep.5

25 Nov 2024

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

Fearless Concurrency Ep.6: Understanding Rust ARC for Efficient Multithreading

21 Nov 2024

### Introduction: Welcome to Episode 6 of the Fearless Concurrency in Rust series! In this episode, we explore the powerful concept of ARC (Atomic Reference Counting) and its critical role in

JSON Handling and Type Management with Large Datasets in Go - Ep.4

14 Nov 2024

### Introduction: Welcome to Episode 4 of the JSON for Engineers series! In this episode, we tackle the complexities of working with JSON data, especially when dealing with extensive datasets and

Fearless Concurrency Ep.5: Ensuring Memory Safety with Mutexes and RwLocks in Rust

8 Nov 2024

### Introduction: Welcome to Episode 5 of *Fearless Concurrency in Rust*! In this episode, Herbert Wolverson dives into advanced concurrency tools, focusing on `RwLock` for managing simultaneous

Managing JSON Field Tags and Value Handling in Go - Ep.3

31 Oct 2024

### Introduction: Welcome to Episode 3 of JSON for Engineers! In this episode, Miki Tebeka explores the intricacies of JSON field mapping and value handling, especially when working in strongly

Transitioning from C and C++ to Rust: A Beginner’s Guide

29 Oct 2024

### Introduction: As you embark on the journey from C or C++ to Rust, you’ll discover a world of exciting possibilities. Rust’s emphasis on safety, concurrency, and performance can significantly

Fearless Concurrency Ep.4: Understanding Mutexes and Thread Safety in Rust

25 Oct 2024

### Introduction: Welcome to Episode 4 of Fearless Concurrency in Rust! In this episode, we explore how Rust’s ownership and borrowing rules impact multithreaded programming, focusing on the

JSON - The Fine Print: Part 1

23 Oct 2024

### Introduction Everybody knows [JSON](https://www.json.org/), it’s a simple serialization format and the default format for REST APIs. Like many other topics, there are fine points you should

Exploring JSON Encoding and Data Handling in Go - Ep.2

17 Oct 2024

### Introduction: Welcome to Episode 2 of JSON for Engineers! In this episode, we explore the unique characteristics of JSON as a schema-less format, discussing both its benefits and challenges.

Fearless Concurrency Ep.3: Managing Threaded Programs and Data Races in Rust

10 Oct 2024

### Introduction: Welcome to Episode 3 of the Fearless Concurrency series! In this episode, Herbert explores advanced threading techniques in Rust, focusing on scoped threads and the Rayon library

Data Integrity with JSON Serialization - Ep.1

3 Oct 2024

### Introduction: Welcome to Episode 1 of JSON for Engineers! In this first episode, Miki Tebeka dives into the fundamentals of serialization, with a special focus on JSON, one of the most

Fearless Concurrency Ep.2: Managing Threaded Programs and Data Races in Rust

26 Sep 2024

### Introduction: Welcome to Episode 2 of the *Fearless Concurrency in Rust* series! In this episode, Herbert Wolverson dives into the fundamentals of threading in Rust, demonstrating how to use

Ep. 7: Enhancing AI with Message Chaining and Accuracy Scoring

19 Sep 2024

### Introduction: Welcome to the final episode of our Intro to Generative AI series! In this episode, Daniel Whitenack takes the concepts you’ve been learning and shows you how to apply advanced

Fearless Concurrency Ep.1: Rust's Approach to Safe and Manageable Multithreading

12 Sep 2024

### Introduction: In Episode 1 of the *Fearless Concurrency in Rust* series, Herbert Wolverson introduces the foundational concept of threads in programming, tracing their origins and evolution

Ep. 6: AI Techniques: Real-Time Web Parsing and Contextual Conversations

5 Sep 2024

### Introduction: In Episode 6 of the Intro to Generative A.I. series, Daniel shifts the focus from basic search techniques to more dynamic, on-the-fly AI applications. He demonstrates how to

Ep. 5: Key Techniques for Accurate AI-Driven Information Retrieval

22 Aug 2024

### Introduction: Welcome to Episode 5 of our Intro to Generative AI series! In this episode, Daniel explores practical techniques for enhancing AI models’ ability to handle large volumes of text

Ep. 4: Streamlining Prompt Engineering and Context Handling in Generative AI

8 Aug 2024

### Introduction: Welcome to Episode 4 of our Intro to Generative AI series! In this episode, Daniel dives into the essential technique of prompt engineering, focusing on creating dynamic and

Categorizing Data with Large Language Models in Rust

6 Aug 2024

### Introduction [LibreQoS](https://libreqos.io/) is an open source project for monitoring and providing quality-of-experience for Internet Service Providers (ISPs) and large networks. It runs as a

Ep. 12: Implementing Robust Transaction Handling in Go

5 Aug 2024

### Introduction: Welcome to Episode 12 of our Ultimate Software Design series! In this final installment, Bill guides us through the advanced implementation of transaction management in Go,

Ep. 11: Enhancing Go Code with Effective Application Layer Tests

30 Jul 2024

### Introduction: Welcome to Episode 11 of our Ultimate Software Design series! In this episode, Bill delves into the intricacies of implementing robust application layer tests within Go projects,

Ep. 3: Proper Prompt Formatting for Enhanced AI Model Performance

25 Jul 2024

### Introduction: Welcome to Episode 3 of our Intro to Generative AI series! In this episode, Daniel explores the critical aspect of prompt formatting when working with AI models, emphasizing how

Ep. 10: Building Secure Go Systems: Key Management, Middleware, and Error Handling

23 Jul 2024

### Introduction: Welcome to Episode 10 of our Ultimate Software Design series! In this episode, Bill dives into the integration of authentication and authorization mechanisms within Go packages,

Ep. 9: Go Package Design: Authorization and API Structures

17 Jul 2024

### Introduction: Welcome to Episode 9 of our Ultimate Software Design series! In this episode, Bill delves into the intricacies of implementing robust authorization and API structure within Go

Ep. 2: Mastering LLM Integration with Go and Prediction Guard

6 Jul 2024

### Introduction: Welcome to Episode 2 of our Intro to Generative AI series! In this segment, Daniel dives into the practical aspects of working with large language models (LLMs) using the Go

Ep. 8: Enhancing Go Application Security with JWT and OPA

2 Jul 2024

### Introduction: In this segment, Bill delves into the fundamental aspects of authentication and authorization, equipping Go developers with essential knowledge and advanced tools to enhance the

Ep. 7: Building Resilient Go Applications: Key Error Handling Techniques

20 Jun 2024

### Introduction: Going into more detail on error handling, Bill provides a comprehensive overview of effective strategies and best practices for Go developers. By exploring the nuances of error

Ep. 1: Enhancing Your Go Projects with Generative AI: Exploring LLMs