Haskell Workshops & ZuriHac 2026

Ten days ago I have attended to Haskell Ecosystem Workshop, Haskell Implementors' Workshop, followed by ZuriHac.

It was my first to all events.

Haskell Ecosystem Workshop

I have attended as part as the Haskell Response Team.

We have collected a lot of feedback (videos will be available at some point), more on this later.

Here is my take on the talks:

Optimising for fast build with GHC

I'm that Teo's talk was the first of the day.

They were very articulated, starting by reminding to start by removing dead code with weeder, which is something we tend to forget.

Then, regular advises:

• Slowness causes: excessive type level programming and code generation
• Don’t reexport, split interface and implementation.

I have discovered ghc-build-stats a simple GHC plugin to spot contention points during the build.

I realized two things:

• None of the codebases I have worked on in the last 3 years follow these best practices
• It does not feel that important to have "fast" build

Servant at Bitnomial

They use servant to expose endpoints and publish OpenAPI/client/documentation.

The use it for non performance-related endpoints, for the others, they use HTTP-streaming.

Interestingly, they have introduced type aliases as “profiles” for classic endpoints (eg. CRUD).

I'm working on servant for a long time, on bigger codebases, so, I have not benefited from the talk.

The GHC we could have if we want it

It was mostly a call-to-action on how to contribute, I was not really the target of this talk, being a huge FOSS contributor myself.

I'm a bit frustrated, become the speaker rose the concern about abandoned packages, but we did not debated it.

Flora

flora.pm is a package manager aggregator.

Similarly, being a contributor myself, I did not learnt a lot from the presentation.

I have enjoyed to have an overview of the roadmap.

Hécate plans to reimplement The Update Framework to avoid breaking client, even though, I agree with Duncan Coutts, current implementation can be extended/merged.

Agent use

He managed to use LLMs to create a product of 50k LoC in two weeks.

He is also using LLMs to all SDLC usage.

He is witnessing the same things than me: duplicate code, primitive.

He gave the following trick to simplify the code: asking a smaller model to a bigger model which will simplify the code until the smaller model understands.

The discussion was really intense and emotional for some of the attendees, I had a hard time to cope with an open conflict at the end.

Stackage

This talk was hard to follow,I was barely hearing it, the pace was not right.

Despite this, I was able to have a look at the heavy work done by the stackage team, curating packages.

Security

Fraser did a talk, which should be available in few months, focuses on hackage-server.

I think the talk was good, but I'm not satisfied:

• I wish we had presented the process and result of the team
• I wish we had discussed how do we, collectively, speed up fixing process
• I feel like people are generally more dissatisfied with our work

Haskell Implementors' Workshop

Here is my take on the second day:

GHC Status report

GHC 9.14.1 will be the first LTS release, with a 2 years window support.

GHC 10.0.1 on the way, it will include reinstallable base which will enable compile with an old base, keeping the compilation working. It will also distinct Type and Constraint which allowed to write type classes on Constraint, or compare Type and Constraint.

Stable Haskell

A fork of GHC and Cabal, it's used to explore, there have been no upstream contributions (yet).

It was created to improve stability, merge time, give a vision.

For the moment, they got rid of Hadrian, and they have started to decouple RTS.

I have mixed feeling about it, I don't think it's a serious competitor of GHC, but it could lead to a community fragmentation.

MicroHs - Dead or Alive? A status report

As usual, we had a great demo:

• 6 seconds to compile MicroHs
• Introduction of the interactive mode
• It can be recompiled embedding other libraries
• A brand new web based interactive mode
• It can be reduced to run in the secure part of CPUs
• It has an architecture-independent serialization
• It supports deriving strategies
• It is still small: 14 kLoC Haskell / 10 kLoC
• It now compiles 100s of hackage packages

Lightweight profiler with ghc-stack-profiler

It is a plain library which adds a thread at runtime and sample stacks, pushing to eventlog.

Evolving the Haskell debugger

It was a fast-paced demo, it has many fixes since last year, supporting step in/out, and all mainstream debugger operations?

