Recommended Reads

Rust

• Await | Writing an OS in Rust by Philipp Oppermann delivers an insightful and masterfully explained view of Rust’s default multitasking model. It is a lengthy article that deserves careful reading. In return, it’ll teach you what exactly async, await, poll, pin… are and how they are implemented.

• The ultimate guide to Rust newtypes by Angus Morrison describes how giving semantic meaning to types by wrapping them in newtypes favors correctness and maintainability. newtypes require some additional thought during development, but in my opinion it’s worth it in most backend scenarios.

• Master hexagonal architecture in Rust by Angus Morrison explains how following hexagonal architecture principles favors scalability, safety, and maintainability; at the cost of development time and some performance impact from type conversions. I’d argue these two main pain points are worth it. On the one hand, development time will see some short-term detriment, but it will be kept stable in the long run. Hexagonal architecture will keep refactors to a minimum, which is a huge time saver in my experience. On the other hand, type conversion penalties can be kept to a minimum that will not be noticed in the vast majority of backend applications.

Go

• Scheduling in Go by William Kennedy; this three-part article is the best literature about Go’s concurrency model: Ms, Ps, and Gs. It is a must for writing concurrent Go code.

• CPU Cache-Friendly Data Structures in Go: 10x Speed with Same Algorithm by Serge Skoredin gives a concise explanation and specific tips on how to improve the performance of Go applications by making data structures cache-friendly.

Java

• A categorized list of all Java and JVM features since JDK 8 to 21 by Dávid Csákvári. It may seem out of place in this list, but my experience working with Java at IBM/StreamSets has shown me how drastically different it is to work with Java 21 compared to Java 8. I am glad Java is positively evolving again after years of stagnation.

Backend

• Transactionally Staged Job Drains in Postgres by Brandur Leach proposes a method for managing background jobs submitted from a request path using transactional staging in the database. It avoids early execution and rollback-related job inconsistencies by relying on standard database isolation guarantees, and is relatively simple to implement. I’ve seen engineers independently arrive at similar patterns, and they work well in practice.

General

• Reflections on trusting trust by Ken Thompson is a revealing paper about how every piece of software we build and run places trust in the integrity of lower layers: the compiler, linker, OS, hardware…

  The moral is obvious. You can’t trust code that you did not totally create yourself.

  That is practically never the case.

• Software freedom isn’t about licenses – it’s about power by Alyssa Rosenzweig argues that licensing is not enough to protect software and user freedom. The article seems even more relevant now than it was when it was written in 2021. The original post seems to be missing, so I’ve linked the copy on linuxreviews.org.

• How to Ruin a Perfectly Good Container by Ben Laurie. I disagree with much of what is said here, but it is a thought-provoking rant-like article that does make some valid points. My article about using object capabilities as the only external access method in WebAssembly argues against some points; e.g., we don’t need to re-implement POSIX; there are other approaches.

• What is CapTP, and what does it enable? by Christine Lemmer-Webber elaborates on the Capability Transport Protocol, why it is cool, and what can be done with it.