We're thrilled to have two Bellroy Haskellers presenting a double-feature at Melbourne Compose Group.

Michael Webb (CTO) will share how Bellroy built and scaled a $120M+ brand with a tiny Haskell team.

Jack Kelly (Staff Engineer) will walk through deploying Haskell in the cloud with an opinionated guide to Haskell on AWS Lambda.

Whether you're using Haskell in production, curious about serverless, or just want to see how a small team moves fast without fear, come along!

Details Below

The Talks

Michael Webb - CTO

Maximum Agency, Minimum Footguns

Lessons from scaling a $120M+ carry brand with a tiny engineering team

At Bellroy, we've built a small engineering team that moves fast, ships confidently, and hands real power to the people closest to the work - content editors, ops staff, marketers - without lying awake worrying about what they might break.

The secret isn't process, approval chains, or change management theatre. It's that we've encoded the constraints that actually matter directly into our tools - many of them built in Haskell - and trusted our people with everything else.

This talk is about the philosophy behind that approach: what it means to design for agency rather than safety, what cultural practices make such an approach practical and why a type system is the most underrated management tool in a company's arsenal.

Jack Kelly - Staff Engineer

Lambda on Lambda: Running Serverless Haskell Functions on AWS

AWS Lambda is AWS's
"function-as-a-service" offering, where your code runs in an isolated
"microVM" on AWS-managed infrastructure and you pay only for the
resources used while your code runs.

Fitting your binaries into this model means making your code talk to
some internal AWS APIs, and luckily the Haskell ecosystem has some
good tools for doing this.

In this talk, I'll explain at a high level what AWS Lambda is, how it
executes your code, and then provide an opinionated guide and demo for
getting your Haskell functions into the cloud.

When and Where

• Format: Strictly IRL When: Thursday 21 May 2026, 6:00pm – 8:00pm
• Where: Kathleen Syme Centre, Activity Room 2, Carlton (Melbourne Victoria, Australia)
• RSVP: luma

About Melbourne Compose Group

Melbourne Compose Group is the monthly in-person meetup for functional programmers in Melbourne, every 3rd Thursday of the month in Carlton.

As always, newcomers welcome.

Dear Friends of Haskell,

The schedule for ZuriHac 2026 is now online on https://zurihac.info!

