Welcome on David Álvarez Rosa | Personal Website

Self-Hosting on the Dark Web

Mon, 01 Jun 2026 10:55:00 +0100

This site is now reachable over Tor as a hidden service, at a .onion address that resolves only inside the Tor network.¹ Tor relays and encrypts your traffic as it passes through thousands of volunteer-run servers, so that no single party can link who you are to what you are doing; a hidden service extends that anonymity to the server itself.

It’s built by the nonprofit Tor Project, which advances human rights and freedoms through free software and open networks, so that anyone can use the internet free from tracking, surveillance, and censorship. The network only works because people use it, so consider supporting them or running a relay—your contribution helps millions stay safe and private online every day.

First Steps on a New Server

Sun, 17 May 2026 17:26:00 +0100

Over the last decade I’ve been playing with dozens of servers from multiple providers. These are the steps I’ve been perfecting to get up to speed fast and feel right at home on a new machine. Wrote it down here mostly as a personal reference, but hopefully useful to someone else too.

Hardware, distro, and DNS §

Clean Linux install with one large root partition plus big swap.¹ While I run Arch on my laptop, Debian tends to be a better fit for servers because of its stability and long support window.

Fundamental Theorem of Calculus

Wed, 22 Apr 2026 20:14:00 +0100

Although the notion of area is intuitive, its mathematical treatment requires a rigorous definition. This post introduces the Riemann integral, and proves the fundamental theorem of calculus—a beautiful result that connects integrals and derivatives.

Riemann integral §

Given a bounded¹ function \(f\colon[a,b]\to\mathbb{R}\), we can approximate the area under its graph by rectangles. Choose a partition of its domain

\[ \mathcal{P}=\{x_0,x_1,\ldots,x_n\mid a=x_0<x_1<\cdots<x_n=b\}. \]

For each subinterval \([x_{k-1},x_k]\), define the width \(\Delta x_k=x_k-x_{k-1}\), and let \(m_k\) and \(M_k\) denote the infimum and supremum of \(f\) on that subinterval. The lower and upper sums are

Optimizing a Lock-Free Ring Buffer

Tue, 24 Mar 2026 11:51:00 +0000

A single-producer single-consumer (SPSC) queue is a great example of how far constraints can take a design. In this post, you will learn how to implement a ring buffer from scratch: start with the simplest design, make it thread-safe, and then gradually remove overhead while preserving FIFO behavior and predictable latency. This pattern is widely used to share data between threads in the lowest-latency environments.

What is a ring buffer? §

¹You might have run into the term circular buffer, or perhaps cyclic queue. These are simply other names for a ring buffer: a queue where a producer generates data and inserts it into the buffer, and a consumer later pulls it back out, in first-in-first-out order.

Deriving Type Erasure

Tue, 10 Mar 2026 09:46:00 +0000

Ever looked at std::any and wondered what’s going on behind the scenes? Beneath the intimidating interface is a classic technique called type erasure: concrete types hidden behind a small, uniform wrapper.

Starting from familiar tools like virtual functions and templates, we’ll build a minimal std::any. By the end, you’ll have a clear understanding of how type erasure works under the hood.

Polymorphism with interfaces §

The typical way to achieve polymorphism is to define an interface consisting of pure-virtual methods you want to be able to call. Then, for each implementation that you want to use polymorphically, you create a subclass that inherits from the base class and implement those methods.

Devirtualization and Static Polymorphism

Wed, 25 Feb 2026 09:45:00 +0000

Ever wondered why your “clean” polymorphic design underperforms in benchmarks? Virtual dispatch enables polymorphism, but it comes with hidden overhead: pointer indirection, larger object layouts, and fewer inlining opportunities.

Compilers do their best to devirtualize these calls, but it isn’t always possible. On latency-sensitive paths, it’s beneficial to manually replace dynamic dispatch with static polymorphism, so calls are resolved at compile time and the abstraction has effectively zero runtime cost.

David Álvarez Rosa

Sat, 24 Jan 2026 12:31:00 +0000

¹Mathematician and engineer based in sunny Dublin, passionate about low-latency, high-performance systems.

Currently working in algorithmic trading at Susquehanna. Previously designed and built systems at Amazon serving 10M+ monthly active customers, developed semantic caching for LLMs at Sopra Steria, and conducted quantitative cybersecurity risk analysis at Deloitte.

About this Site

Fri, 11 May 2018 21:18:00 +0100

After nearly a decade, I’ve rebuilt my personal site from scratch—a blog on software, self-hosting, and lessons learned along the way. This first post is backdated to when I originally launched a site on this domain, back in 2018.

What?—A personal blog. Posts aim to be concise, practical, and rigorous.

Why?—To give back to the libre software community. To keep a record of my learning journey. To deepen my own understanding by writing things down.¹