This is definitely a theory book and feels rather academic at times exploring the history of distributed systems. I thought the title could have been more reflective of the work. Something like “distributed systems challenges and solutions” which sounds dull but I feel it’s more reflective of the content. The word “designing” in the title felt a little misleading for what my expectations were for that word and the content of the book. I found parts 1 and 3 to be the most insightful. In part 2, chapters 5, 7 and 9 I thought went off into the weeds a little too much. After reading thru it, I felt as if much of the concerns raised were solved by ZooKeeper. The chapters on partitioning data and the “trouble with distributed systems” were good though. In part 3 he brings it all together with a log based/ledger architecture and materialized views off of it which solves most of the problems raised in earlier chapters. This makes sense with the authors Samza, Kafka, linkedin background. This kind‘ve made some of the previous chapters feel more like a history of distributed system problems that have been mostly solved with his proposed architecture (ie what LinkedIn is using). Overall the author is brilliant and I’ve followed his blog posts for a couple years (turning the database inside out etc.) so I appreciate his time and energy that went into the book. It wasn’t quite what I was looking for but it’s a good overview of distributed systems and considerations around those systems.

Designing Data-Intensive Applications really exceeded my expectations. Even if you are experienced in this area this book will re-enforce things you know (or sort of know) and bring to light new ways of thinking about solving distributed systems and data problems. It will give you a solid understanding of how to choose the right tech for different use cases. The book really pulls you in with an intro that is more high level, but mentions problems and solutions that really anyone who has worked on these types of applications have either encountered or heard mention of. The promise it makes is to take these issues such as scalability, maintainability and durability and explain how to decide on the right solutions to these issues for the problems you are solving. It does an amazing job of that throughout the book. This book covers a lot, but at the same time it knows exactly when to go deep on a subject. Right when it seems like it may be going too deep on things like how different types of databases are implemented (SSTables, B-trees, etc.) or on comparing different consensus algorithms, it is quick to point out how and why those things are important to practical real-world problems and how understanding those things is actually vital to the success of a system. Along those same lines it is excellent at circling back to concepts introduced at prior points in the book. For example the book goes into how log based storage is used for some databases as their core way of storing data and for durability in other cases. Later in the book when getting into different message/eventing systems such as Kafka and ActiveMQ things swing back to how these systems utilize log based storage in similar ways. Even if you have prior knowledge or even have worked with these technologies, how and why they work and the pros and cons of each become crystal clear and really solidified. Same can be said of it's great explanations of things like ZooKeeper and why specific solutions like Kafka make use of it. This book is also amazing at shedding light on the fact that so little of what is out there is totally new, it attempts to go back as far as it can at times on where a certain technology's ideas originated (back to the 1800s at some points!). Bringing in this history really gives a lot of context around the original problems that were being solved, which in turn helps understanding pros and cons. One example is the way it goes through the history of batch processing systems and HDFS. The author starts with MapReduce and relating it to tech that was developed decades before. This really clarifies how we got from batch processing systems on proprietary hardware to things like MapReduce on commodity hardware thanks in part to HDFS, eventually to stream based processing. It also does great at explaining the pros and cons of each and when one might choose one technology over the other. That's really the theme of this book, teaching the reader how to compare and contrast different technologies for solving distributed systems and data problems. It teaches you to read between the lines on how certain technologies work so that you can identify the pros and cons early and without needing them to be spelled out by the authors of those technologies. When thinking about databases it teaches you to really consider the durability/scalability model and how things are no where near black and white between "consistent" vs "eventually consistent", these is a ton of nuance there and it goes deep on things like single vs multi leader vs leaderless, linearizability, total order broadcast, and different consensus algorithms. I could go on forever about this book. To name a few other things it touches on to get a good idea of the breadth here: networking (and networking faults), OLAP, OLTP, 2 phase locking, graph databases, 2 phase commit, data encoding, general fault tolerance, compatibility, message passing, everything I mentioned above, and the list goes on and on and on. I recommend anyone who does any kind of work with these systems takes the time to read this book. All 600ish pages are worth reading, and it's presented in an excellent, engaging way with real world practical examples for everything.

Very detailed but also handles everything from a high level perspective which makes it easy for a developer to implement. This really should be standard reading for software developers.

Pretty good book, I found a lot of the good/more relevant parts can sometimes get lost in tangents but definitely some great content. I'm a fairly experienced backend/data/systems engineer, and I highly recommend reading Designing Data Intensive Applications as a way to get up to speed. I read it and learned a ton even after having a lot of hands on experience with the subject matter.

I bought this book about 4 years ago and have only started reading it. I wish I had started earlier. This book is very comprehensive and informative. The author makes complex concepts look simple. He’s definitely one of the best engineers and teacher.