Hey there, frontend friends! Is “read more” one of your new year’s resolutions and 2024 is the year you’re actually going to stick to it? Well, you’re in luck! Here’s a list of 10 fantastic books to kick off your reading journey in the new year.
You’ll notice that most of these books are not frontend-related at all, which might seem like a mistake, but I promise you it’s not (I checked!)
I strongly believe that the key to leveling up your skills as a frontend engineer is to develop your technical breadth, and the best way I know how to do that is by reading books that sit right in your “stretch zone”—like these ones.
The list has books on software design, system design, architecture, performance, and more; so I’m sure you’ll find something that piques your interest.
Let’s jump right in!
I know a book with “philosophy” in its name might have caused you to tune out immediately, but in case you’re still reading, I promise this one is worth checking out. A Philosophy of Software Design by John Ousterhout is a short book (~180 pages), and it’s a relatively light read, free of most of the technical jargon you’ll find in other books of its kind.
This book is my favorite introduction to software design and software complexity. It has both practical and theoretical content, with code examples in Java to illustrate implementation details (although the concepts it covers can be applied in any language.)
“Wait a minute. Did you just say Java? I thought this was a list for frontend developers!”
Similarly to the famous 2006 paper Out of the Tar Pit, A Philosophy of Software Design is based on the thesis that complexity is the root of all evil. But the book takes things a bit further, saying that managing complexity is the most important part of our jobs as software designers and engineers.
Whether you agree with that statement or not, I’m sure you’ll find the strategies covered in the book useful. A few of my favorites are:
Finding the right abstraction for the problem you’re trying to solve often comes down to choosing the right design pattern. But with so many patterns to choose from, and implementations that vary widely depending on the programming language, this is easier said than done.
In about 260 pages, you’ll explore:
If you’re looking for a comprehensive introduction to the world of software architecture, look no further than this amazing book by Mark Richards and Neal Ford.
Like most software architecture books, it doesn’t include a lot of frontend-specific content. In fact, there’s very little mention of the frontend at all. But don’t let that discourage you from picking up a copy of this book. This is one of my most recommended reads for software engineers of all kinds.
The book has three parts. Parts 1 and 3 cover the foundational concepts, techniques, and soft skills necessary to become a successful software architect. You’ll learn about architectural thinking, measuring architectural characteristics (e.g., scalability, maintainability, performance), and making architectural decisions.
These two parts of the book talk about architecture at a very general level, without focusing on any particular part of the stack. And because of how general and comprehensive the book’s definition of architecture is, it’s a great way to define what frontend architecture is as well.
Part 2 is the longest in the book, and it covers in detail a number of different architectural styles, such as layered, event-driven, and microservices. Depending on your level of exposure to backend systems, you might find this part a bit more challenging to consume. But if you can handle the discomfort of not completely understanding all of the concepts discussed in this section, reading through it is a fantastic way to increase your technical depth.
Back in my early years as a software developer, one of the books more experienced engineers would recommend to me the most was The Pragmatic Programmer by Dave Thomas and Andrew Hunt.
As a young and easily distracted UI developer I had waaay more important things to do (not really), but I ended up grabbing a copy of the book anyway. And… I didn’t like it very much.
So when the 20th-anniversary edition of the book came out in 2019, I wasn’t particularly excited about it. It took another round of recommendations from people I look up to for me to give the book a second chance. And let me tell you, I’m so glad I did.
It was clear to me now that my problem wasn’t that I didn’t like the book the first time, but that I didn’t fully understand it. So while I wouldn’t recommend it to someone who’s just starting out, I think it’s a fantastic resource for anyone who’s been building software for at least a couple of years.
The Pragmatic Programmer covers some of the most important tools in the software developer’s toolkit. For instance, tracer bullet development, which I wrote about in the past is one of the many subjects it covers. In no particular order, here are some of the topics you’ll find in it:
Duplication, Estimating, Version Control, Prototyping, Debugging, Decoupling, Concurrency, Refactoring, Naming, Reversibility, Domain Languages, and something called Orthogonality which apparently is a very important thing.
We’re not just playing developer-jargon bingo here. Understanding these concepts can play a big role in your career as a software engineer, and this book does a great job of explaining them.
The Pragmatic Programmer is one of my go-to reference books, and it has become one of my most recommended reads for anyone looking to level up their coding skills.
In its seven chapters, you’ll learn about:
Before finding Grokking Simplicty by Eric Normand, all of my previous attempts at learning about functional programming (FP) failed miserably.
Things usually started well, but as soon as the academic jargon and the code examples in Haskell showed up, my brain would immediately shut down.
Thankfully, this book is different.
Unlike many other functional programming books, Grokking Simplicity puts the mathematical concepts of FP to the side to focus entirely on managing software complexity. In particular, it explains how we can build better software by adopting two of the main ideas in functional thinking:
sendEmail function or a
deleteUser method. Calculations are pure functions (e.g., a
sum(a, b) function) that will always behave the same no matter how many times you call them. Data is the inert component: things like objects, strings, or numbers. Identifying these and not mixing them up is one of the main traits of a functional programmer.
If you’re looking for a gentle introduction to FP, or want to learn new techniques for managing complexity in your applications, I highly recommend you check this one out.
You might be surprised to see a system design book in a list for frontend engineers, but I assure you this is not a mistake. In fact, Web Scalability for Startup Engineers by Artur Ejsmont is one of my favorite books to recommend to software engineers of all kinds, but especially frontend engineers.
I like to think of this book as the missing manual of web development. It’s a 300-page roadmap that will take you on a full-stack journey, from the initial user request to the database layer and back. If you’re a frontend developer looking to expand your backend and data engineering knowledge, this is the book for you.
The first half of the book covers concepts you might already be familiar with, such as building a frontend and API layer, an overview of web scalability, and principles of web development. You might be tempted to skip the introductory chapters but I’d highly recommend that you don’t—they’re well worth the time investment.
The second half takes us all the way to the backend, covering the data layer, caching, messaging queues, and searching. These are areas we don’t typically have a ton of exposure to as frontend developers, so I’m sure you’ll get a ton of value out of them.
Along the way, you’ll find that every concept in the book is marvelously explained with diagrams and practical examples. There is also very little code in the book, so it’s a truly language-agnostic resource. It doesn’t go too deep on any particular subject, but it’s a great starting point for choosing areas to focus on next.
Luca Mezzalira has been writing and speaking about micro frontends for as long as the term has been around. You can learn a lot about this architectural style from the articles and conference talks he’s given over the years, but if you’re looking for a comprehensive guide, look no further than his 2021 book Building Micro-Frontends.
One of the core concepts in the book is the Micro-Frontends Decision Framework, which you can use to figure out which flavor of micro frontend architecture is right for your application. This includes deciding how to split your micro frontends (vertically or horizontally), how to compose and route them (on the server, client, or at the edge), and which methods they’ll use to talk to each other.
You’ll also find case studies, tips for introducing micro frontends to your organization, and strategies for making the migration from a monolithic architecture. It really covers a lot of ground, so I’m sure you’ll find it useful whether you’re using micro frontends today, or just want to learn more about their pros and cons.
The Rules of Programming by Chris Zimmerman was a really pleasant surprise. I picked it up earlier this year without knowing anything about it, and it quickly became one of my favorite technical reads of the year.
Zimmerman is a co-founder of the Sucker Punch gaming studio, so if you’ve played games like Infamous or Ghost of Tsushima, you’ve played with code written using these very rules. These are the rules his team uses to write simpler, more maintainable code; which I’d say is an important thing to do when building the massive pieces of software modern video games are.
Here are a few of my favorite rules:
And if you need an extra incentive to pick up a copy of The Rules of Programming, you should know that all of Zimmerman’s royalties from the book go directly to [Girls Who Code](Girls Who Code), an organization helping young women thrive and lead in the tech workforce.
Tidy First? by Kent Beck is the newest book in the list (it came out about a month ago), and it’s all about software design and the importance of making things easier to change.
The question in the book’s title comes from a situation we’ve all experienced before. We want to make a change, but the codebase is messy; should we tidy things up first? You can probably guess what the answer is: it depends, but the book does a great job of explaining what it depends on exactly.
Tidy First? is a very short read (less than 100 pages), and it’s packed with useful advice, organized into three parts:
While the first two parts of the book are more practical, I found part 3 to be the more interesting one (and it’s where I took most of my notes.) This is personal preference, of course, but if you’re passionate about software design and like to dive into the origins of concepts such as coupling and cohesion, I can highly recommend Tidy First? as your next read.
Regardless of where you are in your frontend journey, I hope you’ve found your next great read in this list. Do you have any favorite books to recommend? I’d love to hear about them! Reach out on Twitter and let me know.
If you’re looking for more book recommendations, you should check out the Frontend at Scale newsletter. Every two weeks, I publish an original essay along with recommended books, talks, and other resources on software design and architecture tailored specifically to frontend engineers.
You can read the latest newsletter issue here, and subscribe to get the next one in your inbox using the box below 👇 (keep scrolling down!)
Well, there's only one way to find out!
Join 1,000+ developers getting the latest insights from the world of software design and architecture—tailored specifically to frontend engineers. Delivered right to your inbox every two weeks.