Advanced Web Application Architecture

by Matthias Noback

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

384 pages, ebook

Published July 7, 2020

Reviews

[Andrey Astakhov · Rating 5 out of 5]

"Advanced Web Application Architecture" by Matthias Noback is not a typical book about software architecture. This book doesn't say "Do this!" or "Don't do that". Instead, it tells you a story about refactoring a legacy code to make it a stable and testable application.

About a "story"

Every chapter starts with a piece of code and suggests a slight improvement of it. Then all these improvements appear to be design patterns or architectural concepts. This way we learn how Value Objects reduce the cognitive burden and increase communication, how Repositories allow testing without accessing the database, how Command Objects shape input data of an application.

The story in the book looks like an evolution of a student's code to a performant clean code of an experienced developer. Not surprisingly, the culmination of this evolution is the best explanation of Hexagonal architecture (Ports and Adapters) that I've ever seen before. The principles of the Ports and Adapters approach are not given here like a pure theory but as a result of multiple step-by-step enhancements that turned pieces of a naive junior's code into a sustainable and testable implementation.

Although I already knew and used many of the concepts, this book helped me to fill some awful knowledge gaps and structured my understanding of the described paradigms.

About the style of the book

What I like about Noback's books that he doesn't play a know-it-all guy by giving concrete commands, but shows you a direction as a more senior developer. He gives you advice and informs you that it might or might not work for you by explaining the reasons, pros and cons of each approach.

The style of the book reminds me of a conversation of two developers during a pairing coding session, e.g. :

This should work, and might be a correct integration test, but I doubt if it’s a
very useful test.

And as final words in a debate:

I think this could be ... But that’s something for another day.

It feels like you speak with a colleague who is not afraid of admitting his own gaps by saying "I have only experience with ..." and explains where you can find additional information.

Advanced Web Application Architecture is the longest ebook I've read so far. Sometimes, it was quite difficult to navigate from a current page to a place where some of the concepts were introduced before. However, Noback helps you by providing summaries in every chapter and gives many references to articles and books with detailed explanations. My "To Read" list has been significantly increased.

Summary

So far, Advanced Web Application Architecture is my favourite book about a decoupled architecture. It explains all its advantages and implementation costs.

Abstractions have a cost, but as we discussed before: they have many benefits. Both for the long-term maintainability of your application as for today’s testability of the code.

I fully agree with Noback that developers often under-engineer their web applications and underestimate the challenges of increasing complexity over time, so I second the author and confirm that it’s time to start doing a better job using the principles of the decoupled architecture and the Ports and Adapters approach.

[Jesús Valera Reales · Rating 5 out of 5]

Libro muy bueno sobre DDD, de los mejores que he leído sin ninguna duda.

[Djamel Benali · Rating 5 out of 5]

Must read if you want to write code that's framework-agnostic

[Chesco · Rating 4 out of 5]

There are a lot of interesting and advanced architectural topics in this book.

Most of the book is spent explaining the reader the difference between "core" and "infrastructure" code and how to do the refactoring itself. I found that part a bit dry and extensive, but with lots of code examples.

The final parts of the book refer to hexagonal architecture, and I liked that a bit more, where it connected the author's proposal (core vs. infrastructure) with the hexagonal (ports and adapters) architecture.

At some points I found the book difficult to apply to real life projects, and I would affirm that it's better suited for enterprises with 100+ developers working on long lived projects, that may change frameworks, than on smaller and regular projects. That is partially the reason I gave it 4 stars instead of 5, as I would have liked the book to be less around avoiding frameworks, and more about giving good architecture while working with them.

Nevertheless, reading between lines, the advice is applicable. I actually learned quite a lot of software architecture, not being a software architect myself, but a senior developer.

Definitely recommended for all developers in order to be more architecture savvy in your projects.

[Alessandro Ronchi · Rating 5 out of 5]

An inspiring book, the book I would have loved to write.
If you are into DDD (and PHP but not mandatory), this is a must-read.

[Jose Reales · Rating 5 out of 5]

https://chemaclass.es/readings/advanc...

[Kris · Rating 4 out of 5]

I like quite a lot about this book. Especially the idea about thinking of core and infrastructure code.
If you’re confused at some point because you don’t know as much about DDD as the author it’s ok to move forward, chances are you will see the same thing from different perspectives later and at some point you will get the idea.

There are also parts where I was disappointed. For example validation is greatly simplified while it’s surrounded by so much complex code that I loos more like it’s done this way to fit into the model rather than for the practicality of the final product.

I like the idea of inversion of control and unit testing myself, but the amount of mock code encountered here seems like a lot of extra work.

The developer workflow suggested won’t work for me as well. I’ve tried it multiple times, but its either doesn’t work or takes all the fun from working for me.

Let’s try ending with a positive. It’s the best argument for extracting an application service I’ve seen. With small steps we’ve taking a messy code and organizing it so it’s testable and well organized.

[Jon Højlund Arnfred · Rating 4 out of 5]

A decent book on web application code best practices. I found that the general distinction between infrastructure and core code is fruitful. However, I think in terms of productivity and ease of reading and writing, it might not be a feasible way forward for applications to extract core code to the extend the author promotes in this book. That a large portion of a given application is unit-testable is not necessarily that important, it all depends on which kind of application you write. Imagine an application where most of the logic are done in pure SQL and not in the application layer, then your testing strategy should revolve around verifying assumptions about SQL statements and data stored in the database. In such an application, one could even argue philosophically that the infrastructure code itself is core code, given that SQL is just another programming language which happens to be a little closer to the data, than let's say PHP.

[Milad Mirzaee · Rating 4 out of 5]

This book provides insightful, practical, real-world knowledge about detailed web application design. It explores different ideas and alternative options without jumping straight into theory. Instead, it starts by explaining the reasoning behind decisions and the problems we’re trying to solve.
It covers various aspects like code structure, how design choices affect testing, and gives good explanations of terms and different perspectives around each topic.
What I found missing was a stronger encouragement toward pragmatism, especially when discussing read models or handling more complex situations.

[Greg · Rating 4 out of 5]

Actually had quite high hopes for this book.
It's not bad but I found Object Design Style Guide to be more useful.

[Krystian · Rating 5 out of 5]

Brilliant guide on mid+ sized application architecture. I wish everyone I work with would read it and take it to heart :)

[Luís Soares · Rating 5 out of 5]

One of the best tech books I've read. Immediately recommend it to my co-workers after finishing it.
It summarizes all the concepts of a domain-centric architecture.
Always very practical, focused on web dev, and providing the exact amount of theory.

The only minor downsides: the examples are overly verbose since they're in PHP. Some suggestions are not the best. For example, using exceptions for entities not found in repositories, no big reason was given to abstract primary adapters, not the best approach to test API gateways (he suggests testing them with real 3rd-party APIs but then you'd know about issues only if you build/deploy the app; that's why there's monitoring...).

But still deserves a 5 due to being so practical and I believe timeless.

[Oliver Mensah · Rating 5 out of 5]

This book will teach you how to separate the concerns of a domain model from the infrastructural details that make the application actually run, like databases, webservers, caches, etc.
If you care enough to represent domain concepts about the business you're writing code within then you need to figure out how those business needs can outlive its supporting environments.