Foundations of Scalable Systems

by Ian Gorton

In many systems, scalability becomes the primary driver as the user base grows. Attractive features and high utility breed success, which brings more requests to handle and more data to manage. But organizations reach a tipping point when design decisions that made sense under light loads suddenly become technical debt. This practical book covers design approaches and technologies that make it possible to scale an application quickly and cost-effectively.

Author Ian Gorton takes software architects and developers through the foundational principles of distributed systems. You'll explore the essential ingredients of scalable solutions, including replication, state management, load balancing, and caching. Specific chapters focus on the implications of scalability for databases, microservices, and event-based streaming systems.

You will focus on:



Foundations of scalable systems: Learn basic design principles of scalability, its costs, and architectural tradeoffs

Designing scalable services: Dive into service design, caching, asynchronous messaging, serverless processing, and microservices

Designing scalable data systems: Learn data system fundamentals, NoSQL databases, and eventual consistency versus strong consistency

Designing scalable streaming systems: Explore stream processing systems and scalable event-driven processing

Genres: Technology, Programming, Technical, Software, Computer Science, Architecture, Nonfiction

337 pages, Paperback

Published August 1, 2022

Reviews

[Vlad Bezden · Rating 5 out of 5]

The book starts with the monolith application and ends with streaming services and event-driven applications. The author did a great job of explaining how to scale systems. My favorite part is "Distributed Database Implementations"—a great explanation of CAP theory, how to achieve strong consistency, availability, and network partitioning.
I recommend this book to everybody who is new or mid-level in scalable and distributed systems or looking to architect applications in modern times.

[Tomi Turtiainen · Rating 5 out of 5]

Excellent primer on how scalable systems work. Doesn’t go really deep, but I liked the good amount of pointers on where to find more details. The most interesting part of the book was the explanation of how databases are scaled and what kind of problems that poses.

[Iain Davis · Rating 4 out of 5]

TL;DR
A valuable survey of the scalability space from networks to individual systems to complex distributed architectures. It won't prepare you to build anything, but it will give you a decent grounding in the topic to build upon.

I picked up this book from a recent Humble Bundle. In my unfortunate state of unemployment, it seemed wise to invest in my career, and scalability is definitely an area I have room to grow in. Everything I know is basically what I've been able to pick up by osmosis from working on existing scalable systems, which amounted to a little bit about circuit breakers, even less about caching, beyond re-applying existing patterns, and some little knowledge about Infrastructure-as-code picked up from self-study and having to occasionally manipulate a CloudFormation template for one of our services. And I had a vague understanding of messaging platforms, and event-driven architectures are, but if pressed to describe them, or enumerate differences, I'd have struggled.

This book offers a very broad survey of the scalability landscape. It's organized into four parts:

Part the first
This portion of the book earns the name, as it covers, in three chapters, a spectrum of foundational topics.
• what we mean when we talk about scalability, why it's necessary, and its connection with cost and other quality attributes
• A 3,000 foot view of a simplified process of evolution from the simplest web application architectures to fully decomposed microservices architectures
• A high-level overview of the underlying network technology and concepts
• Single-system concurrency, e.g. threads and implications of threaded systems

Part the second
The second and third parts of the book cover a good portion of the ground that I expected to find in this book. That is, scalability in multi-node distributed systems. Parts 2 and 3 essentially revisit the scalability evolution of a hypothetical system in greater depth. Part 2 focuses on the application layer.
• Application servers and horizontal scaling
• Caching in your application, and using the underlying Internet infrastructure
• Message queues and pub/sub topics (RabbitMQ is used as an example)
• serverless computing - after a brief introdutction this chapter essentially boils down to a comparison between GAE and AWS Lambda
• What microservices are, and how to cope with some inherent challenges

Part the third
Continues the deeper discussion of the scalability evolution discussed in Chapter 2, this time focusing on the data layer
• Why the relational model became open to challenge, and the fundamentally different data modeling approach of NoSQL
• The challenges of eventual consistency
• The challenges of strong consistency
• A comparison of three leading NoSQL implementations: Redis, MongoDB, and DynamoDB

Part the final
A quick survey, in two chapters, of the world of event-driven architectures and real-time stream processing
• A discussion of messaging queues and pub/sub topics, using RabbitMQ and Apache Kafka as examples
• A discussion of the evolution from batch processing to stream-processing systems, along with the unique challenges of working with streams. Apache Flink is used as an example
• A sort of vestigial-tail of a chapter that probably deserved its own section. It mostly points to not-scalability-but-closely-related topics that are not covered in the book (like observability, and automation, for example)

