Update Your Architectural Practices for New Challenges, Environments, and Stakeholder Expectations I am continuously delighted and inspired by the work of these authors. Their first book laid the groundwork for understanding how to evolve the architecture of a software-intensive system, and this latest one builds on it in some wonderfully actionable ways. --Grady Booch, Chief Scientist for Software Engineering, IBM Research Authors Murat Erder, Pierre Pureur, and Eoin Woods have taken their extensive software architecture experience and applied it to the practical aspects of software architecture in real-world environments. Continuous Architecture in Practice provides hands-on advice for leveraging the continuous architecture approach in real-world environments and illuminates architecture's changing role in the age of Agile, DevOps, and cloud platforms. This guide will help technologists update their architecture practice for new software challenges.
As part of the Vaughn Vernon Signature Series, this title was hand-selected for the practical, delivery-oriented knowledge that architects and software engineers can quickly apply. It includes in-depth guidance for addressing today's key quality attributes and cross-cutting concerns such as security, performance, scalability, resilience, data, and emerging technologies. Each key technique is demonstrated through a start-to-finish case study reflecting the authors' deep experience with complex software environments. Key topics include: Creating sustainable, coherent systems that meet functional requirements and the quality attributes stakeholders care about Understanding team-based software architecture and architecture as a flow of decisions Understanding crucial issues of data management, integration, and change, and the impact of varied data technologies on architecture Architecting for security, including continuous threat modeling and mitigation Architecting for scalability and resilience, including scaling microservices and serverless environments Using architecture to improve performance in continuous delivery environments Using architecture to apply emerging technologies successfully Register your book for convenient access to downloads, updates, and/or corrections as they become available. See inside book for details.
Disclaimer: I’m a fan of everything that Vaughn Vernon does. I have read all his books and my expectations around his Addison-Wesley signature are really high.
This book is not a good beginning. It’s a high-level overview introductory book around architecture for probably enterprise people that don’t know anything about architecture. Except for a couple of good quotes in the first two chapters about why the enterprise architects are not doing what it’s supposed to, the rest of the book doesn’t add anything new and it doesn’t go deeper in any topic at all.
There is no concept of “continuous� in the book, neither “in practice� (it’s true that there is one project example been used through the book, but it’s quite anecdotic. Do not expect a proper case study).
I’m getting ready for the other signature books.
This book by three very experienced practitioners is a must-read for anyone involved with the architecture, development, and delivery of business systems within an enterprise.
The book provides clear and concise explanations of fundamental principles of software architecture and then uses a set of case study examples to illustrate how the principles are applied in real-world situations. The case studies consider technical decisions in the context of constraints like time-to-market, team structure and skills, risk tolerance, and business value.
It is hard for a software architect to find a good mentor - this book fills some of that gap.
Had high hopes for this book, especially since it is part of the Vaughn Vernon signature series. Does not go into details about any of the subjects, more like a list of things and tech... with a lot of filler in between. The whole book could have been condensed into less than 80 pages, illustrations included. If you are just beginning with software architecture you might want to read it, but if you have some real-life experience, it will not provide anything new or interesting.
A very nice and refreshing overview for the most important steps needed for constructing a proper architecture and, very important, a concrete timeline for them! I liked a lot that it doesn’t provide actual implementation details (leaving these aspects to be covered by the reader) and it focuses on a high level description for aspects related to Data Storage & Management, Security, Scalability, Performance, and Resilience (with a greater amount of details on the latest point). There are some things which are pretty commonly known nowadays but there are also some aspects which aren’t met in the daily activities but bring a great amount of food for thoughts. I would recommend it without hesitation as a reference for future reading in the architectural bookshelf!
This is the rarest of books - one that can be read at several levels and in a host of situations. Grab it before starting a large project to remind yourself what matters in setting up the right design and, even more important, the way to get there. Then come back as you work on the project to read and re-read the chapters on data, security, scalability - each master class covering the topics expertly (in a way that clearly stomped some of the other reviewers. ) This is a book that distills wisdom, clearly gained through experience but still has a surprising amount of “here is how you do it� to provide instant value. The authors also provide a considerable range of references that point to important but now well understood topics, so it won’t explain what DevOps is - it does something much more valuable: it helps connect all the dots into a coherent philosophy (the authors eschew the terms “framework� or “methodology�) anchored into a few key principles. As a Fortune 100 Chief Architect, I had made the authors' previous book (which I recommend to although this is a self-standing work) required reading in my team members - this one will join it on their shelves too.
Most problems in technology are really communication problems. Most architecture problems then are ones of consensus; agreement between institutions and factions within an organization, between product, tech, the dev teams, that one dev manager who was a dev and was a MySQL pro who hasn't met a solution that MySQL couldn't answer. Building that consensus means you rarely arrive at a technically pure solution, one that meets all use cases optimally. There are just too many competing forces, often too much institutional inertia or too much tapering interests in projects that take longer than a 3 month program increment. This book attempts to define a language we can use when talking about architecture. What does scalability, or security, or performance really mean outside of the buzzwordy, euphemistic way the terms can be bandied about. One who is fulfilling the competencies of an architect then can use this language to build consensus, to get the sort of buy-in that is required for doing anything in the complicated ecosystems of today's enterprises. If you can agree that performance, or scalability can be reduced down to a series of quantifiable stimulus, response, and measurement triads, then picking the tech stack to meet those use cases is an implementation detail.
This book is an argument for "continuous architecture", building off the iterative and continuous delivery of software we have seen with the Agile and DevOps movements over the last ten years and staking out arguments for what a continuously delivered architecture looks like within that framework. The "in practice" part refers as much to the recurring case study of a trade finance system the book has threading through each chapter as it does to an emphasis on the process and people edges of the PPT framework.
So many book reviews of tech books hinge on whether or not the reader already knows what's in the book. A book is either castigated as a beginner sampler, or as reductive to the topics it addresses. I think in the case of this book, it isn't attempting to tread new ground but to build a ubiquitous language of architectural concerns. It breaks down topics and provides mini-frameworks for how to talk about them, giving you predominant trends and implementations within a given quality concern. Sure, after reading this books trim 268 pages you won't be ready to implement a microservice architecture, but you'll know the questions to ask, where to start, and what to concentrate on. And that is the strength of this book. It provides scaffolding for how to think about architecture, outlining 6 principles ((1)Architect products; evolve from projects to products, (2) Focus on quality attributes, not on functional requirements, (3) Delay design decisions until they are absolutely necessary, (4) Architect for change -- leverage the "power of small", (5) Architect for build, test, deploy, and operate, and (6) Model the organization of your teams after the design of the system you are working on), and harkening back to them constantly. Each quality attribute that the book addresses will reference these principles, providing a metronome-like repetition drill.
The book serves as as good as any an entry point for introduction into the increasingly diffuse competencies of an architect, and while I skipped their initial book about continuous architecture, I found this one to be an effective tool in building out my mental model of architecture.
We still struggle today with what architecture should be, but this book describes in an inspiring way what architecture could be, mainly a work to try to give systems desired properties or qualities and not to deliver all functional requirements. Using a fictional system, the book describes in detail critical qualities for the time of digitalization we live in and how various compromises and choices need to be made to give the system the desired qualities. I can really recommend the book to System Architects á la SAFe and similar roles, given that the book focuses a lot on technology.
It is of course a challenge to identify and give systems desired properties in the often complex world we live in. It is not always fair to ask users what choices we should make with system qualities. But as the book writes, we need the help of an agile approach with continuous development and the possibility of monitoring (quality observability?) to handle the often complex world we live in and enable incremental delivery of business benefits. However, working agile is not easy either. An insecurity in giving "go" to start developing epics á la SAFe or equivalent easily results in a big-design-up-front.
It is too much to ask for a book to have answers to all questions, but the book works great as an encyclopedia to start solving critical qualities. Each section then has a solid list of sources to dig deeper into for different ideas on solutions.
Thank you Murat, Pierre, and Eoin for a fantastic book. A book I will really recommend to my colleagues.
"Continuous Architecture in Practice" a comprehensive capture of Architectural concerns, Essential activities and practical case studies, is by far one of the best books I have read recently in the field of Software Architecture. People interested in Software Architecture specifically in the context of emerging technologies, be it practitioners or aspirants, will most probably be interested in reading this book.
Readers can gain knowledge of what it is to apply Architecture principles to more modern or emerging technologies in an agile environment. One of the things that is especially interesting is the key focus on Application Quality attributes such as Scalability, Performance and Resilience. There are dedicated chapters for these aspects. Coming from a Financial Services background, I am really happy with the case study "Automating Trade Finance". Roughly 30 pages are dedicated just for the case study discussion. One of the bonus aspect in this book is the "Comparison of Technical implementations of Shared Ledgers".
Overall, a very good read and highly recommended for any Software Architect's bookshelf. Thanks. Mac SM.
Some people learn best from a set of principles that help them to see the "big picture" while not getting lost in the details. Others learn best from examples that they can relate to their own context, to help them develop their own conceptual models. This book speaks to both kinds of readers: it provides a simple set of principles, and then use examples to show how those principles can be applied to address various software architectural concerns. In doing so, the principles and examples help the reader to develop their own ability to reason about different kinds of architectural challenges.