As promised last year in Cadiz by the Yay Yay people, Lambda World returned for a 2025 edition. Going to Cadiz is a sort of pilgrimage in itself – wake up at an ungodly time in the night, no direct flight, endless wait in airports, train, and eventually some vigorous walk on the cobblestone alleys in the old town. Once at the conference, pilgrims listen to the words of FP gods… or something like that. Totally worth it, but after a journey like this, you may well have mystical visions.

Cadiz is as awesome as I remembered, and the weather was still late summerish, a pleasant break from the early winter temperature and clouds I experienced at home.

The conference lasted two days, fully packed with information, so it is time to start with yours truly detailed and opinionated report. Get ready for the Maxpagani.org Conference Report Template™.

Demographic

Despite the organization’s higher expectations, this year’s conference was attended by approximately 200 people, about the same attendance as last year. I hadn’t noticed any change in the attendance composition with respect to gender, age, or origin. More or less the same assorted bunch of people, young and “mostly” young (like me). All friendly and welcoming, as you would expect at this kind of conference.

Origin countries, as determined by the “lambda move” count (all those from Elbonia do the lambda move now to the left, now to the right!), were sparse from all over the world, from the far east to the far west (but actually no one from Elbonia).

Stands / Sponsors

There were 3 booths on the conference day. That’s not much; I would have expected at least twice as much. Notably absent was Xebia, formerly 47 degrees, the company that started Lambda World years ago.

JetBrains was there to promote its impressive suite of IDEs and dev tools. Quite surprisingly, I found the other main booth was Prima‘s. I discovered this Italian insurance company last year because they hosted a couple of C++ meetups (1, 2, and 3) organized by the Italian C++ community. In Cadiz, I found that Prima’s internal development mainly happens in Elixir, Rust, and Python. Glad to see they are willing to sponsor the developer community in various ways.

The third booth was Predictable Machines, a company co-founded by Jorge Galindo, who led 47 degrees and was the relentless soul of pre-COVID Lambda Worlds. While the other two stands were always crewed, this one was almost always unattended (or maybe it was when I passed by, which happened a few times in the day).

This year, sponsor T-Shirts were remarkable for their absence, another couple of conference like this and I would have to actually buy T-Shirts!

Food & Location

I can’t think of a better location for this conference. Cadiz really shines, and downtown is utterly enjoyable. Being the fifth time I describe this little wonder, I can’t add much, just quote what I wrote last year:

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.

Mistake aside (actually, Cadiz is on the Atlantic Ocean, not the Mediterranean), I can’t agree more with my past self.

The conference took place in Palacio de Congresos as usual. This premise is a renovated tobacco factory, in Neo-Mudéjar style (I know because I read it right now). The conference used three classroom-like rooms for the workshops on the first day and two auditoriums for the parallel tracks on the second day.

The Palacio has a large area at ground level that provides the canteen space during the conference. The internal patio

Power outlets were not a problem on the workshop day (multiple power strips were available in the classrooms). At the same time, it was a problem on the conference day – the auditorium had barely any electrical outlets, leaving you with the option of letting your laptop charge unattended in a classroom (which were open), or leaving the laptop doze and taking notes on the phone (which I did).

As if someone had read my complaints about the past year, this year we had convenient trays to carry food around and reach a table, without the need for a third or fourth hand. A helpful menu note was distributed to all attendees while they were queuing up for food. There you could read what to expect. Also food was conveniently boxed in a small bin. This helped to avoid waste.

Waste boxes were conveniently spread around the room. No wine this year, but plenty of beverages, beers included.

And last, the sore point… coffee. Last year, I loudly complained about coffee. The complaint was so loud that even conference organizers noticed. And they publicly mocked me during the opening talk!

It was an hilarious moment and I fully enjoyed my 2 minutes of fame in a world-class FP conference without being an FP guru!

Anyway, the coffee machine and its operator were the same as they had been in the past year. I attempted to find an improvement, but with little success.

On day 2, I gave the guy a second opportunity, but this time I asked him to add milk. In Italy, (we are picky on this, I know) “caffè macchiato” and “cappuccino” are very different things – in size, milk percentage, and purpose (at the end of the lunch, it is perfectly fine to have a “caffè macchiato”, while it is totally unacceptable to have a “cappuccino”). Nonetheless, the coffee machine operator masterfully crafted a good-looking foam art and actually a good-tasting cappuccino. Noted for next year.

