It was 2019 and nothing suggested that 2020 would not have been another regular year – another spring, another early bird ticket for the Lambda World conference, another regular summer, and then the most awaited conference of the year, a journey to Cadiz to attend Lambda World 2020.
Things went quite differently (for those reading from other planets – because of the pandemic) and the world was suddenly locked down, some conferences went online, and some were canceled, Lambda World included. Things went a bit better in 2021, but no news about a new edition of the functional programming conference. It was 2022, and many conferences had returned to the in-presence format, maybe with some precaution, but the worst part of the pandemic was finally over. Again no trace of Lambda World. 2023 came and went, and still no sign of lambda-life from Cadiz. Still vague or no answer to my emails to the organizing company.
And then suddenly and unexpectedly, the email popped up in my incoming folder – early bird ticket sale for Lambda World 2024 is open. I was so happy they were back, but at the same time I was about to change jobs and it was not the best approach to arrive on the first day at the new workplace and pretend to be sponsored to attend the conference. So, after a brief family check, I decided to self-sponsor my attendance and hope for at least some partial refund.
So, now that the conference is over, yours truly will write a detailed and opinionated report, using my tried and true format. Let’s start.
Demographic
This year Lambda World had an attendance of about 200 people. My subjective statistical eye would suggest that while still attended mostly by young people (let’s say below 30), there was a better age distribution than previous editions. I wasn’t the oldest attendee, and the over-50 group was quite populated.
It is difficult to assess inclusivity because my subjective statistical eye is, by definition, biased and can only be based on people’s look. Anyway, it was far from a male-only event. I’m not sure about the percentage of the computer science/software engineering population of non-white/caucasian people, but it looked a bit under-represented at the event. I don’t blame the organization, but it is a fact.
In the opening talk, the speaker called attendees country by country to stand up, shouting and making the lambda sign (raise your arm and bend left – or right for a mirror effect). It was a hilarious moment of aggregation and recognition. Unsurprisingly, most of the people were from Spain, with good numbers from the UK and Germany, but not so many from France. We were just two from Italy, but I wasn’t able to spot my compaesano because he was somewhere behind me. There were some people from Eastern Europe and one from Canada. It was an enjoyable moment, almost impossible to achieve with the 800 attendees of the previous edition.
Stands
There were 4 stands, quite animated on the conference day. The largest was Xebia’s (former 47 degrees) host and primary organizer of the Lambda World. Not so many swags and gadgets, but I believe this has to do with an improved awareness of the environmental impact of all those plastic gizmos that are extremely likely to end up in landfills. I got two T-shirts from UMATR, kudos. Being not too many attendees, there was a good chance to win the Xebia raffle… regretfully I didn’t. Otherwise, I would now be the happy owner of a Nintendo Switch. Penpot had a couple of games you could play – a Kahoot-like quiz on functional programming (easy questions, read speed was everything, I came out 12th), and “name this piece of OCaml code – wrong answers only” (my unsuccessful entry was “Please ChatGPT, tell me what this code does”).
JetBrains was present but mostly nominal. They promoted their Kotlin IDE, but they had no PC, video, or leaflet, just a person, some stickers, and pins. If they are pushing Kotlin, maybe the conference didn’t offer many interested attendees since, despite its functional potential, there was no talk on Kotlin.
Overall a nice and adequate sponsor presence.
Food & Location
The location is outstanding. Cadiz is a little gem on the Mediterranean Sea, with two castles, a huge cathedral, and it’s a pleasure to get lost in its narrow alleys, discover hidden squares, and rich palaces, and peek into entrances of houses with painted tiles, and iron gates.
Palacio de la Esposicion, where the conference is held, is no less. The central patio, with its glass roof and balconies, offers a stunning view. The building was not entirely used—just two auditorium-like rooms and three small rooms for the workshops.
Although the building is fully renovated, it lacks some power outlets in the sitting area. Having just 4 available outlets in a room with 200 people may leave more than one out of juice. Also, bathrooms were barely enough. Aside from these aspects, everything was great.
Food was a bit of a problem. Let’s start with coffee, I’m now used to the lack of an espresso machine at conferences. Considering that coffee and Italian Food, stand firmly at second place in the Italian pantheon, just below the almighty Football (or Soccer if you prefer), it’s sad. But, I’m digressing. At lambda world Cadiz there was a … ta-dah coffee machine. The first day it didn’t work. The second day it worked so I asked for an espresso and got one… But immediately, at the first sip, it felt so wrong – acid and … sparkling. No way for me to drink that stuff. Nonetheless, this seems to be an Italian-only problem, since at the closing talk, they asked if anyone disliked the coffee and it was just me and the other Italian who raised his hand (again I couldn’t see him).
And let’s get to food. The food was good and plenty, but the lack of trays or large dishes to accommodate food, forced the attendees to juggle with the glass and two or three pots. No major incidents because we are all skilled programmers, used to juggling bits and bytes.
To be honest, since there was plenty of food, you could take something repeatedly, but trays/dishes would have helped.
It wouldn’t have been bad the had been some more descriptive labels on food. Most of it was local specialties, so it was not immediate to understand how to mix them and what the ingredients were.
Workshops
Two days of the conference were devoted to workshops. Included with the conference ticket there were a few workshops, others were paid. The included ones were:
The paid ones were:
- Functional stream processing workshop: Supercharge your streams – Zainab Ali (7h30 350€)
- Implement your own Type Checker – Alejandro Serrano Mena (7h 150€)
- Embedding of Domain-Specific Languages in Scala – Juan Manuel Serrano Hidalgo (7h 150€)
Free workshops were:
- Scala Bridge – Zainab Ali, Noel Welsh (7h)
- Agda and Lean: functional programming meets proving – Juanjo Madrigal, Jorge Mayoral (4h)
- Tacit Programming in BQN, Kap, Uiua and APL – Conor Hoekstra (3h)
- Where Functional Programming Meets Array Thinking – Jesús López-González, Christian Aberturas (1h30)
- Structural Design with Alloy – Alcino Cunha (2h30)
- Arrow & Functional Kotlin Open Space – Alejandro Serrano Mena, Raúl Raja Martínez, Simon Vergauwen (2h20)
It has to be told that when buying the early bird ticket the conference schedule wasn’t defined yet. Possibly it was written somewhere, but it wasn’t clear to me that the first days would have been workshops, to be paid in addition to the conference ticket. Oblivious of this, I bought the airplane and booked the hotel considering all the 3 days of the conference. It was only on the evening of the last day before the conference that by looking at the agenda, I discovered that my workshop was in two days and also realized that the workshop I booked was “only” 1h30, leaving me too much idle time.
On the first day, I was able to work from the hotel (quite an expensive way to do remote working), next, I was lucky enough to swap workshops to attend the Agda and Lean presentations. Not only it did last longer, but also the topic was more useful for my job.
The workshop was split into two parts, each made by introducting to the topic with examples and explanations, followed by a few exercises available from GitHub. Being a workshop it hasn’t been recorded, so you’ll unlikely find it on YouTube along with the other talks of Lambda World. If I manage to find the time, I’ll prepare another post trying to unravel the presentations. Here I will write only that agda is a language supporting dependent data type that works mainly in the functional domain and can be used to build software with demonstrable properties. It is quite expensive to write software this way, but if you have a piece of code that must be correct, then this is the way to go.
The other language presented, lean, does more or less the same, in the logic programming domain. The speakers demoed the proof (mathematical proof) that merge sort uses fewer comparisons than insertion sort. I have sparse memories of my Prolog days but lean resonated quite a lot. Moreover lean has been designed inside Microsoft and it has outstanding support in Visual Studio Code. In the right pane, the IDE suggests what is missing and why something cannot be proven. It looked like really a next-level CASE tool.
Kudos to the two young speakers, for their technical proveness and mastery of the not easy topic, and for driving through the 4h workshop while providing an entertaining and thought-provoking experience. Bonus points for repeatedly answering my questions.
The only limitation to workshops of this kind is that as a complete newbie on the topic, the exercises were a bit over my head (be it the new syntax, the new concepts, or the new tools) so I ended up copying their solution. I need more time, but the subject is so interesting that I’ll try to put aside some spare time for further investigations.
Another workshop I didn’t attend but that looked very promising was the “Scala Bridge”. They proposed a set of software to develop and attendees grouped based on their interests. Each group had to create the software in Scala with the help and support of the workshop speakers.
Talks
Talks had the standard layout, a brief presentation of the speaker followed by about 50 minutes of stage time for the speaker, ending Q&A included. A convenient website provided a means to ask questions and vote for other people’s questions This was an excellent idea that allowed even the most shy attendees to ask questions and to remark points. The same website allowed for rating the talk on a 1 to 10 scale. I had some clumsiness problem in this part and I ended up rating just one speaker… feeling like a boomer.
Videos for each talk are being published on YouTube. Not every talk is already available, but you can find the link to those available right under the talk title.
Thursday Opening Keynote: The Butcherbird Combinator
by Chris Ford (Technical Director at Thoughtworks). Video.
I expected something else as the opening keynote of a functional programming conference. Not that this talk was uninteresting, quite the contrary – Chris showed the difference between the musical scale used by humans and the musical scale used by the butcherbird. The takeaway for the programmer was IMO marginal – the difference between etic and emic – and the idea that programmers should try to look at problems from other people’s points of view. It was not a bad or pointless talk, it just didn’t match my expectations.
Livebook: functional notebooks for AI and Web with Elixir
José Valim (Creator of the Elixir programming language). Video,
In this talk, José walked us through Livebook, a Jupyter-like notebook that uses Elixir instead of Python. Elixir is a functional programming language (based on the Erlang virtual machine), for this reason the code in the notebook always behaves the same way, regardless of the order of execution of the examples. I was very impressed by the automatic graphs that can be produced from the code such as the sequence diagram of two actors exchanging messages was really impressive.
Cracking the Code: Translating Japanese Numbers with Functional Programming
Kim Morgan (Scala Developer). VIdeo,
This talk was about a rewrite system developed to help translators do their job when translating dates and numbers from Japanese. Since there are a few different ways to express numbers and dates, translations may not always be obvious, also they tend to confound translation support systems (i.e. systems that help translators to do their job).
Kim explained the specificities of Japanese constructs for numbers (which somewhat resemble Roman numerals), and dates (which are complicated by the use of emperor eras), and then she turned to the technicalities of approaching the problem with Scala and how the rewrite system works.
Hooray for arrays
Stephen Taylor (Array Language Champion). Video.
Stephen presented the story behind APL and his creator, Kenneth Iverson. Stephen studied with Kenneth, so the history was first-hand and very accurate. APL was invented not as a programming language, but as a notation to process matrices and vectors. A concise and somewhat cryptic notation lets you express complex operations and seamlessly aggregate them.
Surely, APL is elegant and effective, but the funny symbols are impossible to decode without studying them. This approach resembles Haskell, which favors symbols, like >>=, over full names for operations. Possibly both languages stem from mathematics. Symbolic names offer a gentler introduction, but I’m digressing.
The talk presented the language via some examples of operators and their combination. This language surely intrigues me, but the use of dedicated symbol as operators makes the learning curve even steeper and discourage me. Moreover, the overly compact syntax of the language worries me that this could a write-only language – once you master it, you can quickly write your ideas, but later you can have a hard time to reconstruct the meaning of your work. BTW my closer encounters with APL were owning an APL interpreter disk for my Amiga (1988) and working on an IBM PC XT with an APL keyboard (1991). So, maybe the time has come for trying again.
I really appreciated the closing part, when Stephen talked about the climate change crisis. This is something very urgent, happening now, and as unrelated as it may seem to a functional programming conference, it is very related to everything we do and should be really much more in focus than actually it is. Preparing for the change to come, and devising resilience strategies is what is going to help us. Plaese, have a look at his site: https://alreadyhere.uk/.
Resilient REST APIs: The Case for Parallel Change
Abby Sassel (Haskell Engineer at Artificial). Video.
When you operate an API, you’ll find sooner or later that it needs to evolve and that it is not always possible to evolve it in a backward-compatible way. Abby describes the alternatives – you can version the API, or each API call. But these approaches don’t motivate clients to upgrade and force you to support old and new APIs at the same time.
The proposed approach is adding new features alongside existing ones, in an expansion phase. For a while the previous API is still supported. After a reasonable time, all the clients will be able to migrate, and the API can be shrink to include only to the new interface.
Concrete Functional Programming
Kamila Szewczyk (Student at Saarland University). Video
Kamila stands out from the crowd of speakers for many reasons – first, she’s very young (in her 20s!), and then she’s remarkably tall. But when she starts talking you understand she’s from another planet. She wrote a LISP interpreter… when she was 15… in malbolge. And if this progression doesn’t leave you astonished I don’t know what could.
Her talk was on the many technologies pioneered by functional programming (which she employed in her KamilaLISP – another LISP interpreter, not written in malbolge this time) – garbage collectors, immutable data types, linear types, and so on.
An Imperishable Wonderland of Infinite Fun
Will Byrd. Video.
Functional programming is gaining traction and becoming accepted in most mainstream languages. So, what’s next? In this talk, Will explores the logic programming paradigm. Logic programming is about relationships and finding answers to queries on those relationships. The wow effect comes at the end of the talk, when Will shows how this can be applied to functional source code and logic programming may provide missing pieces in your code.
Rethinking Effects with Effect Systems
Noel Welsh (Developer at Inner Product and Underscore). Video
Noel walks us into the functional programming and the motivation for effect systems. Functional Programming is a sound engineering approach to compose complex functions from simple building blocks in an easily understandable way, thanks to local reasoning.
Now pure FP is useful (but for heating the room), since effects are needed at least to give inputs to the algorithm and capture outputs. Monadic approach helps you to chain effects together, but it is not easy and require special syntax (for comprehension or do notation) to be used effectively.
Effect systems, though still a subject of research, offer a way around this, allowing the programmer to write imperative-like code, and managing effects in a decoupled way.
Liquid Haskell: Verification with Refinement Types
Niki Vazou (Research Associate Professor at IMDEA & Haskell Enthusiast). Video
A deep dive into refinement types (types with validation predicates) with lots of examples in Haskell. Liquid Haskell is a tool for program verification using… refinement types. Interestingly refinement types are integrated with the type system, so the verification happens at compile time. Regretfully Haskell syntax proves to be impervious to understanding from those who do not know the language.
Functional effects in perspective
Vitaly Bragilevsky (Developer Advocate at JetBrains). Video.
Despite the title, Vitaly doesn’t explain what effect systems are in this talk, instead he goes a bit into the history of the concept and then tries to understand what programmers need and what computer languages can provide.
Effects are not new, appearing for the first time in 1992. Along the way, it got overtaken by the moand concept to handle effectful computation (such as I/O, async/concurrency/coroutine, exceptions, and non-determinism). Although powerful monads are not problem-free – they do not compose (in the functional sense, you can chain them, but that is not composition). Worse, to be effective, monads require language support (Haskell do-notation or Scala for-comprehension).
My take – Are monads becoming a thing of the past?1 Maybe, but this does not mean that Option, Either, and List are useless
Closing Keynote: Concurrency-Oriented Software
Robert Virding (Principal Language Expert at Erlang Solutions). Video.
The closing keynote was another blast. Robert is one of the designers of the Erlang language and he offered his unique perspective on the language’s genesis and evolution comparing with other approaches to concurrency and other languages.
One of the best takeaways from his talk was the quote: “Any sufficient complicated concurrent program in another language contains an ad hoc informally-specified, bug-ridden, slow implementation of half of Erlang“
Indeed Erlang stays almost unrivaled (but, possibly, for its evolution Elixir) in a niche for system and concurrent programming. This language pioneered the ideas in the reactive manifesto in advance by at least 15 years. The Erlang process is a lightweight construct (a message-passing actor). You can have plenty of these, in the order of millions and more without any significant overhead. There is no shared state and no locks. Also, there are no types.
Robert gave me a strong motivation to learn Erlang, hampered only by tha lack of static typing in the language.
Personal Thoughts
I was very happy to attend Lambda World 2024 and relieved that the conference, despite the long pause from the previous edition, staid true to its origin of a good blend of industry and academy talks focused on the many faces of the functional programming. Something has changed though, Lambda World is now organized by Xebia (former 47 degrees) and Jorge Galindo, the man who was the soul of the previous editions2 is now pursuing his career path outside Xebia. Maybe it was just my impression, but it felt like the conference organization was reset (which was not, because many people in the organization were also at previous editions) and restarted, looking a bit (just a bit) lost, without the full self-confidence needed to run the show at its fullest. Running a conference is not an easy endeavor and I’m sure the success of this edition will give them full entry for next Lambda World. BTW a welcome change is that next year dates for the conference have been already announced in the closing speeches. October 22-24, 2025, mark them on you calendar.
As in the previous editions, I came back with a long list of stuff I don’t know about and an equally long list of things to study and investigate. I think this is a good result and worth my personal investment in the conference3. Being aware of the things you don’t know about it is a good starting point, and having tags for such things about what they are and what they would allow you to achieve is key for growing your skills and experience. Knowing this would help you to locate where you are on your road to mastery and where to go next. Here what is in my list, after the conference days –
- learn Erlang, APL, Elixir, Malbolge
- better understand Agda e Lean
- understand effect systems
Now it is just a matter of keeping up with the good deeds.
- If true it would be ironic that C++ is starting to get (in a very C++ peculiar way, of course) the importance of monads only now. ↩︎