.NET Software Architecture – Architecting Applications for the Enterprise
Get a fresh perspective on real-world software design: from DDD to CQRS and from both up to Event Sourcing
Duration: 24 hours
- 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 architectureExperience with SQL Server
WHEN and WHERE is this course running?
What does this course cover?
Domain-driven design (DDD) emerged a decade ago as a very engaging way to tackle complexity in the heart of software. DDD worked for many and failed for as many others. Today we’d better split the DDD approach in two distinct parts: analytical and strategic. DDD analysis is about understanding the business processes and the structure of the client organization. This type of knowledge is essential to model a software architecture that fits nicely mirroring the real-world rather than reinventing it based on assumptions. The strategic part of DDD is about choosing the ideal software architecture for distinct subsystems in accordance with a few parameters such as expected lifespan of the software, skills, legacy code and the canonical costs and deadlines.
This 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. 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.
Who is this course designed for?
Meet the author
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.
All our courses can be offered as a private delivery and tailored for your team's specific needs
- 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 framework in the works
- Role ofPolyglot 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
- New frontier of project management