My Recommended Books for Software Engineers

The books I’m about to list are best suited for folks with at least 2 to 3 years of work experience, or for anyone who feels ready to level up and gain a deeper mastery of software engineering. Since these are geared toward foundational engineering principles, you won’t find books here that teach a specific framework or language. Just a heads-up: some of these can be quite a heavy read.

Dependency Injection: Principles, Practices, and Patterns by Mark Seemann and Steven van Deursen

Even though it starts out with Dependency Injection (DI), this book goes way beyond that. It really expands your thinking on how a software application’s dependency graph should look, diving into cross-cutting concerns, Aspect-Oriented Programming (AOP), Domain-Driven Design (DDD), common DI patterns, and anti-patterns. While the examples are written using C# and .NET, the foundational concepts are highly generic. Personally, I just skipped the framework-specific explanations and focused on extracting the core architectural concepts I needed.

Domain-Driven Design by Eric Evans

This is a classic that has been around for a while, but most of its core philosophies are still incredibly relevant today. Depending on the language you use, applying these concepts can actually become even more concise now. The main goal of this book is to train your mindset so you can quickly spot domain objects and communication patterns out of complex business logic and requirements. Because it delves into a lot of theory and the specific challenges of its era, I found it a bit heavy to read. However, it’s incredibly rewarding—it vastly improves how you analyze and approach system design rounds and real-world production setups.

Implementing Domain-Driven Design by Vaughn Vernon

Once you finish Evans’ book, you should jump straight into this one while the concepts are still fresh in your mind. This book does a great job of clarifying the things that might have felt abstract or confusing in the original DDD book. It brings the concepts into view and makes them highly actionable. Reading these two back-to-back lets you compare both perspectives, making it much easier to connect the dots.

Test Driven Development: By Example by Kent Beck

TDD is definitely a polarizing topic—some devs love it, some hate it. Personally, I lean more toward Behaviour-Driven Development (BDD). Regardless of where you stand, this book is worth reading because it gives you a deep understanding of software testing philosophies, concepts, and approaches that go far beyond just writing unit tests.

Extreme Programming Explained by Kent Beck

TDD actually originated from the Extreme Programming (XP) movement. In fact, a lot of what we call Agile and CI/CD today evolved out of XP practices. After reading about TDD, it’s highly worth getting a taste of what XP is all about. Even if you don’t see immediate practical benefits, you’ll find yourself having “aha!” moments later in your career where the concepts from this book suddenly click.

Working Effectively with Legacy Code by Michael C. Feathers

If you are looking to scale up your current engineering knowledge, this is an absolute must-read. As developers, we spend most of our daily lives wrestling with change requests and inheriting other people’s codebases. This book teaches you the exact strategies needed to modify code, safely introduce new features, and leverage unit tests effectively. It really changes how you visualize what “good code” actually means and how to build software that is easily adaptable to change.

Now that we’ve covered the high-level system design books, let’s pivot to the low-level stuff.

Operating Systems: Three Easy Pieces (Remzi Arpaci-Dusseau, Andrea Arpaci-Dusseau)

This feels less like a heavy academic textbook and more like a collection of light, engaging blog posts about operating systems. Instead of overwhelming you with micro-details, it focuses sharply on three core pillars: Virtualization (Memory), Concurrency, and Persistence (File Systems). For someone like me who didn’t come from a formal CS background covering OS or computer architecture, this is by far the easiest and most approachable resource out there. Plus, it’s completely free.

The Art of UNIX Programming by Eric S. Raymond

If you didn’t cover Computer Architecture or Operating Systems back in school, this can be an incredibly dense and difficult read—it certainly was for me. However, getting even a high-level mental model of how UNIX operates under the hood gives you a massive edge. It drastically improves your ability to debug complex issues, write automation scripts, or handle deep R&D tasks. It’s best to dive into this one right after reading OS: Three Easy Pieces.

The Structure and Interpretation of Computer Programs by Abelson, Sussman, Sussman

This book takes a deep, low-level dive into how programming languages actually function, covering everything from compilers to interpreters.

Next up is an incredible book series. I’m currently making my way through Volume 1, but the entire lineup is fantastic:

Write Great Code: Understanding The Machine 2nd Edition by Randall Hyde

• Write Great Code, Volume 2: Thinking Low-Level, Writing High-Level – Randall Hyde

• Write Great Code, Volume 3: Engineering Software – Randall Hyde

• Write Great Code, Volume 4: Reading and Writing Files – Randall Hyde

Finally, here are a couple of recommendations specifically for Apple developers—especially those moving toward platform or infrastructure engineering. Fair warning: these are highly technical and dense.

OS Internals Trilogy by Jonathan Levin

The Art of Mac Malware by P.Wardle

To wrap things up: everyone always talks about Clean Code and Clean Architecture. Honestly, I’m not a massive Uncle Bob fanboy. If you are going to read his books, I highly recommend pairing them with John Ousterhout’s A Philosophy of Software Design. It provides a fantastic counter-perspective and keeps your architectural mindset balanced.

Until next time!