Two weeks after the Devfest Toulouse, I was in Cádiz to attend 𝛌World. It is a conference focused on Functional Programming. It was composed of two days, one mostly dedicated to workshops while the second one was only about talks. For my first time there, the least I can say is that it fulfilled my expectations: a language agnostic conference with high quality talks in a friendly atmosphere. Here are some highlights.

Content

In the quest of purely functional programming, I watched several talks from past editions of Lambda World  on Youtube. I found, because of the diversity of the talks and the language agnostic thing, that the conference allows to abstract, and ease reasoning on the concept level instead of the language level. I mean, a lot of talks were in fact about the Math which serves as the foundations in Functional Programming.

So, the conference started with an unconference. The first talk, about Agda, made me think a lot about Idris. Then came a short introduction to Bow the Swift brother of Arrow, a return of experience on FP in the field, and an introduction to ReasonML. I especially liked the return of experience, where the presenter explained that in his project, he had to deal with a lot of legacy code (in C++) and he came up with a: "wrap the crap" strategy to deal with it. These short talks were not in-depth talks, but were good to see what could be interesting to dig later.

Then I followed a workshop on ZIO lead by John De Goes. We did a web crawler in Scala using ZIO. The schedule was unfortunately too tight to make it really interesting but the exercise was a good start to use ZIO. The entire workshop can be found here.

The first day ended with a keynote by Martin Odersky, the creator of Scala. His speech was titled "Implicits revisited". He gave a retrospective history of how and why the Scala team created implicits in the first place, then shared his thoughts about the good parts, and well, the less good ones. As a Scala developer, this keynote was important for several reasons. The first one, beeing to understand the language better, and the second one, to get a view of the future. About the past, Martin explained how implicits were born as an "automatic conversion mechanism". To better quote him :

Given a class C, and a trait T, how do we make C extend T after the fact ? Without changing the code of C.

Very soon (this presentation by Odersky, in 2006) typeclasses were coined in Scala, and implicits were a key feature to reduce the boilerplate with implicit parameters. And today, in order to fix the problems with "implicits", Martin highligths the flaws made in designing implicits:‌

• implicits resolution depends on names
• nesting does not matter
• similar syntax for different concepts
• implicit parameters are located as normal parameters
• implicit scope is hard to grasp

In order to solve this, Scala 3 brings a whole set of new keywords and syntax to clearly identify Typeclasses and instances. The documentation explains it very well and this keynote made me want to try it.  The talk ended with the inevitable question of the transition from Scala 2 to Scala 3 on this aspect. This is solved by a compatibility through the Scala 3.0 where given clauses will also generate legacy implicits.

Day 2 started with a keynote by Emily Riehl. As a category theorist, she shares with the audience a "Categorical view of Computational effects". For a complete thread about this talk:

While the first part of the talk was understandable by anyone into FP, the second part was much harder to grasp! But it is also why this kind of talk is important: to keep having an horizon of things to learn.

After this keynote, I attended a talk by Aditya Siram about static introspection at compile time. In this talk we went through Nim and D, which are languages supporting static introspection. In Nim and D, you can write functions whose execution happen at compile time. You can even share code between compile time and runtime. There are usecases for this (and a field for experiments, to find more), and in the end, it is up to the developper to choose between pre-computation (at compile time) with increesed binary size and runtime  computation with a slower application but a lighter binary. As stated in his talk, there is much to learn from these techniques. From a Scala developer point of view, for one part, it made me think bout macros and automatic instance derivation for typeclasses. Yet, Nim provides much more power, allowing at compile time to run almost everything... I also thought about refined types even if I am not sure why...

As an Arrow user (well, not so much since I mainly write code in Scala), I could not miss Raúl & Simon's talk. Arrow is a (damn awesome !) library to ease functional programming in Kotlin. The topic was specifically Arrow Meta, which is a compiler plugin to make Kotlin better. The aim is to bring a lot of features to the language. For example, union types. Arrow Meta allows to rewrite code at compile time. In Arrow, this will be useful for typeclass derivation, support for Higher Kinded Types, ... Even tooling will benefit from this project ! The end of the talk showed  the spirit behind Arrow: a vibrant community of nice people. If you are new into FP, this community is ready to share and will improve your FP game.

Every FP conference should have a talk about Recursion Schemes. Lambda World made no exception. And Harold Carr introduced the recursion zoo with Haskell examples. A good lesson to think about the nature of our algorithms. As I am not confortable with the topic, I won't say much more.

Then, it was time to hear April Gonçalves for a mathematical refactoring of code. They talked about how equational reasoning (thank you referential transparency !) can help to reduce the complexity of an algorithm. The presentation was straight forward but I clearly need to go through it one more time with a coding example, to apply the refactorings made in the talk. Also, I need to do it in Scala !

After lunchbreak, I attended a talk by Marco Perone about Category Theory. The point of the talk was to show how to encode Category Theory concepts in Idris. Having done a bit of Idris for fun months ago, I was able to follow right from the start. Marco shows how Idris allows safer programming through dependent types and stronger typing. Through the example of a function returning the head of a list, he highlights the differences between Haskell & Idris. He gives a quick definition of what a category is:  

very abstract concept [...], think of a category as a context for some kind of information [...] the first constitute of a category are objects. Objects in the abstract are just dots [...], but we can interpret that with our model as pieces of information, as chunks of knowledge

From that definition, Marco goes to a live coding session to encode this concept in Idris : A Category is just a record with one field object which is of type Type. The next concept in Category Theory are morphisms:

which are just arrows between dots, if we interpret that in our mental domain, [...] morphisms are connections between information, they are kinda a way to go from one information to another

Then, Marco add this concept to the previously coded definition of a Category in Idris. After that, he adds the rules of composition, to combine two consecutive morphisms to build a new one. The talk goes on with the identity morphism and soon we are reaching associativity. After all this, Marco talks about functors:

A way of mapping between categories in such a way that we preserve the structure which exists in a category.

The talk goes on with the implementation of Functor in Idris. The talk ends with a demo to show how the concepts previously presented can be applied to model some kind of e-commerce flow. I found this talk interesting because it both showed how Idris & Category Theory can be used to solve real world problems. We had a nice overview of how it feels like to code in Idris.

Before the final keynote, I attended a talk by Robert M. Avram. It was more a show than a talk. The point was to tell the story of all the tentatives functional developpers went through to deal with side-effects. From the concept of monads, to free monads and interpreters, the tale was nice. It is the kind of talks which are really entertaining, and I enjoyed the show. It reminded me of this blog post which explains, in Scala the long and slow maturation of how we deal with effects.

The ending keynote was something I did not expect at all. While very interesting in the begining, with a colorful definition of what a data scientist is, and a nice story, I found the political message behind it a bit misplaced (while I may be agree with it).

Logistics

It is hard to talk about 𝛌World without talking about Cádiz, and the amazing team behind the scene. The venue is just fantastic: well located and beautiful, in a city full of things to enjoy: from the food to history, to, just the beauty of the city.

The buffet contained everything for vegans & vegetarians, and by a lot of little things, I saw that the staff cared a lot about diversity, and the well being of everybody. As Jorge Galindo says, Lambda world is Family : there is a nurcery for children, activities offererd to your relatives so that they also feel welcome.

I met nice and interesting people from all around the world (well, mostly Europe). I had the chance to see some arrow contributors and users. The ambiance was chill and relaxed in the warm sun of Cádiz.

It was the first time I attended such a conference and for sure, I will come back if I can. When the feedback form arrived in my Inbox, I had a hard time to figure out what they could improve. So thanks again to the staff for this grat conference& see you soon Lambda World !