Speaker

Salomon Brys

Salomon Brys

Kodein Koders

Kodein Koders

Paris, France

Salomon is the creator and maintainer of the KODEIN multiplatform open source initiative as well as the founder of KODEIN Koders.
Deeply rooted in the Open-Source philosophy, he is dedicated to making tools and libraries to make programming easier, safer, and more exciting.
He is a Kotlin GDE, Kotlin certified trainer, Kotlin meetup Paris co-organiser, and conference speaker (you guessed it... about Kotlin!).
He also loves dancing Rock, playing boardgames, and flying small planes.

Salomon est le créateur et mainteneur du framework multi-plateformes KODEIN, et le fondateur de la société KODEIN Koders.
Profondément ancré dans la philosophie Open-Source, il se dédie à la création d'outils et de librairies pour rendre la programmation plus simple, sécurisée, et fun !
Il est Kotlin GDE, formateur certifié Kotlin, co-organisateur du meetup Kotlin Paris, et conférencier (vous l'aurez deviné... sur Kotlin !).
Il adore aussi danser le Rock, jouer à des jeux de société, et piloter des avions de loisirs.

Area of Expertise

  • Information & Communications Technology

Topics

  • Kotlin
  • Kotlin Coroutines
  • Kotlin/Native
  • Kotlin Multiplatform
  • Android
  • iOS

Sessions

Script your app : a new Scripting language for Kotlin/Multiplatform & the JVM en fr

There are many good reasons you may want to add a bit of scripting in your application : A-B testing, having configurable behaviour without having to update the entire app, allowing customisation, etc.
As of today, there is no scripting language that is compatible with all Kotlin/Multiplatform targets. So let me introduce you to a new Scripting language that works on the JVM as well as on each Kotlin/Multiplatform targets. It is tailor-made for Kotlin applications, uses coroutines by default, and is very simple to reason about and integrate.
In this presentation, I will introduce you to the concepts of KaMyPso language, and use a simple Compose Multiplatform application to show how you can integrate a simple scripting feature to a Kotlin/Multiplatform application.

Du script dans votre app : un nouveau langage de script pour Kotlin/Multiplatform & la JVM en fr

Il y a plusieurs bonnes raisons d'ajouter du Script dans votre application : A-B testing, pouvoir configurer le comportement sans avoir à mettre toute l'application à jour, permettre la personalisation, etc.
Il n'y a, aujourd'hui, pas de langage de script qui soit compatible avec toutes les plateformes de Kotlin/Multiplatform. Laissez moi donc vous proposer un nouveau qui fonctionne sur la JVM comme sur toutes les plateformes de Kotlin/Multiplatform. Il est fait sur-mesure pour les applications Kotlin, utilise les coroutines par défaut, et est très simple à comprendre et à intégrer.
Dans cette présentation, je vous présenterais les concepts du langage KaMyPso, et utiliserai une petite application Compose Multiplatform pour démontrer comment intégrer une fonctionnalité simple de scripting à une application Kotlin/Multiplatform.

Kotlin/Multiplatform for iOS developers : state & future. en fr

Kotlin/Multiplatform is very often seen by iOS developers as an additional pain point, rather than a productivity tool.
Let's go beyond the front line and try to understand this point of view. What can we do to ease their journey to using KMP, and facilitate their integration to our Kotlin/Multiplatform project?
We will explore the entire pipeline of integrating a KMP core into an iOS project: tooling, coding, building, deploying, integrating, and using. We will discuss the current limitations that KMP imposes on each step, and try to understand their consequences on the quality of life of an iOS developper.
Finally, we will show some tools and practices to alleviate these constraints & create a shared narrative with all platform developers, as well as discuss what's in the future of KMP for iOS.

Using C & native platforms in Kotlin : Building a multi-platform advanced library en

Kotlin/Multiplatform is an amazing tech which allows you to develop your business code once and deploy it to every mobile platform. However, to do things, you need to access APIs that are either provided by the platform in its native language (Obj-C, Swift) or as native libraries (C, C++, Rust).
In this live coding talk, we will see how to use different types of APIs in a Kotlin Multi-platform library that can be used on Kotlin/Multiplatform. Using Cryptography primitives as an excuse, we will see how to configure, compile, test and deploy a simple algorithmic library, and how to use it in a Kotlin/Multiplatform Mobile (KMM) project.
We will first demonstrate how to create a library with a native C dependency for the JVM, Android, Kotlin/Native & iOS, the Web, and more specifically to align JVM JNI, Kotlin/Native C-interop and JS WebAssembly.
Finally, we will explore how to use Swift iOS SDKs in conjunction with Kotlin Android SDKs to commonize advanced platform features, such as embedded cryptography.

Quick start native mobile Kotlin/Multiplatform setup en fr

Kotlin/Multiplatform is a complicated piece of tech! Because it chose to integrate inside native development tools & workflows, setting up a clean and shareable project can be complicated. Here's everything you need to set up a production ready architecture.
In this talk, we will explain how to architecture your code for a multi-platform mobile application, how to efficiently share business & behaviour code between your native apps, and how to configure each project (Common, Android & iOS) to link them to the business library.
We’ll discuss various patterns that we can use to standardise communication between the frontend (the UI) and the backend (the business logic) to ensure that the behaviour of our application remains strictly equivalent no matter the actual platform.
We’ll also show how to automatically test your common code, and how to deploy the various produced artifacts when working with application specific teams.

Let's compose this (web-based) presentation! en fr

Describe your UI for a given state and use events to update said state. This is, in a nutshell, the declarative UI pattern which “eliminates time” (think react, and of course Jetpack Compose). If we describe our application state to be “step X of slide Y”, then it’s easy to see how we can use the declarative pattern to create a web-based presentation framework.
In this live coding, we will first explain how JetBrains Compose for web works and how we can take full advantage of the Compose lingo we already use on Android to create reactive web apps in pure Kotlin.
From a single page, we will then create a presentation framework that takes advantage of the declarative paradigm with Compose for Web. We will describe our slides using our own Kotlin DSL and leave the transitions to the browser via CSS.
Each new slide will build on what we created for the previous one, until we have created a full declarative presentation framework, and a presentation declaring it!

Composons cette présentation (web) ! en fr

Décrivez votre UI en fonction d’un état donné et utilisez les événements pour changer le dit état. Voici, en substance, la description du pattern “Declarative UI” (pensez React, Vue, Svelte, etc.). Si nous définissons l’état de notre application comme “étape X de la slide Y”, il est alors facile de voir comment nous pouvons utiliser le pattern déclaratif pour créer un framework web de présentation.
Dans ce live coding, nous expliquerons d’abord comment fonctionne JetBrains Compose for web.
D’une simple page web, nous créerons alors un framework de présentation utilisant le paradigme déclaratif avec Compose for Web. Nous décrirons nos slides avec un DSL Kotlin maison et laisserons les transitions au navigateur via CSS. Chaque nouvelle slide utilisera ce que nous avons créé pour la précédente, jusqu’à ce que nous ayons créé un framework complet de présentation déclarative, et une présentation pour le déclarer !

Mise en place rapide pour les applications mobiles natives Kotlin/Multiplatform en fr

Kotlin/Multiplatform est un bout de technologie compliqué ! Parceque Kotlin a fait le choix de s'intégrer dans les outils & workflows natifs, mettre en place un projet propre et partageable peut s'avérer compliqué. Voici tout ce que vous avez besoin de savoir pour créer une architecture prête pour la production.
Dans cette présentation, nous expliquerons comment architecturer votre code pour une application mobile multi-plateformes, comment partager efficacement le code métier & comportemental entre vos apps natives, et comment configurer chaque projet (Commun, Android & iOS) pour utiliser la librairie business.
Nous discuterons des différens patterns que nous pouvons utiliser pour standardiser la communication entre le frontend (l'interface) et le backend (la logique métier) pour aussurer un comportement strictement similaire sur chaque plateforme.
Nous montrerons également comment automatiser les tests de votre code commun, et comment déployer les différents artéfacts produits lorsque vous travaillez avec des équipes spécifiques à chaque application.

Advanced multi-platform dependency injection en

Dependency Injection is a complicated topic, and when used in a project that compiles to multiple targets through different compilers & runtimes, it can lead to serious headaches. However, the Inversion of Control pattern brings a lot of architecture features and safety.
In this talk, we will see how to use all the power of Kodein-DI (a popular dependency injection framework that works everywhere Kotlin can compile to) in a mobile multi-platform project targeting Android through Kotlin/JVM, iOS through Kotlin/Native and the mobile Web through Kotlin/JS.
First, we will see how to use DI to abstract and test multi-platform business modules as well as how to debug common binding and retrieval errors. Next, we will abstract & test behaviour by embedding the DI framework into popular behaviour architecture patterns such as MVP & MVVM. Finally, we will enhance our code using the advanced features of Kodein-DI such as set bindings, lazy access, context and scopes.

A mirror without reflection for Kotlin/Multiplatform en

Reflection is a very powerful JVM feature that allows to create implementations of interfaces on the go, as well as exploring the type hierarchy, methods and properties of a given class.
These capabilities do not exist in Kotlin/Multiplatform, so we will explore an alternative method to runtime reflection: a compile-time symbol processor to create compile time mirrors.
Using Mocking as an excuse (as mocking typically needs reflection), we will explore how we can use KSP (Kotlin Symbol Processor) to circumvent the absence of reflection and generate efficient test mocks at compile time. We will also see the limitations that multiplatform brings to both the KSP generator and its associated runtime, and ee will explain the tradeoff that needs to be made when using KSP, and why they are needed.
Finally, we will demonstrate how to architecture all moving parts : the KSP plugin, Gradle Plugin, KSP generator & library runtime, so you can be ready to use KSP and create your own mirrors.

Let's compose this presentation! en fr

Compose Multiplatform allows you to create apps with UIs that run on a variety of platform. Its base pattern can be summarised as "for each state you define, there is a UI you can describe". If the state is {Slide,Step}, then this app can very easily describe a presentation. In this live-coding session, we will create on stage the presentation we will present!
We will start from a few simple slides with Compose for Desktop and then add more and more features to the presentation as we dive into Compose concepts (screen adaptation, animations, pre-loading, optimisations, quick navigation, etc.).
Each new slide will build on what we created for the previous one, until we have created a full declarative presentation, and a presentation to declare it!
As a presentation is always better when the audience can access it, we will then port it to the Web with Compose WASM.

Composons cette présentation ! en fr

Compose Multiplatform permet de créer des applications avec une UI qui fonctionne sur tout un ensemble de plateformes. Son pattern de base peut être ainsi résumé : "pour chaque état définit, il y a une UI qui peut être décrite". Si l'état est {Diapositive,Étape}, alors cette app peut simplement décrire une présentation. Dans cette session de live-coding, nous allons créer en directe la présentation que nous allons présenter !
Nous commencerons par quelques diapositives simples avec Compose Desktop puis nous ajouterons de plus en plus de fonctionnalités en explorant les concepts de Compose (Adaptation à l'écran, animations, pré-chargement, optimisations, navigation rapide, etc).
Chaque nouvelle diapo avancera sur les fondations de la précédente, jusqu'à ce que nous ayons une déclaration de présentation, et une présentation pour le déclarer !
Et puisqu'il est toujours mieux pour l'audience de pouvoir accéder directement à la présentation, nous la porterons au Web avec Compose WASM.

Kotlin/Multiplatform pour les développeurs iOS : maintenant & bientôt. en fr

Les développeurs iOS voient souvent Kotlin/Multiplatform comme une difficulté supplémentaire, bien loin d'un outil de productivité. Traversons la ligne de front et attachons nous à comprendre ce point de vue. Que pouvons-nous faire pour faciliter leur progression avec KMP, et faciliter leur intégration à notre projet Kotlin/Multiplatform ? Nous explorerons l'entièreté du processus d'intégration d'un coeur KMP dans un projet iOS : l'outillage, l'interface de programmation, la compilation, le déploiement, l'intégration, et l'utilisation. Nous discuterons des limitations que KMP impose actuellement à chaque étape, et tenterons de comprendre leurs conséquences sur la qualité de vie des développeurs iOS. Nous terminerons par montrer enfin quelques outils et bonnes pratiques qui permettent d'alléger ces contraintes et de créer une narration partagée avec les développeurs de toutes les plateformes, ainsi que par un aperçu de ce que le futur nous prépare pour KMP.

GDG DevFest UK & Ireland Sessionize Event

January 2022 London, United Kingdom

Advanced Technology Days 16 Sessionize Event

December 2021 Zagreb, Croatia

droidcon London 2021 Sessionize Event

October 2021 London, United Kingdom

droidcon Berlin 2021 Sessionize Event

October 2021 Berlin, Germany

KotlinConf 2019 Sessionize Event

December 2019 Copenhagen, Denmark

Salomon Brys

Kodein Koders

Paris, France

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