That's a lot of ground to cover in about 300 pages. At no point in this book, or after reading it, are you going to be prepared to dive into designing a complex scalable distributed system. But what you will have, at least if you're at a similar place in your career to me, is a better understanding of the landscape. I feel so much more prepared to engage with topics around scalability now, particularly around the data layer and messaging/streaming, since these are areas I just haven't encountered much in my career. I've run across them, perhaps to the point where I had to fix a bug in a handler, but never to the point where i had to make fundamental decisions... to choose a platform, or tweak the configuration to achieve a desired outcome. I feel much more confident going into a discussion, and also confident that I can use any of the tools discussed in this book with at least a notion of what I am trying to accomplish with it. I wish I had had this book to read earlier in my career. I would recommend this book to any engineer who feels themselves to be at that sort-of "mid" phase in their career. Earlier, if they're ambitious. It will prepare them for future discussions and lay the track for later learning.

It wasn't an easy book to read, but I actually went through and read each chapter twice (once taking paper notes, and then a second time to force myself to recall it, and to capture the key points and any references to other materials in my notes app) because I felt like I was getting value out of it each time. I don't know what more practical praise I can give a book than that.

If I have complaints, they're few. The author seems to be aiming for platform agnosticism, but has a clear preference for the Java ecosystem. That's fine, but I can't help feeling it might be easier to get hands-on with some of these tools in a language with less overhead and set-up necessary. This isn't really a hands-on book. Second, that last chapter is sort of a sign-post to "here are some other topics you might want to study", but had that been expanded into a chapter on each of those topics, I think it'd make this book an even more valuable early-career resource. The topics mentioned in the last chapter are some of the things that were most baffling to me as I transitioned from college to the working world and discovered I had to do a whole lot more than just writing code... automation, observability, deployment, and long-term data storage.

All in all, a strong recommend for early-to-mid career folks who want to know something about this space. It's also a wealth of references out to other books and articles for further reading.

[Edmund · Rating 4 out of 5]

Foundations of Scalable systems gives a good overview of some of the fundamental building blocks of modern distributed systems. It is however very much an entry level book into the topic and those with significant experience in large scale distributed systems will get a lot less value from the book. This being said I could see this being a valuable book for those newer to the field thus the four star rating.

[Jevgenij]

Extremely basic

[Asim Ghaffar · Rating 4 out of 5]

A good starting point for beginners or those with some experience in scalable systems.

It is a good text by Ian Gorton for anyone exploring the principles & fundamentals of building scalable systems, though it doesn’t quite achieve the awesomeness of Designing Data-Intensive Applications.

Gorton starts with fundamental concepts, from packet switching and threading to the CAP theorem, establishing a robust groundwork before moving into technologies around asynchronous messaging, NoSQL databases, and serverless architecture.

Gorton does a solid job introducing major technologies for building scalable systems, discussing settings and parameters that impact both scalability and resilience. However, the book could benefit from more concrete use cases—for instance, when comparing MongoDB vs DynamoDB or Flink vs Storm. The concluding chapter offers a high-level view on topics like instrumentation and containerization, rounding off the content with a broad finish.

A valuable aspect of this book is its generous recommendations for further reading, from articles to books, making it an excellent resource for beginners. I rated it 4/5 on Goodreads and would recommend it to anyone new to scalable systems or with intermediate experience. It is easy to follow, despite having an academic touch*, making it totally great for learning on your own.

* The book is part of the curriculum for CS6650 Building Scalable Distributed Systems, taught by Gorton himself (videos available on YouTube).

Note: I got the book from Humble Bundle. They routinely offer deals, many of which include titles from O'Reilly. You might get lucky at https://www.humblebundle.com/books

[Marcin Kuthan · Rating 5 out of 5]

You can say that this is a book about the basics, but these basics concern the construction of distributed systems, which isn’t an easy subject.
For less experienced engineers, this book reduces the area of unknown unknowns, turning them into known unknowns. A lot of references allow them to deepen their knowledge as needed.
Experienced engineers can treat this book as a refresher and identify areas where they need to supplement their knowledge.

[Sven Kirsimäe · Rating 5 out of 5]

This book offers a solid return to the fundamentals of building scalable systems. Depending on your experience, it can be a helpful refresher of familiar concepts or a practical reference to support you through your needs.

[Mathias Valdbjørn Rønnelund · Rating 4 out of 5]

Great amount of tools described. And each topic are introduced at a perfect pace.

Only thing would have been more coding examples

[Bastek_pt · Rating 5 out of 5]

Very well-structured book with everything you need to start your journey with scalability. It helped me solidify what I already knew and shed some light on things I was not fully aware of.