Talks

A tour of distributed auth patterns, the associated challenges and how biscuit makes things easier

Read (in english 🇬🇧) || Regarder 📹 (en français 🇫🇷)

The `traverse` function is so pervasive in functional programming that it became a joke: `traverse` is the new `42`. Since it's a bit abstract until you actually encounter it, let's dig a little and review some case where… well, it was _actually_ `traverse`.

Read (in english 🇬🇧, at DDDDD) || Read (in english 🇬🇧, at LambdaLille) || Regarder 📹 (en français 🇫🇷, à LambdaLille) || Watch 📹 (in english 🇬🇧, at DDDDD)

Functional Programming is often seen as a nice tool for small-scale concerns, not as a tool for application design. However, functional programming comes with interesting tools aimed at solving these boring (or deemed boring) concerns: dependency inversion, observability).A functional solution, called a monad stack, allows to combine all this cross-cutting concerns and behaviours with no magic (or not too much). Let's see how it works and how it relates to the current "Tagless Final" trend

Lire (en français 🇫🇷) || Watch 📹 (in english 🇬🇧)

Config files are getting bigger and bigger. Config languages are limited (by design). Using a general purpose language for config looks like a good idea but has severe drawbacks. Dhall is designed to bring flexibility and abstraction to config, while keeping key properties.

Read (in english 🇬🇧) || Watch 📹 (in english 🇬🇧)

Spinning up dev environments got incredibly complex. We now cheat by using containers or VMs, but these are extremely heavyweight solutions.We only care about the easy way to run software, not about the runtime isolation. Thankfully, there is nix, that does just that: allowing us to run software on your machine without trashing your global environment.

Read (in english 🇬🇧) || Regarder 📹 (en français 🇫🇷)

Servant allows you to describe and build web API is a type-safe and composable way. It also provides a powerful way to structure your applications by letting you choose a monad stack, either for the whole API or for specific parts of it. This mechanism, called `hoistServer` can be used eg. for dependency injection as well as access control.

Read (in english 🇬🇧)

Test-Driven Development is widely accepted as good practice. But can we do better? By specifying your program's behaviour with types, you can go a very long way, with more confidence and with less hassle than with tests.

Read (in english 🇬🇧) || Regarder 📹 (en français 🇫🇷) || Watch 📹 (in english 🇬🇧)

"Tools not rules". A process without a tool to guide is mistakes waiting to happen.

Read (in english 🇬🇧) || Regarder 📹 (en français 🇫🇷)

Get consistency back in your μServices architecture: the best way to reduce complexity in a μServices architecture is to embrace boundaries. You'll see how to do it with the help of proper design and a good type system.

Read (in english 🇬🇧) || Regarder 📹 (en français 🇫🇷) || Watch 📹 (in english 🇬🇧)

Haskell is trendy, but too often for side-projects. At Fretlink, they put haskell in production, on real projects.

Read (in english 🇬🇧) || Regarder 📹 (en français 🇫🇷)

Something strange happened at Clever Cloud: everybody has started using rust, little by little. Many greenfield projects are using rust. That's not to say we've stopped using scala, java, or ruby (and even a bit of go and haskell). As a CTO, how do I keep complexity and language diversity in check? How do I choose which language to use for projects? Do I let others choose?

Lire (en français 🇫🇷) || Regarder 📹 (en français 🇫🇷)

Dans le monde du compile-to-js, il y a des langages proches (genre coffeescript), et des langages qui vont un peu plus loin (genre typescript). Et puis il y a purescript. Ce soir, on verra le pourquoi et le comment, avec la bibliothèque halogen, qui permet de créer des applications/interface graphiques.

Read (in english 🇬🇧)

As domain driven design practitioners, we have to design datastructures a lot. Often we have to encode our knowledge into a not-so-expressive type system. That's when the trouble starts: our types don't represent exactly what we have.

Read (in english 🇬🇧) || Watch 📹 (in english 🇬🇧)

React and flux have shown us how to design UI in a modular fashion. One of the core ideas, is that data should always flow in one direction. With this concept, it's easier to build applications from independent modules. I'll show what react core concepts are and how they allow developers to manage complexity in big applications.

Read (in english 🇬🇧) || Watch 📹 (in english 🇬🇧)

Scala, by being both Functional and Object-Oriented is easy to get started with, especially for java developpers. However, to get the most of the language, you have to embrace its functional nature.

Read (in english 🇬🇧) || Watch 📹 (in english 🇬🇧)

It can be usual for software developers to let the ORM take care of the database schema. In many cases it's a bad idea as it makes the data stored in your database brittle and hard to use confidently. I'll show a few tricks which will help you cleanly store and query data by using your database engine to its full power.

Read (in english 🇬🇧) || Regarder 📹 (en français 🇫🇷)

Backend programming sounds hard. But we all know what really strikes fear in the hearts of backend devs: CSS. Building a simple page layout is a daunting task: you need to juggle with floats, margins and all that sort of things. But what if I told you handling layout in CSS has improved dramatically? Or, Djikstra forbid, that it's now kind of easy? Let's see what we can do with flexbox and grid; I promise you you won't be scared of CSS layout anymore.