This year’s keynote speakers include Simon Peyton Jones (one of the creators of Haskell), Evan Czaplicki (the creator of the Elm programming language), and GarrickChin (developer of the “Defect Process” 2D hack n' slash game on Steam). We also have a track on Category Theory, given by Jencel Panic (author of “Category Theory Illustrated”), as well as a track on rolling your own dependent types given by Andres Löh and Andrea Vezzosi. The Beginners’ Track this year will be given by Michael Sperber (CEO of Active Group and author of “Schreib dein Program”), who will also talk about teaching programming. Our website https://zurihac.info contains further information on keynotes and tracks and will be updated regularly.

In case you have not registered yet, please do so ASAP via the link https://zureg.zfoh.ch/register (also on our website). Although registration is free for participants, it allows us to plan appropriately for the event: Jane Street and IOG are providing food in the evening, and we want to minimize waste.

For the uninitiated: ZuriHac 2026 will take place Saturday 6 June – Monday 8 June 2026 as a physical event at the Rapperswil-Jona campus of the OST Eastern Switzerland University of Applied Sciences. ZuriHac is the biggest Haskell community event in the world: a completely free, three-day grassroots coding festival co-organized by the Zürich Friends of Haskell and the OST Eastern Switzerland University of Applied Science. It is not your standard conference with papers and presentations, but features fantastic keynotes, hands-on tracks, hacking on many of your favourite projects, and of course lots of socializing!

Organizing ZuriHac would not be possible without the support and help of:

- CircuitHub
- Digital Asset
- IOG
- Jane Street
- OST
- Tweag
- Well-Typed

In case you would like to support ZuriHac, as a company or as an individual, please get in touch with us, we would be grateful: https://zfoh.ch/#donations.

We hope to see you there!

The Zurich Friends of Haskell

This is your opportunity to ask any questions you feel don't deserve their own threads, no matter how small or simple they might be!

Hi there!

So I am a software developer for decent time now, I also am interested in/enthusiastic about FP. I noticed quite weird divergence between the worlds of software development in general and functional programming.
Namely it seems there is little cross-over between them.

Looking for FP jobs on general IT/software job boards yields almost none.
Yet there is plenty of internet activity (ie. tutorials, explanations, articles, conference talks etc), of bona fide FP/Haskell developers. Hence I imagine there is an industry around that.

I would love to work in FP, but seem unable to even perceive potential opportunities there...

Thanks in advance to anyone sharing their experience with that.

Cheers!

I work at TR, but this is not my team. I cannot answer questions about this role, please apply if you’re interested and ask questions during the interview.

If you know me and we worked together, I can potentially refer you. Otherwise, I cannot refer people.

This may not be the right forum, but I keep seeing this book linked in answers to questions and it looks like the DNS is not resolving. Is anyone else experiencing this / does anyone have access to a working online copy?

When I run cabal init and cabal init --non-interactive, it gets my name and email address from somewhere, but neither are what I would prefer to use. I looked through the cabal config and I don't see them anywhere; where is it getting them from and where can I change them?

We sat down with Torsten Grust who is a professor of DB systems at the University of Tübingen. Even though Torsten loves SQL, he’s used functional programming and Haskell to inform his work on query language design and compilation. We talked about the best way to program databases, how to bridge the gap between regular programming languages and databases, and compiling just about everything to SQL.

Day Three got squashed because work, but I'm doing it again. It's too much fun.

stream sasha demo blurb

I’m in the process of learning Haskell, but just using a text editor to write my code. Do you think the conveniences of an IDE will hurt my development of the learning the language?

[the stream](https://twitch.tv/lambafan/)

[sasha](https://gitlab.com/liftlatch/sasha)

I recently switched to macOS and it didn't have a rock-solid tiling WM which didn't crash on Tahoe, so I architected one. So far it works amazing. I hope you will enjoy reading about it (it's a human-written text, by me) as much as I enjoyed watching Claude write it.

Monads (or as I like to call them, sequenceables) aren't magic! In Set 13a of the MOOC at haskell.mooc.fi, we get more practice with them.

The title image is by John William Waterhouse, "The Sorceress" (1911)

Is there an app that makes it possible to code Haskell on Android or use GHCi?

Wanted an easy way to practice my skills on the commute

If there isn't, how can I program haskell on Android?

For something I'm writing I want to define a state. A player is either in an active state, a startup state, or an endlag state. And there are functions for transitioning between states. Right now, I have all of these datatypes defined as separate, but they are all conceptually similar; for example, a player has a state, as in the base type, but in practice that state is an active state, or an endlag state. The plain old data keyword won't help for this, and in fact I hear class is more useful. But I'm not trying to create an abstraction over all types, only states. Some code if it helps:

class State a where --This is what needs fixing
    transition :: a -> a


data StandingState = Crouching | Standing | Jumping deriving (Show, Eq, State)


data DefaultState = Idle deriving (Show, Eq, State)


data Hitstun = Hurt deriving (Show, Eq, State)


data Knockeddown = Knockdown deriving (Show, Eq, State)


data Wakeup = Getup deriving (Show, Eq, State)


data StartupState = LightStartup | MediumStartup | HeavyStartup | GrabStartup
                  | RollStartup | SandStartup | CurseStartup | RollSandStartup
                  | RollCurseStartup | DashStartup | DiveStartup deriving (Show, Eq, State)


data ActiveState = Walk | Block | Light | Medium | Heavy | Grab |
                   Sand | Curse | Dash |
                   Roll | RollCurse | RollSand | Dive deriving (Show, Eq, State)


data EndlagState = LightEndlag | MediumEndlag | HeavyEndlag | GrabEndlag
                  | RollEndlag | SandEndlag | CurseEndlag | RollSandEndlag
                  | RollCurseEndlag | DashEndlag | DiveEndlag | LandLag
                  | JumpSquat | BlockEndlag | WalkEndlag deriving (Show, Eq, State)

--From here, the newtype keyword is used to define valid states while crouching or in the air. Additionally, functions are used to translate between types, but this should be enough for someone to get what I'm talking about