December 13, 2024Ardan Labs
From the Ardan Community
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.
Continue reading December 09, 2024Ardan Labs
From the Ardan Community
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.
Continue reading December 06, 2024Ardan Labs
From the Ardan Community
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.
Continue reading November 26, 2024Ardan Labs
From the Ardan Community
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.
Continue reading November 22, 2024Ardan Labs
From the Ardan Community
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 managing shared resources in multithreaded Rust programs. By leveraging ARC, developers can safely share ownership of data across threads without relying on a traditional garbage collector, enabling efficient, flexible, and scalable concurrency.
What is ARC?: Understanding Atomic Reference Counting as a lightweight, manual garbage collection system.
Continue reading November 15, 2024Ardan Labs
From the Ardan Community
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 optimizing type management. Here, Miki introduces key strategies for managing large JSON documents, avoiding unnecessary type definitions, and using Go’s encoding/json package to handle custom serialization needs effectively.
Type Pollution Avoidance: Minimizing type declarations by using selective decoding and anonymous structures.
Continue reading November 8, 2024Ardan Labs
From the Ardan Community
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 reads and writes and the powerful concept of interior mutability. These tools provide developers with greater control over data sharing in multithreaded environments, enabling them to optimize for both performance and code simplicity in Rust.
Read-Write Locks (RwLock): Manage concurrent read and write access efficiently.
Continue reading November 1, 2024Ardan Labs
From the Ardan Community
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 typed languages like Go. This session covers the practical challenges of matching JSON fields to Go struct fields, distinguishing between missing and zero values, and using default values to ensure robust JSON parsing. These strategies are crucial for engineers managing flexible JSON data structures in a language with strict type requirements.
Continue reading October 30, 2024Ardan Labs
From the Ardan Community
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 enhance your programming toolkit. This beginner’s guide on transitioning from C and C++ to Rust will provide a structured approach to making that transition, addressing essential concepts and practical applications. Let’s dive in!
Step 1: Understanding Rust’s Ownership Model Concept Overview: Rust’s ownership model is its most distinctive feature.
Continue reading October 25, 2024Ardan Labs
From the Ardan Community
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 complexities of managing memory in a concurrent environment. We’ll break down how Rust’s strict borrowing and ownership model ensures safety and prevents common pitfalls like data races and undefined behavior, making it an ideal choice for building reliable multithreaded applications.
Thread Safety and Ownership: Managing variables across threads using Rust’s ownership rules.
Continue reading