Cyrille Martraire

Cyrille Martraire

Deliberate Designer, Consultant & Trainer


Cyrille Martraire (@cyriux) is CTO and partner at Arolla (@ArollaFr), a company gathering 130 developers specializing in modern software practices. He's the founder of the Paris Software Crafters community in 2011 and has since been a regular speaker at international conferences. With 23+ years of experience, Cyrille now helps scale-ups and corporations as a consultant and trainer on evolving and modernizing systems to be more modular.

Cyrille is the author of the book Living Documentation (Addison-Wesley Professional, 2019) and co-author of Software Craft (Dunod, 2022).

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 !

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.

Cyrille Martraire

Deliberate Designer, Consultant & Trainer


Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.

Jump to top