It only works on byte code, but there are to interpret compiled code/dependencies.

They aim high such as temporal debugging and borrowing features from “Tomorrow Corporation Tech Demo”.

I have not used a debugger since a decade, but I guess it could be useful.

Is there a future for a formally specified Haskell report

I’m not really found of this kind of talks but I have enjoyed it a lot.

He spent a long time going over other programming languages specification.

I’m actually impressed how close he is for completing it.

Towards better implicit parameters

I don’t like this extension and it is more broken than I thought, noticeably, I have discovered that we could define type classes bound to no type, as follows:

class C where
  x :: Int

I enjoyed the talk, the proposal makes sense to fix the extension, but I think, with modern effects systems it makes more sense to delete it.

GHC string interpolation

Initially published in 2023, it got 635 GitHub comments, what an obstinacy!

Lots of decisions have been made, I have followed a bit at the beginning, I cannot recognize it anymore.

Lighting talks

• language-haskell: parser/pretty-printer, not much change, mainly due to the upcoming GHC AST extraction
• Type functions in BlueSpec: hardware language with Haskell like types, type classes functional dependencies alternative to type aliases
• The missing Haskell dev tools: haskell-inspector, profile and debug executable. Connect to a connector in your app and drive it with a client
• “True” heap profile with ghc-debug: usually we get a heap census, labeled memory cells instead of a graph -> use flame graph to represent heap
• Type families are still painfully slow: using type families to store ASM instructions (qBayLogic), slowed by the type checker, core files are huge after desugaring (coercion).

ZuriHac

I was my third attendance to ZuriHac.

Saturday

The first day I have attended to Simon Peyton Jones's talk "Another taste of Verse".

It might be the third or fourth talk on Verse, and I think I'm starting to understand.

I'm not a fan of the overall approach, it is mostly reversed-engineered. It is fascinating how much effort is put, trying to find which approach used in decades-old research programming languages to implement uncommon features. The most interesting thing to me being the representation of types as partial functions.

Then, I have kept working on the issue I have opened 3 years ago (patch). The aim is to be able to use of record dot syntax on record selectors when they have a constraint, as follows:

data Rec = Rec { thing0 :: Int, thing1 :: HasCallStack => Int -> Int }

res :: Rec -> Int
res r = r.thing1 r.thing0
-- Cannot call thing1

I have also trimmed an old patch on hackage-server which will fix a decade-old security vulnerability.

I have also fixed a bug on MicroHs, which is producing larger than expected binaries when embedding libraries. I'm pretty happy with the result, as it also improved the regular binary size:

I have also meet 7 people I know (it was 7 last year, 3 two years ago, and 1 two years ago).

Aside of this, I have worked with Fraser en Piotr on security issues.

Sunday

The second day, a consensus arose that my GHC issue should lead to a GHC proposal, but I think it will be rejected, since the issue seems deep.

While I was at it, I have exhumed an old tech-proposal of decoupling haddock intermediate representation from GHC, obviously, it will not be done in the following weeks, but in the long-run, it should enable a large set of changes in the whole ecosystem.

I have attended to two talk:

• “Getting to the Data - dataframes, notebooks and typed pipelines”: I have never used dataframes, or equivalent libraries, but I have realized I have built a subset 10+ years ago. The talk was interesting, and the demo was neat.
• “The Haskell gamedev experience”: I do not plan to create a video game, but I was expecting some new sage, or special techniques, but it was more a praise of Haskell.

Monday

On the last day, I went back-and-forth on my proposals.

I have also worked on fixing another hackage-server security vulnerability which spread all over the codebase.

The last talk I have attended was “How to stop writing Haskell”, it was pretty depressive to have a collection of all the ways Haskell can fail in a company.

Conclusion

It was another very stimulating event.

I'm glad I was ably to connect to many people in the community.

Unlike the previous years, I have made some progress on the topics I had in mind, which is satisfying.

However, I have also had too much social interactions, which exhausted me.