Posts on Umit Unal

PetraCache: Building a Memcached-Compatible Cache with RocksDB

Tue, 03 Feb 2026 10:00:00 +0300

The Problem

Memcached is fast. Really fast. But when it restarts, your cache is gone. Cold cache means every request hits your database until the cache warms up again. At scale, this can take down your entire system.

I wanted to explore a different approach: what if we could add persistence to memcached without changing the protocol?

Why memcached Protocol?

mcrouter is Meta’s memcached router—5 billion requests per second in production. Consistent hashing, failover, replication, connection pooling. All battle-tested at massive scale.

Consistent Hashing Algorithms: Jump Hash vs Ring Hash vs Rendezvous Hash

Wed, 17 Sep 2025 14:30:00 +0300

Whether you’re building a database, cache, load balancer, or content delivery network, you face the same fundamental challenge: distributing workload across multiple machines. Poor distribution leads to unreliable and slow systems. Optimal distribution enables scalability. The question is: how?

Your e-commerce platform started with one database but now handles 100 million users across 50 database shards. Every user profile, order history, and product review must be stored in exactly the right shard for fast queries. When user “john_doe_12345” places an order, which of your 50 shards should store it? Route it wrong and you’ll query all shards (slow). Route it right and you get instant lookups. You add new shards monthly during planned maintenance, and replace failed ones immediately with identical replicas.

Distributed System Implementations: Building Key-Value Stores

Fri, 25 Apr 2025 14:09:07 +0300

Many modern applications need to be fast, scalable, and always available. To achieve this, they often use distributed systems. These systems run on many computers and work together to store and process data.

One important type of distributed system is the key-value store. It saves data as key-value pairs. This model is simple but very powerful. Many popular tools—like databases, caches, and service discovery systems—use this structure.

However, building a key-value store that works across multiple machines is not easy. We need to think about problems like:

Using RoaringBitmap in Distributed Data Systems

Sun, 22 Dec 2024 14:09:07 +0300

In modern high-traffic or data-intensive applications, distributed data systems are crucial for handling large volumes of information. But when we deal with huge sets of integer IDs—such as user IDs, IP addresses, or event indices—we need a data structure that is not only memory-efficient but also supports fast set operations. This is where RoaringBitmap comes in.

RoaringBitmap stores large sets of integer values in a compressed format and offers rapid operations like intersection, union, and difference. This blog will explore how RoaringBitmap can make distributed data systems more efficient and easier to manage.

eBPF Powers Next-Generation Observability: Maximum Insight, Minimal Impact

Sun, 01 Dec 2024 14:09:07 +0300

In the era of modern software systems, observability has become a critical aspect of system management. It enables engineers to monitor, debug, and optimize their applications effectively. However, traditional observability tools often come with high resource costs, limited visibility, and performance overhead. This is where eBPF (extended Berkeley Packet Filter) steps in to revolutionize observability solutions.

eBPF is a cutting-edge technology that empowers developers to collect detailed insights about system behavior directly from the Linux kernel, all while keeping resource usage to a minimum. It offers a flexible, efficient, and secure way to understand what’s happening inside your systems, without significantly affecting performance.

Advanced Concepts in LSM Trees: Scaling Write-Optimized Storage

Fri, 01 Nov 2024 14:09:07 +0300

Handling massive volumes of data writes in distributed environments requires data structures built to minimize I/O, balance loads, and retain data integrity. Log-Structured Merge Trees (LSM Trees) accomplish this by intelligently managing writes, compactions, and reads across hierarchical storage levels. This guide will dissect the internal mechanics of LSM Trees, from write batching and SSTable lifecycle management to advanced techniques in compaction and read amplification reduction, all essential for high-performance distributed storage solutions.

Implementing CountDownLatch Functionality in Go Inspired by Java

Fri, 09 Apr 2021 12:42:59 +0300

When working with concurrent applications, synchronization primitives are essential tools. While Go provides sync.WaitGroup, sometimes we need more sophisticated control like timeouts. Java’s CountDownLatch offers this functionality, so let’s implement it in Go.

The Implementation

Our CountDownLatch combines Go’s sync.WaitGroup with atomic operations for thread-safe counting:

type CountDownLatch struct {
 sync.WaitGroup
 counter uint64
}

The struct embeds sync.WaitGroup and adds a counter field using uint64 to store two 32-bit counters in one atomic value.