Java dans le cloud : Avec Spring ou Quarkus ? en

Après presque 20 ans, la vieille guerre « Java EE vs Spring » semble enfin terminée ! Comparer une spécification avec un framework n’avait pas grand sens. Surtout quand on a réalisé que Spring s’appuie (en partie) sur Java (maintenant Jakarta) EE.

Et voici un nouvel acteur arriver : Quarkus … Un framework Subatomic et Supersonic !

Spring vs Quarkus, framework vs framework : une nouvelle guerre en vue ? Une vraie ? Pas forcément ... Plutôt que de les opposer, nous vous proposons de les comparer concrètement sur des cas d’usage précis : API REST, persistance, programmation réactive, code natif, test …

Nous avons besoin de vous pour y voir plus clair : nous vous mettrons à contribution avec des sondages en live pendant nos démos.

A l’issue de cette présentation, nous aurons une vue complète et objective de ce qui les rapproche et ce qui les différencie. Nous saurons également comment transposer cette réflexion et faire le bon choix pour nos prochains projets.

Take your your Java REST API development to the next level by adopting an API-First approach en

Have you ever found yourself in a situation where the API documentation was outdated or simply incorrect? This situation is mainly due to the fact that the documentation is either done after the fact or the generation tools are not suitable.

In the context of API development, we too often oppose Code-First approaches to API-First approaches. Most developers prefer the former because it is more code-centric and documentation is generated automatically. Unfortunately, the latter is often only associated with the words "documentation" or "specifications."

However, designing and implementing an API-First approach offers many advantages: ensuring that implementations are compatible with specifications, automating the validation of published APIs, and most importantly, enhancing the developer experience for your customers.

In this Tools in Action, we will transform an API developed in Java using Spring by shifting from "Code-First" to "API-First" using the latest practices and tools.

By adopting main API specifications such as JSONAPI and OpenAPI, and utilizing tools from the OpenAPI initiative like OpenAPI Generator and Microcks, we will therefore improve the design and software lifecycle .

Last but not least, we will explore how to tackle this major challenge: improving the quality of your API, encouraging its adoption by your clients, and, above all, getting your developers to enjoy writing and handling API documentation.

Let your Java application be truly observable! Let's dive into logs, traces and monitoring en

Imagine, it's Friday afternoon.
You're eager to enjoy your weekend when an Ops engineer forwards you a blocking issue with an HTTP 500 error.

Indeed, he couldn't identify the root cause due to a lack of contextual information.
After a few hours, you finally manage to identify it by reproducing and debugging it on your computer.

If you're accustomed to facing such issues, it surely means that you may have overlooked developing one of the most important features of your application: Observability!
During this workshop, we will implement logging best practices and cover the whole observability stack from libraries to storage backend and visualization tools based on the Grafana Stack (Tempo, Prometheus, Loki, Grafana).
We will therefore get an overview of how Devs can make Ops their best friends by making our Java application more reliable and production-ready!

Architecture Katas : Improve your system architecture design skills in a funny way ! en

How to learn architecture ? How to improve in this field ? How do we recognize a good or a bad architecture ?
There are plenty of books and training sessions about this subject. The best thing is to practice!

