Digging deep into a topic by digging scientific papers

Why waste time reading opinions and speculative facts when you can find reliable answers in scientific papers? But let's face it, academic literature can be intimidating if you don’t know how to navigate it.

If you’re not familiar with the world of published papers, then join @cyriux in a workshop where you’ll actually start digging into boring yet fascinating stuff that will propel your learning on a topic of your choice.

I dig scientific papers all the time, in any topic I need to learn seriously. This workshop is to help others get started without getting bored or intimidated

- start by a search with academia-specific words (eg citation)
- navigate the bibliography of each text
- discover the official names of the subtopics to explore more
- know where to find some version of any paper even if you don’t have a subscription to journals
- learn the common structure of papers to read them ultra fast
- save time by not reading unreliable material

Untangling Consequences: Causality Patterns for Effective Multi-Context Design

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!

Untangling Consequences: Causality Patterns for Effective Multi-Context Design

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!

Living Documentation: Tackling the knowledge in the heart of software

If you prefer coding over writing documentation, then you’ll love Living Documentation! A Living Documentation is a new approach to dramatically improve how knowledge is shared in the development team. It evolves at the same pace as the ever-changing codebase with a minimal extra cost by using judiciously-crafted artifacts and some automation.

Living Documentation builds on top of practices like BDD and DDD, but it also has its own key principles and novels ways to documenting every aspect of making software, from defining the business goals to discovering the domain knowledge, creating the architecture, designing and coding. Join Cyrille Martraire, the author of the book "Living Documentation" (Addison-Wesley Professional, 2019) to find out how to speed up your software delivery by implementing this approach in your projects!

Crafting Modular Architecture

Objectives:
This presentation brings together everything you need to know to be able to tackle architecture issues in companies calmly, on systems that can be complex. It is derived directly from state of the art and is validated by our years of experience with customers.

During this course you will:

Become acquainted with the main architectural patterns and styles and the state of the art
Design, document and present a pragmatic architecture
Solve the main problems of an architecture in production
Identify couplings and modularity criteria
Decouple components and manage scalability and availability
Gain an overview of the entire software system
Presented by experts with extensive personal experience in architecture in different contexts, this course mixes theoretical presentations with exercises that will enable participants to really get involved and intensify their understanding.

Architecture in a corporate or business context involves highly technical factors, as well as significant human issues; this is why this course covers both of these facets, in order to provide a complete overview of the topic.

Programme
Introduction to Architecture

The multiple definitions of technical architecture: a question of stability, large scale, shared knowledge, irreversible decisions
Architecture as a means of aligning a company’s objectives with its information systems
Architecture as implementation styles
Global vs. local architecture, Umbrella diagrams
Overview of architectural styles

Hexagonal Architecture
Event-Driven Architecture
Pipeline
Microservices
Enterprise Integration Patterns (EIP, Greqor Hohpe), Integration styles
PoEAA (Fowler)
API design
Emerging Architecture
Technical Architecture

Configuration, Discovery
Asynchronous messaging
Data consistency: Golden Source, replication, autonomy vs. authority
Fault-tolerance, load balancing
Stateless vs stateful, consequences, stickiness & affinity, managing sessions
Logging & tracing guidelines
Monitoring: guidelines, tools, alerting
Integration in practice: reconciliation, data migration
Test-Driven Architecture, metrics, static analysis
Architecture Documentation

The importance of communication in architecture, techniques and tips
Living Documentation applied to architecture : Evergreen Overview Document, Internal Documentation with annotations and coding conventions
Living Diagrams generated with each build
Legacy migration patterns

Extension by Federated Service
Strangler Application
Legacy Read Model
Architecture & SDGs

Overview of Bounded Contexts and Context Mapping
Overview of Large-Scale Structures of DDD
General Information
This course is aimed at experienced developers, team leads, architect managers, but also at experienced or aspiring architects.

Course Requirements:

