The more you design your system into multiple Bounded Contexts, involving multiple teams, the more you’re going to face excessive coupling due to causality effects. Actions in one context often trigger consequences in others, leading to intricate dependencies, such as when updating purchase order statuses, modifying UI user journey kinematics, or undoing operations across multiple contexts.

This talk introduces unpublished modeling patterns designed to elegantly handle causality between Bounded Contexts while minimizing coupling. If your system is or is becoming modular, these patterns will prove valuable to preserve your teams' autonomy!

As developers, we are often explained the business domain in a way that is corrupted by implementation concerns or past constraints. This is harmful. To achieve better domain models, we often have to reverse-engineer. Alternatively, we can also explore the domain from its first principles, which are the main concepts or assumptions that cannot be deduced from anything else.

Dependencies come in many forms, from binary libraries to JSON contracts for example. While they are necessary to build complex systems, dependencies are also the cause of a lot of headaches, and learning how to better deal with them makes your life less miserable in the long run.

Through this talk you'll explore the universe of dependencies in the light of Domain-Driven Design. From the good old Hexagonal Architecture and its variants, the dependencies between Tactical Patterns at small scale to Cohesive Mechanisms or the Levels of Responsibility at a larger scale, you'll discover guiding principles that you can use to improve your design taste for great good.

Everyone has their own perspective on design, and I'm no exception. In this talk I will explore simple stuff explained in a complicated way, or the other way round, whichever is worse. For example I will talk about congruence as an essential quality of design, and salience as a life-saving approach for testing. Intimidating words indeed, but for real benefits!

Deep conversations with domain experts and careful attention to the language are central in software development and in particular in Domain-Driven Design (DDD). However it takes many years and many failures to get better at this game.
Still, over time it is possible to extract a growing set of techniques and heuristics that can boost the effectiveness of the interviews with domain experts, to learn faster and converge quickly to better models.
There are techniques and heuristics for asking better questions, listening carefully to words and other signals, and for managing credibility as a developer facing business experts.
If you think all the above is important, then these interviewing techniques will improve your skills, step up the quality of your collaboration with your domain experts, and will provide benefits for better domain models. And if you find all that boring, then perhaps you could focus your career on Java EE instead.

How do you represent the Ubiquitous Language in practice? How do you materialize Bounded Contexts in your code? How do you document your understanding of the domain?

In this talk we'll show concrete answers to these questions and some more, in a way that will make you want to get started. And beyond mere recipes, these questions offer opportunities to get accurate feedback to improve your actual practice of DDD.