Read our leading and best-selling books on advanced software design and development techniques.
Implementing Domain-Driven Design
Implementing Domain-Driven Design presents a top-down approach to understanding domain-driven design (DDD) in a way that fluently connects strategic patterns to fundamental tactical programming tools. Vaughn Vernon couples guided approaches to implementation with modern architectures, highlighting the importance and value of focusing on the business domain while balancing technical considerations.
Building on Eric Evans’ seminal book, Domain-Driven Design, Vaughn presents practical DDD techniques through examples from familiar domains. Each principle is backed up by realistic Java examples—all applicable to C# developers—and all content is tied together by a single case study: the delivery of a large-scale Scrum-based SaaS system for a multitenant environment.
Vaughn Vernon, the author, takes you far beyond “DDD-lite” approaches that embrace DDD solely as a technical toolset, and shows you how to fully leverage DDD’s “strategic design patterns” using Bounded Context, Context Maps, and the Ubiquitous Language. Using these techniques and examples, you can reduce time to market and improve quality, as you build software that is more flexible, more scalable, and more tightly aligned to business goals.
Available in these languages
Domain-Driven Design Distilled
Domain-Driven Design (DDD) software modeling delivers powerful results in practice, not just in theory, which is why developers worldwide are rapidly moving to adopt it. Now, for the first time, there’s an accessible guide to the basics of DDD: What it is, what problems it solves, how it works, and how to quickly gain value from it.
Concise, readable, and actionable, Domain-Driven Design Distilled never buries you in detail–it focuses on what you need to know to get results. Vaughn Vernon, author of the best-selling Implementing Domain-Driven Design, draws on his twenty years of experience applying DDD principles to real-world situations. He is uniquely well-qualified to demystify its complexities, illuminate its subtleties, and help you solve the problems you might encounter.
Vernon guides you through each core DDD technique for building better software. You’ll learn how to segregate domain models using the powerful Bounded Contexts pattern, to develop a Ubiquitous Language within an explicitly bounded context, and to help domain experts and developers work together to create that language. Vernon shows how to use Subdomains to handle legacy systems and to integrate multiple Bounded Contexts to define both team relationships and technical mechanisms.
Domain-Driven Design Distilled brings DDD to life. Whether you’re a developer, architect, analyst, consultant, or customer, Vernon helps you truly understand it so you can benefit from its remarkable power.
Available in these languages
Reactive Messaging Patterns with the Actor Model
Reactive Messaging Patterns with the Actor Model enables enterprise developers to solve complex application and integration problems that were nearly impossible to address before. Developers can build multi-core, multi-threaded, highly-scalable, high performance, low-latency systems, and write composable software that is event-driven, scalable under load, responsive, and highly resilient. Developers are increasingly recognizing the potential of these technologies, and companies including Lightbend, VMware, and SpringSource have recently released new tools for using them. Now, there’s a start-to-finish guide to using reactive programming and the Actor model with Scala and Akka: Reactive Messaging Patterns with the Actor Model.
The book begins with a concise, usable review of programming with the Actor model and the Scala language and the Akka toolkit. Next, Vaughn presents a guide to achieving high performance using the threading model supplied with actor systems. Following this is an easy-to-adapt cookbook of solutions for message-based applications and integration. The detailed solutions address messaging systems, channels, construction, routing, transportation, endpoints, and system management. Each follows the proven format introduced by Gregor Hohpe and Bobby Woolf in their popular Enterprise Integration Patterns, while offering advanced solutions based on Scala and Akka. Using this guide’s insights and examples, you can take Scala programming to the next level, applying Scala with the Akka toolkit to achieve maximum organizational value.
The Addison-Wesley Signature Series: Vaughn Vernon
Vaughn Vernon is a champion of simplifying software architecture and development, with an emphasis on reactive methods. He has a unique ability to teach and lead with Domain-Driven Design using lightweight tools to unveil unimagined value. He helps organizations achieve competitive advantages using enduring tools such as architectures, patterns, and approaches, and through partnerships between business stakeholders and software developers.
Vaughn’s Signature Series guides readers toward advances in software development maturity and greater success with business-centric practices. The series emphasizes organic refinement with a variety of approaches—reactive, object, and functional architecture and programming; domain modeling; right sized services; patterns; and APIs—and covers best uses of the associated underlying technologies.
Strategic Monoliths and Microservices
Driving Change with Purposeful Architecture
Vaughn Vernon and Tomasz Jaskula
Continuous Architecture in Practice
Software Architecture in the Age of Agility and DevOps
Murat Erder, Pierre Pureur, Eoin Woods
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 architectures 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 author’s 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
A Collaborative, Visual, and Agile Way to Build Domain-Driven Software
Stefan Hofer, Henning Schwenter
Storytelling is at the heart of human communication—why not use it to overcome costly misunderstandings when designing software? By telling and visualizing stories, domain experts and team members make business processes and domain knowledge tangible. Domain Storytelling enables everyone to understand the relevant people, activities, and work items. With this guide, the method’s inventors explain how domain experts and teams can work together to capture insights with simple pictographs, show their work, solicit feedback, and get everyone on the same page.
Stefan Hofer and Henning Schwentner introduce the methods easy pictographic language, scenario-based modeling techniques, workshop format, and relationship to other modeling methods. Using step-by-step case studies, they guide you through solving many common problems:
- Fully align all project participants and stakeholders, both technical and business-focused
- Master a simple set of symbols and rules for modeling any process or workflow
- Use workshop-based collaborative modeling to find better solutions faster
- Draw clear boundaries to organize your domain, software, and teams
- Transform domain knowledge into requirements, embedded naturally into an agile process
- Move your models from diagrams and sticky notes to code
- Gain better visibility into your IT landscape so you can consolidate or optimize it
This guide is for everyone who wants more effective software—from developers, architects, and team leads to the domain experts, product owners, and executives who rely on it every day.
Principles of WEB API Design
Delivering Value with APIs and Microservices
The Full-Lifecycle Guide to API Design
Principles of Web API Design brings together principles and processes to help you succeed across the entire API design lifecycle. Drawing on extensive in-the-trenches experience, leading consultant James Higginbotham helps you align every stakeholder on specific outcomes, design APIs that deliver value, and scale the design process from small teams to the entire organization.
Higginbotham helps you bring an “outside-in” perspective to API design to reflect the voices of customers and product teams, map requirements to specific and well-organized APIs, and choose the right API style for writing them. He walks through a real-world example from the ground up, offering guidance for anyone designing new APIs or extending existing APIs.
- Deliver great APIs by getting your design processes right
- Gain agreement on specific outcomes from design teams, customers, and other stakeholders
- Craft job stories, conduct EventStorming, and model capabilities
- Identify the right APIs, and organize operations into coherent API profiles
- Choose the best styles for each project: REST, gRPC, GraphQL, or event-based async APIs
- Refine designs based on feedback from documenters, testers, and customers
- Decompose APIs into microservices
- Mature your API program, implementing design and management processes that scale
This guide is invaluable for anyone involved in planning or building APIs–architects, developers, team leaders, managers in single and multi-team environments, and any technical or business professional delivering “API-as-a-product” offerings.
Patterns for API Design
Simplifying Integration with Loosely Coupled Message Exchanges
Olaf Zimmermann, Mirko Stocker, Daniel Lubke, Uwe Zdun, Cesare Pautasso
As thousands of developers focus on constructing reliable, well-performing, and secure APIs, there’s immense demand for a practical, up-to-date, technology-and-platform-independent guide to API design. API Design Patterns fills this gap. A team of expert authors cut through the complexity of API communication and message content, presenting rich and complete design guidelines and heuristics for engineering APIs sustainably and specifying them clearly.
API Design Patterns covers the entire API lifecycle, from launching projects and establishing business goals through defining architecturally significant requirements, elaborating and implementing designs, and documentation. It illuminates patterns drawn from both public web APIs and proprietary application development and software integration projects the authors have led or participated in. You’ll find a complete library of concrete, actionable design patterns, each formatted consistently to explain context, forces, problem, solution, discussion, and known uses.
Throughout, the authors share practical insights for making better design decisions and tradeoffs, facilitating easier implementation, and structuring and designing higher-quality APIs to meet both short- and long-term needs. You’ll learn how to:
- Facilitate better API design discussions by establishing a common vocabulary, identifying key decisions, and comparing realistic options
- Simplify design reviews and accelerate objective comparisons
- Plan to smoothly evolve and extend APIs without compromising backward-compatibility
- Enhance documentation with useful design knowledge to help client developers quickly grasp API capabilities and constraints, and confidently use your APIs
Adaptive Systems with Domain-Driven Design, Wardley Mapping, and Team Topologies
Architecture for Flow
In a world of relentless change and accelerating uncertainty, organizations must continuously adapt and evolve to compete in environments they never anticipated. This requires upfront design for adaptability, and closer business alignment of software systems and team structures. To succeed, organizations must integrate advanced techniques from business strategy, software architecture, and team organization. Now, independent technology consultant Susanne Kaiser introduces a powerful unified toolset you can use to design, build, and evolve adaptive software systems and teams that are optimized for ever-faster rates of change.
Kaiser shows how to combine Wardley Maps, Domain-Driven Design (DDD), and Team Topologies to understand your problem domain more clearly, focus on your crucial core subdomain, and reflect the dynamics of your business landscape. Using these tools, you’ll learn how to design evolvable services within an adaptive system, which is in turn owned by a team organization that optimizes for fast flow.
Kaiser goes beyond Domain Driven Design’s popular patterns to reveal how DDD enables strategic design for long-term business success. Her accessible explanations and practical examples show how to combine DDD with intuitive Wardley Maps and powerful Team Topologies to improve success across the full lifecycle: strategy, design, implementation, deployment, operation, and evolution. As she demystifies and demonstrates these tools, Kaiser answers the most important questions faced by project participants–from CxOs to architects to software developers.
Balancing Coupling in Software Design
Successful Software Architecture in General and Distributed Systems
Microservices become immensely popular because it promised to help organizations build loosely-coupled systems that allow for fast, easy change. But microservices systems haven’t always kept that promise. This book identifies the deeper problem — how software architects and designers approach coupling – and introduces an important new approach for creating more successful designs whether you use microservices or not.
Instead of blindly avoiding coupling, leading software architecture expert Vladik (Vlad) Khononov proposes a novel method that transforms it into a powerful design tool: “balanced multi-dimensional coupling.” Khononov begins by surveying existing methods of evaluating coupling, and illuminating their strengths and limitations in the context of modern distributed systems. Next, he introduces a new multi-dimensional coupling model, and demonstrates how to harness it to build modular software.
Instead of focusing solely on a single approach, Balancing Coupling in Software Design illuminates underlying design principles that are ubiquitous in SOA, microservices, DDD, design patterns, and other paradigms, revealing how each of them can fail if thoughtful design principles for coupling are neglected — and how balanced coupling can make all of them work more effectively.