Scala.io is an awesome independant Scala conference in France. This year’s event took place on November 7–8, 2024, at EPITA in Paris. Kudos to the organizers for their outstanding effort in making this event happen!

Here are a few takeaways

Surprise Opening Keynote - V. Kasas

A smaller edition than ever in terms of CFP submissions, attendees, sponsors.

Scala is dying, some reasons:

  • Drama in the community
  • Insisting too much on pure FP pushes people away
  • External: Java stole features to Scala

Hope

  • At Databricks, any part of the code must be understandable in 2 min (so no cats, no implicits, …)
  • Propose solution when people are suffering (ex. of mix between either and validated)
  • lot of possible creative usage of TASTy
  • It’s up to us to spread the love for Scala.

Building Robust Applications with Kyo: A Hands-on Introduction - A. Hearn

  • kyo-data : low allocation
  • kyo-prelude : side-effect free algebraic effect
  • kyo-core
  • kyo-scheduler : high perf

Definition of effect = A description of what you want, produced when executed.

Syntax: File < (IO & Resource)

Pro:

  • removes F.pure usage
  • no need for flatMap
  • direct style (cps compiler plugin behind the hood)

Tools for Scala Startups - D. Ciocîrlan

Scala is underrated for full stack products

Computer algebra in Scala - R. Jolly

Explanation of design choices between OO (enrichment) vs Functional (type classes).

Calculating is funnier than guessing - R. Kuckaertz

Slow-Auto, Inconvenient-Semi: escaping false dichotomy with sanely-automatic derivation

author of chimney lib

  • semi-auto: speed
  • auto: poor error messages

Mill builds in Scala 3, a migration story- J. Thompson

A fascinating talk on Mill’s migration to Scala 3, featuring deep technical insights. James is a Scala 3 compiler contributor.

  • Scala 3 is now 3 years old
  • type inference changes when an else branch is missing
  • Pb with implicit conversion from Unit
  • Mirror doesn’t like @data annotations from Coursier
  • this in Scala 2 macro is duck typing

Plowing Postgres and Unearthing Hidden Gems - V. Bergeron

At Ledger, migration from Cassandra (ETL) to PG (ELT)

  • Use modern SQL as much as possible
  • avoid SQL codegen (thus lib like quill, slick)
  • repo pattern is harmful
  • DDL can be tested with a transaction
  • use explain (analyze, costs, verbose, buffers)
  • linearization = state pattern
  • use Common Table Expression (CTE)
  • subquery in select => nested loop join

Scala performance: when you should betray your functional programming principles - G. Renoux

At Datadome, the bottleneck is CPU, not IO, even with 200k rps (the load is distributed across 100+ nodes)

Programming a Language - N. Rinaudo

As always, a very interesting talk where Nicolas demonstrated writing an interpreter for an AST, step by step.

  • unary functions are sufficient
  • any for loop can be rewritten with a while
  • any while can be rewritten with a recursion