index

Hello and welcome to the first episode of My Week in Readings. This format is born from a necessity: I tend to consume a discrete amount of knowledge materials during my week and I want to remember and also have a reference of the most interesting of them.

Multiprocessor Programming & Rust Atomics

I’m a huge fan of book clubs and have tried several times to start one at the companies I’ve worked for over the last few years. Unfortunately, I haven’t had much success. Meanwhile, I discovered that a guy from New York with interests that align with mine started a “global” book club.

This time the book club is focused on multiprocessor programming. This week marks a turning point in the book. We’ve spent six weeks in the more theoretical realm of multiprocessor programming. It wasn’t simple, but here we are. This week we read Chapter 7 of The Art of Multiprocessor Programming about Spin Locks and Contention and it was absolutely fascinating. It explains the various techniques we can use to implement locking mechanisms. Between the two possible approaches - spinning and blocking - this chapter focuses primarily on spinning. Although the examples are in Java, I had fewer problems following along. Definitely worth the effort.

Alongside The Art of Multiprocessor Programming, I’ve started re-reading Rust Atomics & Locks - Mara Bos’s excellent book about how Rust handle concurrency. I read Chapter 1, which is essentially an introduction to Rust’s approach to concurrency. From what I understand, it follows a similar path to how C++ handles these concepts, but I need to explore this theory more deeply. It covers much of the same ground that’s already introduced in The Rust Book.

Effect

It’s enough to say that over the past year, I’ve spent considerable time exploring the Effect framework/library for TypeScript, and I’ve found it to be one of the most challenging and rewarding experiences of my programming life.

The challenge stems mainly from how TypeScript’s type system works and the fact that when your domain becomes truly complex, you end up with cryptic type error messages. But I’ve found ways to work around this problem.

What I find most fascinating about the Effect type is its ability to provide comprehensive information about the functions you’re calling, effectively solving one of the most annoying problems in the JavaScript world: the function coloring problem.

The blog post about Flix effects provided an excellent introduction to understanding effect systems in functional programming languages. While it focuses on Flix rather than TypeScript’s Effect library, it offers a solid theoretical foundation for understanding how effect systems work in general.

I need to explore the Effect type more deeply and understand its limitations, as well as how it differs from the “standard” approaches used in languages like Haskell. But that’s a topic for another time.

NixOS Adventures

Three weeks ago I decided to install NixOS on my ThinkPad X270 and give it a try. I have never before used Nix in any way but I heard a lot of great things about it from David. So I decided to give it a try in the most extreme way: installing a distro completely based on it.

Well, it is turning out to be more complex that I expected but also more interesting that I have expected. The fact that it is a really “cutting-edge” technology that has a large and frangmented ecosystem that sometimes is really poorly documented made the things really complex to do.

But hey, having the ability to use one language to describe all about your operating system configuration and also about the development enviroment is really really cool.

I am returning with a regular frequency to NixOS & Flakes Book as my main introductory resource. But in particular I have spent the week trying to figure out how to build a development enviroment for Haskell and the talk that Malte Ott gave at this year Zurihac helped me a lot.

I am also watching this serious about a guy who rebuild its configuration from scratch, which is helping me in understanding one thing or two about advanced NixOS configurations.

The NixOS journey continues to be both frustrating and rewarding. I’m slowly building intuition for the Nix language and starting to see the power of declarative system configuration, even if the learning curve is steep.

Bloom Filters Deep Dive

This week I discovered an amazing series by Aleksey Maltsev on Bloom filters. This is exactly the kind of deep, technical content I love.

The series starts with the classic Bloom filter, explaining how this simple data structure (just a bit array and hash functions) can solve massive memory problems. What blew my mind is that a Bloom filter with 1% error rate requires only about 9.6 bits per element, regardless of the element size. That’s incredible space efficiency!

The second part covers Counting Bloom Filters, which solve the deletion problem by replacing bits with small counters. The trade-off is increased memory usage but you gain the ability to remove elements.

The third part introduces Cuckoo Filters, which are fascinating because they achieve the same memory footprint as classic Bloom filters while providing deletion support and fewer false positives. They use a clever hash-table layout with fingerprints instead of a flat bit array.

What I particularly appreciate about this series is how it explains not just the “what” but the “why” diving into the mathematical foundations while keeping the explanations accessible. The visualizations and examples make complex probabilistic data structures understandable.

Filesystem Innovation: TernFS

One of the most interesting discoveries this week was learning about TernFS, an exabyte-scale distributed filesystem that XTX Markets (a major algorithmic trading firm) just open-sourced.

This is fascinating for several reasons:

• Scale: XTX handles $250 billion in daily trades and needed storage that could handle 500+ petabytes across multiple data centers
• Performance: The system serves multiple terabytes per second at peak, which is mind-boggling
• Reliability: They claim to have never lost a single byte of data since deployment
• Open Source: Unlike other big tech companies, XTX actually open-sourced their solution

TernFS is designed specifically for large, immutable files (the kind used in machine learning workloads) and uses a combination of hard disks for sequential reads and flash storage for random access. It’s multi-region by design and has no single points of failure.

The timing is interesting too - with AI/ML workloads exploding, having a battle-tested filesystem designed for this exact use case could be incredibly valuable for the broader community.

Ruby Community Controversy

This week also brought some concerning developments in the Ruby community. Tekin Süleyman’s blog post highlighted serious issues with DHH’s (David Heinemeier Hansson, creator of Rails) recent public statements and their impact on the community.

The controversy centers around DHH’s blog posts that many in the community view as racist and exclusionary, particularly his comments about London being “only a third native Brit” and his praise of far-right figures. As Tekin points out, this is especially painful for non-white members of the Ruby community who have worked hard to make it more inclusive.

The situation has escalated beyond just blog posts - there are now governance issues at Ruby Central, with maintainers losing access to critical projects like RubyGems. This has created a complex web of technical and social problems that the community is struggling to address.

What’s particularly troubling is how this affects the next generation of Rubyists. When newcomers research Ruby and Rails, they don’t just find technical documentation - they also find this controversy and might reasonably conclude this isn’t a welcoming community.

It’s a reminder that technical leadership comes with social responsibility, and that the health of programming communities depends on more than just code quality.

Rust + Git = <3?

Finally, I came across this interesting thread from the Git mailing list about the introduction of Rust into the core of Git. While I haven’t had time to dive deep into the technical details, it’s always fascinating to see how changes in foundational tools ripple through the entire development ecosystem.

---

What interesting technical content did you discover this week? I’d love to hear about it via email.