Welcome on David Álvarez Rosa | Personal Website

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.

Page Not Found

Sat, 13 Dec 2025 22:23:00 +0000

That page couldn’t be found (404 error). Try the Home page.

Subscription

Sat, 13 Dec 2025 22:06:00 +0000

Welcome! Your subscription is confirmed. Thanks for signing up.

You can unsubscribe anytime by emailing david@alvarezrosa.com from the same email address you subscribed with.

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.¹