Knowledge of different programming languages with good object design skills.
Previous experience in software development.
Participants must have a workstation with a development environment.
Teaching Materials:

The trainers will distribute the teaching materials in PDF form at the end of the course.

Teaching Methods:

30% Theoretical, 70% Practical

Property-based Testing with Monoids

You may already know Property-based Testing as a complementary approach to TDD. You may also have heard of Monoids: they are simple maths creatures really useful to model all sorts of real-life business situations. In fact, you're probably familiar with them without knowing it. If not, do not worry: we’ll cover them first before starting a kata expected to demonstrate how well they combine!

Join Cyrille & Mathieu for this 2-hour workshop where you will be guided towards coding your own domain model powered by monoids and guided by Property-based testing. You will be ready to apply monoids at work the next day and it will change your coding (and testing) style forever!

Expected Audience: this workshop is for developers in any programming language, Java and JavaScript being the sweet spot. You’ll code in your IDE or with the IDE of your coding partner if you’re willing to!

Key learning points:
- Discover or revisit your understanding of Property-based testing and monoids
- Start practicing Property-based testing on an ideal case thanks to the strong properties of monoids
- Acknowledge the limits of the approach, and the relationships with other design patterns

Monoids in Practice

(This is a hands-on lab with limited capacity. You should receive an invitation to sign up for your favourite session at latest one week before the conference. Capacity of this session = 28)

Monoids are easy to learn, and really useful to model many real-life business situations. Monoids are simple maths creatures, that you're familiar with without knowing it. In fact, the only difficult thing with monoids is their name. Still, how do you actually start using them in code?

Join Cyrille for this little workshop where you will be guided towards coding your own domain model powered by monoids, so that you can apply them at work the next day.

Expected Audience:

This workshop is for developers in any programming language, Java and equivalent being the sweet spot. You’ll code in your IDE (or with the IDE of your coding partner). A quick grasp of monoids would be ideal, but not necessary.

Key learning points:

- Revisit your understandings of (or discover) monoids
- Put monoids into practice through the Monoid Kata (or another even more difficult kata of your choice if you’re adventurous)
- Acknowledge the limits of the approach, and the relationships with other design patterns

Living Documentation

If you prefer coding over writing documentation, then you’ll love Living Documentation! A Living Documentation changes at the same pace as software design and development, from establishment of business goals to capturing domain knowledge, creating architecture, designing software and coding. It builds on top of BDD and DDD, but it also has its own key principles and novels ways to dramatically improve your documentation at minimal extra cost by using well-crafted artifacts and judicious automation.

This workshop from Cyrille Martraire, the author of the book "living Documentation" (Addison-Wesley Professional), will guide you on how to implement the approach in your projects. Even if you haven't read the book, this workshop is the right place to learn the main elements of a Living Documentation, step by step through a provided sample Java code base.

You will learn

- How most knowledge is already there somewhere in your artifacts, even in an implicit form
- How just talking and working together may be enough documentation, and when it does not
- How to augment the code to make it fully explicit for further use by people and tools
- How to differentiate between stable and volatile knowledge, and how this informs the way to deal with it
- How to create zero-maintainance Evergreen Documents
- How to recognize Shameful Comments and improve your code from there
- How a word cloud can tell if you're doing your domain model wrong
- How to generate a Living Glossary straight out of the code
- How Architectural Decisions Records can help make better decisions
- How Design Patterns help document a design decision very efficiently
- How to visualize a design structure by generating a Living Diagram from the code itself
- How to use plenty of other techniques to improve your particular needs, and the main traps to avoid
- How failing to do any of the above is in itself a valuable feedback
- How to introduce the topic in your project and with your colleagues

What you will need

- A working Java 8 environment with Maven for two attendees
- The sample project (only using basic Java) will be available from github or from a USB key

Domain modeling towards First Principles

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.

Reaching for first principles takes more mental energy, but is also the key to more radical innovations beyond small incremental evolutions. It also turns domain modeling into a fun puzzle to solve.