I tried to have another one mid-afternoon (being a cappuccino still quite acceptable for the afternoon break), but the guy was nowhere to be found, I hope he didn’t take my past year review as an offense.

Workshops

The workshop schema was much like the past edition – some were included with the conference ticket, some were extra.

Given that my budget runs on a shoestring, I attended the free ones. The layout on the subscription page was not optimal, and I missed that most of the workshop ran all morning, while two of them were half morning each. Of course, I registered for only the second of them, and I had to enter the wait list for the first one.

I take the chance to praise the organization. They managed everything with great care and empathy. Even if the workshop was fully booked, they managed to get me in.

So, Kotlin workshop. These two were hands-on workshops. A list of prerequisites to prepare the laptop was sent to everyone attending.

What was missing in the list was the GitHub repository where to collect the code to work on (this one and this one). Entering the room last due to the waiting list, I found myself unable to see the Wi-Fi password on the registration card¹, trying to read the GitHub URL from my neighbor’s screen. This is why I lost some precious time and missed some introductory explanations for the exercises.

First workshop title was “Crafting elegant DSL in Kotlin”, by Simon Vergauwen.

The running example was a DSL for describing HTML documents. If you have ever written code to generate HTML without using specific libraries or language support, you know that this is quite a tedious endeavor. You need to double-check that the HTML structure is correct, but you don’t have any support from the type system since everything is concatenated into a string.

The workshop presented a way to use the Kotlin type system to support a DSL for this purpose, making it easy to write code like:

html {
    body {
        a("https://kotlinlang.org") {
            target = ATarget.blank
            +"Main site"
        }
    }
}

Kotlin supports DSLs in a way similar to Scala – expressions and optional parentheses make it easy to define custom declarative languages. There is also a mechanism similar to Scala’s implicit, called receiver, to let inner code access outer scope values in a controlled way.

I got lost somewhere in the exercise, but that’s my fault. The presenter was absolutely clear. I should have prepared better.

Takeaways –

• extension function – you can add methods to an existing class (without the need for an implicit class, as it happens in Scala)
• Kotlin TODO() is the equivalent of Scala ???.
• Nullable values are postfixed with a question mark, and they work much like an Option in Scala.

The second workshop of the morning “Pure Functions, Powerful Effects” by Alejandro Serrano, was on effects and how Kotlin supports them.

The presentation was intriguing, with a clear motivation for exposing the side effects of a function in the function signature and having them enforced by the type system. Also, the language provides some effects but not a uniform syntax for them. Once more, I managed to get lost in the code assignment.

Having the option to familiarize myself with the concepts and the Kotlin syntax would have definitely helped me to stay on track.

The workshop in the afternoon “Which [X] Are You? Vector Similarity in Rust with Axum and SurrealDB” by Caroline Morton, was on Rust, and it really stood out. Possibly also because I am a little more familiar with Rust than Kotlin. This is the workshop repository.

What I really liked about this workshop was that it was well laid out, and exercises were self-contained, so you always started from a code that compiled, and you performed the exercise there. This avoided the frequent workshop problem of incremental assignment – where you have to work and the previous step, and if you didn’t manage to complete or understand, then the workshop is gone.

The topic in Caroline’s workshop was using Rust to implement a web service that operated a vector database. This also made me discover vector database (in this case SurrealDB), i.e. database capable of storing vectors with high number of dimensions and computing operations on such vectors, such as ordering vectors in the db by distance from a given one.

First Day Talks

This year’s talks had no speaker introduction. This doesn’t spoil the experience, anyway; most of the speakers already introduce themselves in the first slides. Each talk lasted about 40-50 minutes, leaving enough time to switch tracks, for a drink, or a quick stop at the loo.

As for the past edition, Q&As were handled by the Vevox website; attendees could type in their questions and vote for those by other attendees, and the top-voted question chart was displayed on the conference screen. It worked; they kept it.

All talks were filmed and their videos have been published on YouTube, but most will be available only to paid subscribers (or those who bought the conference ticket). This is a way to support the conference. If you love Lambda World or Functional Programming Conferences, consider contributing by subscribing to the channel.

Nobody told me, but I expect those videos could go free in the future. It would make sense.

Thursday Opening Talk – Starship Enterprise – Functional Programming at Huge Companies

by Jack Higgs – Director of Software Engineering at JPMorganChase. Slides. Video (subscribers only).

I found this talk a bit confusing. The goal was to make a point on how to introduce FP in large companies and what its advantages are, specifically for this context. So a talk on strategies, how to present the Return on Investment, how to onboard your colleagues, and so on. Instead, there was quite a lot of coding, and the most strategic parts were confined to the end of the talk, without including practical advice.

