Effective Rust, David Drysdale, O’Reilly, April 2024

This book is for experienced developers who are already fluent in a compiled programming language with static typing (such as C++, Java, or C#) and are considering migrating some of their projects to Rust. It will be harder to approach for those with experience primarily in dynamic languages. Chances are, the potential audience has skimmed through some entry-level books on Rust but found them too focused on the basics to hold their interest. The bite-sized, depth-focused items in Effective Rust are designed precisely for them.

I remember reading Scott Meyers’ original Effective C++ many years ago. That book educated myriads of C++ developers on how to use the language correctly. Rust is harder to use incorrectly, but there are still many concepts and nuances that need to be grasped to use it effectively. A glance at the chapter list reveals these areas: types, traits, concepts (covering Rust’s unique features, including lifetimes, borrow-checking, unsafe calls, and panicking), dependencies, and tooling.

One of the things I like most about this book is how it puts Rust into the broader context of modern programming languages. The author not only explains how to accomplish certain tasks in Rust (e.g., error handling—an area where Rust really stands out) but also compares Rust’s approach to those found in other languages. Throughout the book, they touch on common software development topics—functional programming, testing, semantic versioning, dependency management, continuous integration, and more—showing how Rust fits into the bigger picture. There’s even a mention of the B programming language. That’s the context, right?

This book doesn’t just teach readers to be proficient in Rust—it teaches them to be better software developers overall. Much of its advice applies beyond Rust. Item 30: Write more than unit tests is a recommendation anyone could benefit from, and its section on fuzz testing is a gem.

Effect Oriented Programming: A New Paradigm for Creating Reliable, Adaptable, Testable Systems – Using Scala and ZIO, Bill Frasure, Bruce Eckel, and James Ward, September 2024

Sometimes, titles are more exaggerated than the actual content. But this book has the right title—I truly believe we’re witnessing a new paradigm here. By the way, did you know that the Greek word παράδειγμα (parádeigma) means “example” in modern Greek? Well, this book gives us a real example of how modern applications should look and what we should focus on while developing them.

The authors build on concepts well-established within the functional programming community but give them a fresh perspective, making them more accessible to a broader software development audience. They even introduce their own terminology, choosing to avoid the mathematical jargon so beloved by some ivory-tower inhabitants.

Would I recommend this book to those not particularly interested in Scala and ZIO? Absolutely. Chances are, a library supporting this programming style already exists in your favorite language – or is being developed as we speak. This book helps readers understand what effects are all about and how to write code that fully leverages them.

How do we handle system initialization? How do we test? How do we prepare for (inevitable) failures? How do we manage shared state reliably? And how do we ensure we build resilient systems? These are tough questions, but the book provides solid answers based on effect systems.

It’s a short book, and at times, it may feel like it only contains toy examples. But remember – we always start small to build something huge.

Writing for Developers, Piotr Sarna and Cynthia Dunlop, Manning Publications, November 2024

I write for developers as part of my day job, so I was pretty excited when I first heard about this book. Even though I’m not the primary target audience (the book is aimed at software developers who consider writing about what they do at work), I still found it really interesting and valuable. I fully agree with the authors that the entire IT community benefits when we explain what we do—whether in conference talks or blog posts.

This book motivates developers to write, helps them find the right topics, offers advice on captivating readers, and distills the entire blog post delivery process: writing, editing (they call it optimizing – a perfect word here!), gathering feedback, and publishing. And yes, getting keywords and tags right really does matter!

Writing for Developers follows the popular approach of describing patterns and anti-patterns of blog posts. (For another example of this approach, see Presentation Patterns: Techniques for Crafting Better Presentations by Matthew J. McCullough, Nathaniel T. Schutta, and Neal Ford.) An entire Part 3 is dedicated to such patterns as Bug Hunt, Rewrote it in X, and How We Built It, each accompanied by conceptual descriptions, key elements, discussions, and examples.

I especially liked Part 4, which covers blog post promotion and building on top of it – because, let’s be honest, stopping at just one post can be tricky!

And, of course, no book these days avoids the topic of AI. It turns out AI can actually be a valuable tool for writing – if used the right way. The authors explain how, and no, they’re not just talking about generating entire texts from simple prompts!

Potpourri

Here are several books I’ve read lately, thoroughly enjoyed, and can happily recommend to others:

• Power and Progress by Daron Acemoglu and Simon Johnson – before AI overtakes the world, we must be prepared by the examples from human history!

• Timeline Taxi by Brent Roose – time-travel fiction, a small but really captivating novel.

• Hands-On Large Language Models by Jay Alammar and Maarten Grootendorst – an excellent read for those who want to try it themselves.