In the same way as coding dojos, I will present to you architecture katas. There are created by Ted Neward (http://blogs.tedneward.com/). His idea came from the following observation :

"So how are we supposed to get great architects, if they only get the chance to architect fewer than a half-dozen times in their career?"

One solution to this issue could be to practice regularly on several topics to gain experience.

After a brief introduction of how to start designing an architecture, I will present architecture katas, and the conduct. Then we will do a kata together.

To conclude, after this first try I will present the benefits I had benefited.

Améliorer les compétences et les infrastructures avec les katas d'architecture en

Comment devenir architecte ? Comment progresser dans ce domaine ? A quoi reconnait-on une bonne ou une mauvaise architecture ? Il existe certes un certain nombre d' ouvrages et formations sur le sujet, mais le mieux est quand même de pratiquer ! A la manière des coding dojos, je vais vous présenter les Architecture Katas. Ces derniers ont été initiés par Ted Neward. Son idée est venue du constat suivant :

"So how are we supposed to get great architects, if they only get the chance to architect fewer than a half-dozen times in their career?"

La solution à ce problème est donc de pratiquer régulièrement sur des sujets très différents pour gagner en expérience.
Je dresserai dans un premier temps un rapide constat sur le besoin de gagner en compétence en architecture. Puis, je ferai un retour d'expérience sur la manière de démarrer une conception. Après tout ça, je vous présenterai les katas d'architecture. Je commencerai par les règles et le déroulement. Enfin, je finirai par les bénéfices que j'en ai tiré.

Real-life REST API Versioning for dummies: Strategies and Best Practices en

When we want to publish APIs, for instance using an API Management solution, we regularly think about versioning.

This practice meets project management needs but brings a lot of complexity.
Imagine, you work on a platform which exposes APIs to many customers.

You must bring new features while controlling the existing ones.

Which strategy to adopt? What are the potential technical tools and practices we could implement easily?

During this presentation, you will unlock the secrets of API versioning I have put in place and helped me during my last projects.

Through a real-life use case based on a microservices architecture, we will define the best strategy to put in place, the other potential ones and their constraints.

At the end of this workshop, we will have the big picture on the diverse ways of APIs versioning.

I presented this talk at:
- DevFest Lille 2023
- API Days Paris 2023

The hitchhiker's guide to architecture design en fr

Designing a new platform is always tricky to set up.

How to start? What is the best strategy to adopt while designing a platform? What kind of architecture should we deploy: event streaming, orchestration, or choreography?

For a brand-new platform: "Donut @ Home", we will proceed a live architecture study.

After analysing the customer needs, brainstorming, and exchanging our ideas, we will choose among all the potential solutions the *least worst* option.

You will be asked to validate our design and the different implementation examples.

At the end of this talk, you will have tips and tricks for thinking about it and starting working on architecture studies in complete peace of mind.

Target audience: beginners/intermediate

Une plateforme à concevoir, deux architectes: trois possibilités ? en fr

La conception d'une plateforme est toujours délicate à initier.

Comment démarrer? Quelle est la démarche à adopter pour concevoir une architecture? Quel est le modèle à appliquer: event streaming, orchestration ou chorégraphie?
Au travers d'un besoin utilisateur, nous prendrons notre "casquette" d'architecte et déroulerons devant vous une étude pour une toute nouvelle plateforme "Donut @ Home".

Après avoir analysé le besoin, confronté nos idées et convictions devant vous, nous choisirons, parmi toutes les solutions possibles, la *"moins pire"*.

Nous vous solliciterons pour valider notre conception et les exemples d'implémentation possibles.

A la fin de cette présentation, vous aurez des clés pour penser et démarrer les études de vos architectures en toute sérénité (ou presque).

REST APIs versioning Hands On! en fr

When we want to publish APIs, for instance using an API (Application Programmable Interface) Management solution, we regularly think about versioning.

This practice meets project management needs but brings a lot of complexity.
Imagine, you work on a platform which exposes APIs to many customers.

You must bring new features while controlling the existing ones.

How to deliver new functionalities to specific customers without affecting the others?

Throughout this workshop you will (re)discover and apply advice I have put in place and helped me during my last projects.

Through a real-life use case based on a microservices architecture, we will define the best strategy to put in place, the other potential ones and their constraints.

We will challenge them implementing new features for a new customer in this application.

At the end of this workshop, we will have the big picture and put into practice diverse ways of APIs versioning.

Workshop 2H up to 3H
Target audience: intermediate
The technical requirements are described on this page: https://github.com/alexandre-touret/rest-apis-versionning-workshop

Le versioning des APIs REST par la pratique en fr

Quand on souhaite publier des APIs avec par exemple, une solution d' API Management, on évoque régulièrement le versioning. Cette pratique répond à des contraintes projet mais apporte malheureusement son lot de complexité.

Imaginez, vous travaillez sur un produit qui expose des APIs à plusieurs clients. Vous devez leur proposer des évolutions et nouvelles fonctionnalités tout en maîtrisant l'existant.
Comment faire évoluer et proposer vos APIs à certains clients sans pénaliser les autres? Quelle stratégie adopter? Quelles solutions techniques peut-on mettre en place simplement?

Lors de cet atelier, vous (re)découvrirez et mettrez en pratique des conseils que j'ai pu mettre en oeuvre et qui m'ont aidé lors de mes derniers projets.

Au travers d'un cas concret basé sur une architecture microservices, nous définirons la stratégie à mettre en œuvre, les différentes possibilités d'implémentation ainsi que leurs contraintes.
Nous les challengerons ensuite en apportant différentes évolutions (ajout d'un nouveau client ou de nouvelles fonctionnalités).

A l’issue de cet atelier, nous aurons une vue complète et mis en pratique différentes manières d'appréhender le versioning d'APIs.

Type: Workshop (2H à 3H)
Audience: niveau intermédiare
Les pré-requis sont décrits sur le repo github :https://github.com/alexandre-touret/rest-apis-versionning-workshop