Domain Experiments: Refining Models Through Example Mapping and Business-Oriented TDD
Explore domain model refinement through example mapping and business-oriented TDD, enabling rapid experiments without system rewrites. Learn to adapt to evolving requirements efficiently.
Demystifying Event-Related Software Concepts and Methodologies
Explore and understand various 'event' related software concepts, their origins, intentions, and applications in modern IT landscapes.
Unlock Your Autonomy - Improve Your Software Design
Discover techniques to enhance software design autonomy and improve overall system architecture in this insightful conference talk.
Understanding DDD and Clean Architecture Through "The Three Little Pigs" - A Java Implementation
Explore DDD and Clean Architecture through "The Three Little Pigs" fairy tale, with Java code examples for practical implementation insights.
The Data Abstraction Talk
Explore data abstraction's impact on code design, information hiding, and software architecture across programming paradigms. Learn to balance visibility and encapsulation for better dependency management and API evolution.
From Days to Hours: How EventStorming Transformed Our Domain Modeling Process
Explore EventStorming methodology to revolutionize domain modeling, accelerate problem-solving, and enhance system design in complex software projects.
Strangling the Monolith - Applied Patterns & Practices from the Trenches
Practical strategies for incrementally modernizing legacy systems, focusing on the strangler pattern, domain-driven design, and team topologies to evolve towards a reactive architecture.
Actors Can Rule Your DDD World
Explore implementing DDD principles with actor models in .NET 6 and Akka.NET for event-based CQRS systems. Learn key concepts, see code examples, and discover the synergy between actors and DDD.
DDD Really Matters
Explore deep collaboration with domain experts and five essential strategies for achieving excellence in software development initiatives.
Domain-Driven Refactoring
Explore techniques for transforming existing code into a more cohesive, domain-driven design through refactoring, pattern recognition, and strategic application of DDD principles.
Getting the Best Out of Entity Framework Core
Explore Entity Framework Core's inner workings to optimize database access, including querying, relationships, unit testing, and Domain-Driven Design integration.
Reinventing the Transaction Script
Explore functional programming principles to reinvent the Transaction Script pattern, enhancing domain-driven design while maintaining simplicity and productivity in business logic organization.
Practical Domain-Driven Design with EF Core
Explore practical Domain-Driven Design implementation with Entity Framework Core, covering key concepts like bounded contexts, domain models, and specification patterns.
Modernizing an Existing System to Take a More Domain-Driven Approach
Explore refactoring patterns and steps to transform a non-DDD SOA system into a domain-driven design approach, covering key concepts, implementation strategies, and decision-making processes.
Data Mesh in Practice - How Europe’s Biggest Online Fashion Retailer Goes Beyond the Data Lake
Explore how Zalando transitioned from a centralized Data Lake to a distributed Data Mesh architecture, emphasizing data ownership, quality, and accessibility at scale.
Capability Mapping
Explore business capability mapping for effective microservice design, enhancing organizational agility and product velocity through strategic alignment and improved integration.
Refactoring the Architect's Role
Modernizing the architect's role: strategies for mentoring, scaling processes, and maximizing efficiency in microservices environments. Explore principles to guide teams towards success and redefine the architect as a peer.
Domain Driven UI
Explore Domain Driven UI using F# and SAFE-Stack to seamlessly integrate backend domain models with frontend design, enhancing user experience through a functional approach.
Agile Software Architecture
Explore agile software architecture principles, roles, and practices. Learn how to effectively implement architectural concepts in modern development environments.
What Swift Devs Can Learn from C++
Explore C++ features Swift developers might envy, including performance optimizations, hardware customization, and mature community practices, presented by an iOS developer working on Photoshop for iPad.
Domain Driven Design and Onion Architecture in Scala
Explore Domain Driven Design and Onion Architecture in Scala, focusing on code readability, maintainability, and rapid prototyping. Learn key concepts and practical techniques through a code-driven approach.