Not a bad talk, but split between coding and advocacy.

Thursday Non-Profit Talk – Margaret Hamilton Foundation

by Jorge Galindo – Co-founder at Predictable Machines. Video (free).

The final talk of the day was on a local non-profit initiative by Jorge Galindo (the guy behind Lambda World before the pandemic, Xebia (former 47 Degrees), and now Predictable Machines).

The initiative, named after Margaret Hamilton, aims to provide STEM (and software development) exposure and training to children at an early age before the gender bias kicks in, preventing females from developing an interest in computers and computer science.

Surely the presentation strikes some chords, and I am totally sympathetic with Jorge and applaud this initiative. Given that last year this talk was about Médecins Sans Frontières, I would have expected something more global (Greenpeace, Extinction Rebellion, …), so that even non-Spanish people could get in touch once at home.

Nonetheless, kudos to Jorge!

Second Day – Talks

From Lambda to LLMs

by Anurag Mendhekar – Tech Entrepreneur, Author, and Software Artist. Slides. Video (free).

I deeply enjoyed this talk presenting the perspective of programming in general and functional programming in particular as a profession in the future years. Programmers benefitted from collective intelligence via web search first and stack overflow later, but now collective intelligence is writing your code thanks to AI and LLM.

Is this a fad that will go away in a few years, much like bubbles and buzzwords of the past, or is it a paradigm shift like the one that sent public phones or punchcard operators the way of the dodo?

Anurag has no doubts – AI will improve to the point that it can be replace most of the programmer’s job and there won’t be any regulation from the governments, nor any union from the programmers that will protect this profession from extinction.

What is the future for programmers? According to the speaker, programmers should refocus on acquiring system-wide competencies to be able to direct the AI to write a sound software system. Another area that will emerge and functional programmers are in a favored position is formal verification. Today AI writes code, but we have no proof that such a code does what we expect. We need a way to prove that code is not harmful, nor defective. Functional languages such as Agda or Lean are in the forefront of this endeavor.

This is an interesting perspective, is a credible prediction? The only problem I saw in Anurag’s presentation was to take numbers from Microsoft and Github. These companies have a vested interested in showing that you can buy AI instead of programmers time, so maybe the numbers are a little biased.

Anyway it is true that computer and software performances steadily advances more than linearly. So it is quite likely that five – ten years from now, LLM will be able to generate a sound software. I witnessed some vibecoding myself and was pretty impressed. I had to guide the AI with a close supervision, but I got the requested application, with all the technical features I specified.

I am uncertain if this is a future I like. I mean, I enjoy coding – the pleasure coming from analyzing and decomposing, clamping together basic pieces to implement a complex behavior or to solve a daunting problem. It is also true that it takes time and often you would like a function or an application, but you don’t have the time or don’t want to learn and apply new technologies.

Anyway according to the presentation, today 25% of new code is AI generated and 72% of developers favor AI tools, and 49% of them (developers, not tools) believe that they will be replaced by AI in five years. The caveat on these numbers holds.

AEON – AI-native programming language

Alcides Fonseca – associate professor at the University of Lisbon. video (subscribers only).

In this talk, Alcides demonstrates how to utilize AEON language to constrain AI results and verify their correctness. AEON allows programmers to define refinement types (although AOEN uses the Haskell jargon and calls them Liquid Types).

I found refinement types a brilliant idea (I even gave a talk on how to replace assertions with refined types in C++), and using them to validate LLM responses is a sound application.

I got a bit lost when Alcides introduced Satisfiable Modulo Theories (SMT), which is an NP-hard problem. A rough description of SMT is a class of algorithms that, given a set of relations, attempts to find the values that satisfy those relationships.

Accidental Functional Programming in Rust

Caroline Morton – Founder of Clinical Metrics | Software Engineer | Epidemiologist | GP. video (members only).

Caroline held the Rust workshop on the previous day and presented her experience with Rust in handling epidemiology data sets.

Epidemiology data is collected from the field with a wide variety of means and results. Mainly, it comes from doctors who fill in forms. These data are usually messy and filled with null or NaN fields. Once the data are cleaned, they are passed to R, Stata, or Python applications for analysis and synthesis.

Doctors use code to report symptoms and illnesses. There are 10k or more codes. Just imagine that the cough alone has 45 different codes for each kind of cough.

