This short post explores the std::vector<bool> specialization of std::vector in the C++ standard library. Specifically, we look at how the standard library writers achieve a space-optimized implementation without sacrificing (most) of the semantics we expect from standard containers, and why this optimization sometimes leads to unexpected behavior.

This post is the first in a series on adding functionality to the CPython interpreter. In it, we implement the almost-equal operator described in CPython Internals. In this first post, we update the CPython tokenizer, parser, and abstract-syntax tree to support our new feature.

This post describes several options for deploying containerized applicatons on AWS and the tradeoffs in terms of usability, scalability, and pricing.

This post links a presentation I made back in 2019 titled “Cryptography for Cybersecurity Professionals.” I lost track of the presentation in the intervening years, but recently stumbled on it again while auditing my password manager for old, unused accounts.

I recently watched the presentation How to Write a Great Research Paper by Simon Peyton Jones. In this post, I summarize some of my primary takeaways from this presentation and augment this with some examples from my own research experience.

This post presents benchmark results for two popular reader-writer lock implementations, and offers some (tentative) explanations for the patterns we observe.

In this post we’ll explore an approach to using C++20 coroutines to hide memory stall latency when performing bulk lookup operations on a data structure that exceeds the size of last-level cache.

C++20 coroutines enable many interesting asynchronous programming constructs of their own accord, including co_awaitable synchronization primitives, generator functions, and asynchronous algorithms, to name just a few. However, the power of coroutines really shines when we integrate them with an external event source such as IO completions or timer expirations.

This blog post explores the semantics of coroutine composition by examining a simplified implementation of the task type.

C++20 introduces a number of exciting new features: constraints and concepts, modules, ranges, new primitives in the thread support library, etc. While all of these features are interesting and deserving of study, it is the language support for coroutines that I find the most compelling.