Through examples you will discover how domains can be deconstructed towards their essential first principles, in order to reconstruct sharp domain models.

Implementing Monoids for Great Success

You've heard good things about monoids (not monads) and how useful they are for domain modelling, and you've decided to incorporate that into your programming style. That's great! But now you'd like to start making your own monoids in code, with some guidance. This practical workshop is for you! You will code a few monoids, and learn how to use them to the max.

You will:
- Understand monoids without a headache
- Create your own custom monoids on a few examples
- Discover many possible applications of monoids at work
- Learn how to test them, including with Property-Based Testing
- Learn tricks to make anything into a monoid
- Grow a curiosity for other mathematical structures

This workshop can be done in any programming language you're familiar with and that you have installed on your own computer.

Crafter : pourquoi pas moi ?

Déjà 10 ans de Software Craft ! Comment vos pratiques ont-elles évolué durant cette décennie ? Et finalement c'est quoi vraiment le craft, et surtout est-ce que c'est pour vous ?

Embarquez avec Cyrille Martraire, le fondateur de la communauté Paris Software Crafters depuis 2011 pour découvrir l’historique et les enjeux du software craft et les pratiques qui en découlent, avec un peu de recul !
https://roti.express/r/ATL-35

Bounded Contexts in 25mn

Bounded Contexts are a key ingredient of Domain-Driven Design, and knowing about them can really make a difference. Through non-technical examples, you'll get a concrete grasp of the concept. It's not that hard to understand Bounded Contexts!

Bounded Contexts

Bounded Contexts are a central concept in DDD. As linguistic boundaries between different domain models, they help us tackle complexity.

Blink Modelling

(This is a hands-on lab with limited capacity. You should receive an invitation to sign up for your favourite session at latest one week before the conference. Capacity of this session = 28)

DDD Europe is pairing up four master modellers with four domain experts they’ve never met, with four domains they’ve never modelled.

In two hours, with the help of an unsuspecting audience, they’ll model it at maximum speed. They’ll identify risky and complex issues, isolate it, visualize it, turn it inside out. Or, they run out of time with a big fizzle.

Bounded Contexts for Team Organization

Since Conway's Law was discovered in the sixties, we know that the organisation structure and the system design it produces, are closely linked. Bounded Contexts can help us create better team autonomy, resulting in more effective software designs.

Breaking conventions for more performant models

Everything’s possible when you model a domain, and you don’t have to follow conventions. Indeed, it can be beneficial to model time, space, roles and anomalies in unconventional ways to simplify the model or enhance performances. The end of day doesn't have to be at midnight, regions don't have to be administrative, time and space can even be split in irregular ways.

In this talk, we will present multiple examples demonstrating how taking liberties with domain traditions can be advantageous within bounded contexts and sometimes even in identifying the bounded contexts themselves.

This is a call to action to encourage software practioners to model beyond the obvious.
The end of day doesn't have to be at midnight, regions don't have to be administrative. Time and space can also be split in irregular ways. And domain anomalies don't necessarily have to be seen as actual failures.

Architecture for Everyone, Everywhere, All the time

As software systems get more complex and move to the cloud, the trend is clear: architecture is becoming a concern for everyone, all the time, and everywhere.

It is therefore essential for every team to have a good understanding of architectural practices. But as we cannot be experts in everything, what do we really need to know, and how is the role of architects evolving?

This session provides a synthetic overview of the key topics to be familiar with, from the mindset when facing a problem to the techniques for integrating modules, minimizing coordination needs, and ensuring consistency at scale. It will also highlight the importance of having the right attitude in each context, in addition to mastering a growing number of technologies.

This talk is a summary of the key points of my popular commercial workshop "Pragmatic Architecture" (also called "Crafting Modular Architecture").

Audience: Developers with experience and curious about architecture

The content has already been presented in conferences at Devoxx France as a deep dive format, and as a talk at a private event at France Travail with an attendance feedback of NPS=86, where many attendees were architects or senior devs.