Caroline shows how functional features of Rust helped her and her team to process and validate epidemiology data. And more precisely –

Optional and Result types. E.g.

let codes: Vec<&str> = raw_codes
  .iter()
  .map( |c| c.trim() )
  .filter( |c| !c.is_empty() )
  .filter(|c| validate_code(c).is_ok() )

Enums and pattern matching allow for encoding errors and codes, and trigger actions on them.

match validator.validate_code(code) {
    Ok(_) => // valid code
    Err(CodeListValidationError::InvalidCodeLength {..}) => {
        ...
    }
    Err(CodeListValidationError::InvalidCodeContents(..)) )> {
        ...
    }
    Err(e) => {
         ...
    }
}

This talk was very practical. Functional programming is somewhat accidental, meaning that if you are looking for category theory or advanced algebra, this is not for you. This is more for traditional programmers who want to explore Rust and check what it is in for them.

Prompting safety

Ignacio Gallego Sagastume – Software Engineer @ Hivemind Technologies, Isaia Bartelborth – Principal Software Engineer at Hivemind Technologies. slides. video (members only).

More and more services are relying on LLM via prompt. In other words, some free text input is sent to the LLM to generate a response. Much like SQL injection, prompt injection could happen and expose sensitive or private data.

To prevent this unfortunate situation, Ignacio and Isaia present a DSL that frames the prompt in such a way that only a controlled prompt can be submitted to the AI.

The design process of the library is well detailed as well as how the library works and how can be extended. You can find the code here: https://github.com/HivemindTechnologies/scala-llms-dsl_final, just bear in mind that the author deem it not ready (yet) for production.

The library is well rooted in algebra, so be ready to face monoid and contravariance if you want to dig into it.

Pick a (effect) Lane

Jayanth Manklu – Engineering Data Platforms at JP Morgan. slides. video (members only).

In this talk Jayanth takes us into for a dive into Scala “direct style”. While traditionally effect system, such as ZIO, relied on a monadic system and heavily decorated functions, direct style hides all the complexity leaving the programmer use imperative style with standard type.

Odersky, the mastermind behind Scala, sponsors the direct style, claiming that it lowers the adoption curve making it easier for programmers to switch from other languages while keeping all the benefits of the asynchronous programming model and safe error handling.

Jayanth, by using the Ramen recipe as a tool to present both approaches shows the differences between the two.

Although I consider direct style a testament to Scala versatility, I reckon that it may cause lot of trouble since the reader has no way to tell whether that code runs synchronously or asynchronously and how errors are reported. Not a fault of the speaker, which properly handles the matter although I found a bit disorienting the part about direct style never having heard about.

From Exception Hell to Typed Bliss

Jordi Pradel – Founder at Agilogy. slides. video (members only).

Error management basic is to use exceptions. This clears the unhappy path, leaving the programmer focus on what to do when everything works as expected. Unfortunaly exceptions are not very good when you want to handle the error. You don’t know what kind of exception a function may throw and when you catch it you may look at the stack trace, but you don’t know how the execution got there.

Jordi shows us the error handling path from exceptions, to typed error management using Kotlin as the language. Regardless of the language defining through the return type what kind of error a function may produces provides a boost in program correctness and robustness.

Here are the lesson learnt by Jordi –

• typed errors for stuff you want to handle
• exceptions for errors you don’t want to handle
• Use null for the expected absence of a value
• Be explicit about errors.
• It’s easy to forget stuff
• Use Detekt -> the static linter for Kotlin (a bit difficult to configure)
• Error accumulation is difficult

Functional Rust: from ADT to Advanced Concurrency

Stefano Candori – Software Engineer at Prima, and Adrian Ramirez Fornell – Backend Software Engineer at Prima. video (members only).

Rust is advertised as a system programming language, truth is that Rust is strongly rooted in Functional Programming principles. In this talk Stefano and Adrian show how FP structures and idioms are mapped onto Rust constructs.

Total Function for Automated Reasoning: Building Terminating Theorem Provers

Alexander Gryzlov – Research Programmer at IMDEA Software. slides. video (members only).

This talk was quite hard to follow back to back. Not the single concepts that were clearly laid out, but the overall picture. Termination and well-founded programs are not easy topics.

For example proving that the GDC algorithm terminates is not easy at all, since we know that it converges, but we can’t prove that it terminates, at least, not in its basic form. We need a so called “well-founded” form where a type takes track of the distance from the target.

Hard talks always serve a humbling purpose. No matter how good you are at programming, there is always something that needs effort to be understood.

