Get a fresh and pragmatic perspective on top-down, realistic software application architecture: from DDD to CQRS and from both up to UX and task-driven design, events and polyglot storage.Mer information & fakta
Domain-driven design (DDD) emerged a decade ago as a very intriguing way to tackle the inherently complex task of writing business software. DDD worked for many and failed for as many others. One of the reasons for the fifty/fifty result was the unperfected definition of the approach. The true value of DDD is in the guidelines and tools it provides for domain analysis rather than in the software development practices it suggests. Deep understanding of the business processes and the structure of the client organization is essential to define a software model that truly mirrors the real-world. Even more important is mirroring via software the tasks that users accomplish in their everyday activity. This leads to the need of counter-analyzing the common understanding of DDD and, well before actual architecture and technology, it shifts the focus on UX aspects. Quite surprisingly, when you start with a task-oriented analysis a bunch of architecture buzzwords come magically into place, such as CQRS, polyglot persistence and event-sourcing.
The class starts from the following definition of software: well-designed software is any software that understands and matches the business domain and that is easy to modify, adapt and even rewrite. Subsequently, the purpose of this class is presenting the state-of-the-art of software architecture and discussing a few reference implementations primarily but not exclusively on top of the .NET Framework.
You’ll first get an annotated overview of parameters that make software successful today and then tools available for domain-driven analysis (DDD). Next, the class presents the DDD canonical layered architecture and supporting design practices such as Domain Model, CQRS, event-driven architecture or just CRUD. A strong emphasis is put on using events as the primary data source of the application presenting emerging design patterns and frameworks.
This class doesn’t evangelistically promote any approach or technology but dissects the recent dynamics of software design to bring up what makes each pattern suitable to given business scenarios. Finally, a new methodology is discussed—called UX-first—that pushes a top-down design of software systems and sits somewhere in between classic waterfall and modern agile. In doing so, you’ll face the challenges of today’s and tomorrow’s software: data persistence, responsiveness and scalability.
The litmus test of this class is fairly simple and ambitious at the same time. The class worked if, after taking it, you feel like all buzzwords you hear other scream about are all coming into place.
All code shown during the class uses C# and the Microsoft .NET Framework. However, that happens only for convenience. Much of the content of this class is language and platform independent.
- Discover the natural architecture of a system using ubiquitous language and bounded contexts
- Take a user experience (UX) first approach, rather than designing for data
- Found your design on distinct command and query stacks rather than comprehensive models
- Use event-sourcing and CQRS together to model complex business domains more effectively
- Reconsider the role of the database—a polyglot layer rather than a product
- Reconsider tools and strategies for scalability and performance
- Understand scope and impact of devices in architecture
Developers and lead developers willing to grow professionally by learning design principles and architecture patterns to apply in everyday work. The class also addresses well common needs of project managers and IT managers who coordinate the various phases of the software development process and gives them solid skills to better understand what’s going on these days in software and communicate with super-skilled developers and architects. Finally, the class may also result fruitful to solution architects needing a crisp refresher or looking for a new perspective that rejuvenate their design spirit.
Foundation of Successful Software Projects
- Why prioritizing software maintainability is crucial
- Readability, testability, and extensibility
- Mechanics of software projects
Discovering the Domain Architecture
- Domain-driven design analysis of the business (processing requirements)
- Ubiquitous language
- Bounded contexts
- Mapping contexts
DDD Supporting Architecture:
- Domain Model
- Aggregates and value objects
- Domain services and persistence
- Domain events
Supporting Architecture: CQRS
- Virtually infinite scalability and extensibility
- CRUD just done better (TX Script pattern)
- Event-driven command stack
- Options and tools for the read stack
Supporting Architecture: Event-Sourcing
- (Business) Benefits of a lower level data source: general maintainability, extensibility, BI extensions
- Options for the event store
- Data snapshots and history
- Options for performance tuning
Introduction to Event Databases and Frameworks
- The grammar of events
- Historical CRUD
- SQL Server 2016 and JSON serialization
- Event data stores
- More advanced event frameworks in the works
Role of Polyglot Persistence
- Challenges of modern persistence: costs, consistency, tools, expertise
- Pros/Cons of NoSQL in business domains/scenarios
- Role of UX experts
- Approved and verified screens before coding seriously
- New frontier of project management
About Dino Esposito
A long-time trainer and top-notch architect, over the past 15 years Dino has been the author of many popular books for Microsoft Press that helped the professional growth of thousands of .NET and Web developers. Latest books are “Microsoft .NET: Architecting Applications for the Enterprise” (MS Press, 2014, 2Ed) and “Modern Web Development” (MS Press, 2016). Dino currently applies his expertise mostly to the professional sport industry, among the first to seize the opportunity of Web and mobile integrated development. Dino is also a technical evangelist for JetBrains and ScientiaMobile, a Pluralsight author and a regular contributor to MSDN Magazine. Follow Dino on Twitter as @despos.