Complexity is a Sin

Volodymyr Yaroslavskyi – Scala Developer @ JP Morgan Chase. video (members only).

Complexity is something we programmers deal with daily. How to avoid complexity or keep it within reasonable boundaries is a quest worth pursuing. Volodymyr takes us into what complexity is and how to deal with it.

The talk is well structured and well presented – where the complexity come from, which kind of complexity exist and what we can do for it.

I liked the ideas that more often than not writing complex code makes us feel smart… until the moment you have to maintain the code. I’ll copy the closing tips about complexity –

• Do not try to predict the future.
• Keep future changes in mind.
• Complexity builds up fast.
• Discipline and code review.
• If something seems overly complex to you, probably it is.
• Refactors are expensive and unpredictable.
• Do not break patterns; special cases add complexity.

Personal Thoughts

Lambda World proved once again to be the functional programming conference to attend – interesting and thought-provoking talks, formative workshops, a perfect blend of theory and practice, framed in a wonderful location.

I found the number of attendees to be the right size for my introvert nature to have multiple occasions to get in touch with speakers and other attendees.

Unfortunately, the number of attendees was not up to the expectations of the organization and not enough to break even, as yay yay events published in a candid and transparent retrospective post.

And this is a problem since this is the second year in a row that the conference has been a loss. Clearly, there can’t be a third time, at least not in this form.

Why?

How did the conference pass from attracting some 800 people pre-COVID to “just” 200?

Yay yay events went through the past year attendees list to ask why, while I am only guessing. I think there is a natural turnover from year to year. People who came, but found the talks not interesting / too easy / too difficult, orthe location too hard to reach. I wouldn’t be surprised if, even for the pre-COVID editions, some 100 people were not returning. The failure was the inability to attract more than 100 new attendees.

And to get some partial insights into this, you would have to ask the newcomers why they came. Where did they learn about the conference, what did they expect to find, and what could have stopped them from attending.

Surely there has been a shift in functional programming – in part it entered the mainstream with most popular languages integrating constructs to enable (at least the basis) for this paradigm. In this sense, the scenario is very different from 2010-2020, when FP advantages were clear, but the only way to benefit was using a FP language.

The hard part, the one enjoyed by FP gurus with exotic algebra, remained out of reach for the mainstream community. They are hard concepts and do not easily resonate with traditional programmers.

The Scala language, once quite popular, lost a great deal of traction as the evolution of the Scala Italy conference shows.

Another problem is that employers seem less inclined to sponsor employees’ training, and the price tag for attending a conference away from home, even in a relatively cheap place, is not something everyone can afford lightly.

Maybe COVID proved that conferences can happen online, and while many employers are backpedaling on the work from home issue, they could go something like – you have to work in person, but you can attend a conference remotely.

Also, the shift towards AI-supported development may make employers think that training is not much needed when you can ask the AI everything and make it do the work.

I paid everything myself (for the second year in a row), but I think I am the exception.

Is there a future?

Is the world moving away from tech conferences? Hard to say, and possibly as every general claim it is false.

Is the decreasing number of sponsors a signal?

A more solvable question how can Lambda World be profitable again?

Here are some ideas –

• Move the conference to a location easier to reach. I love Cadiz, but it takes two flights and almost a day to get to and another one to come back.
• Make the conference hybrid (like cppmeeting). With a reduced ticket, you can attend the conference online, you have the option to ask questions, and to interact with other online attendees, but you lose the experience and the networking options. If the ticket is cheap enough (in the 50-100€ for early bird), people could pay for themselves without the need for employer sponsorship. The cost for the organization would go up a bit by a constant and would not scale up (once you support remote attendance, the cost is basically independent from the number of attendees).
• Charge for food. I don’t much like this one, but it is an option. Codemotion is like this (and this was one of the reasons for my bad review). But rather than canceling the event entirely, I would be willing to sustain this. For those who are sponsored for attending, this wouldn’t change much, for those self-sponsored, they may choose to bring their food.
• A final option is to merge this with another conference; there would be some scale economy (single location, single setup, single catering), possibly some confusion, but everything is better than no Lambda World at all.

I strongly hope Yay yay don’t give up and manage to get Lambda World back in the profitable zone. This would turn into positive feedback; the more people, the more sponsors are interested in contributing, more speakers are willing to present. And more T-Shirts from sponsors to loot for.

1. Totally my fault. I discovered that I got an email from Yay yay events that stated the password would be found on the necklace card. ↩︎