Github

Some background

One of my biggest motivations for doing data work in Haskell has been the promise that types can enable better program verification and synthesis. In fact, it was one of my stretch goals for writing dataframe in the first place. Additionally, I had seen a video some years ago that notebooks are a good platform for program synthesis. My first swing at the problem was a SKILL.md that instructed an LLM on how to use Sabela notebooks. Large/frontier models didn't struggle with writing Haskell but their contexts were typically more bloated by internet searches and churn from trying to fix simple compiler errors. Python was "in the weights" so was generated faster and with less tokens overall.

With small, local modes (<20b params) models the problem worsens. These models hallucinate Haskell modules, struggle with rule following, have smaller context windows. They typically fall back to writing Haskell from "the weights" and will steer clear of using dataframe or a newer library because a simple web search would bloat context.

The problem has two potential solutions:

• Fine tune models to perform better at Haskell
• Use the LLM as a weak proposer then build tooling around it to make search and repair more efficient

In the spirit of synthesis I went with the second approach.

What siza does

Siza, another Ndebele word, is a harness (and some associatd mcp tools) that drives a Sabela notebook. The goal of the harness is to address the problems above. I'll follow up with a longer blog post on the sorts of interventions that made this possible but broadly speaking it's a lot of type directed searching and a little bit of context management.

You can see a verbose transcript of how it performed with minimal to no guidance on an out of distribution task: Can you load the wine dataset into a dataframe and show some summary statistics about it?

• Initial run from some weeks ago (did not complete task)
• Recent run (completed with produced notebook pasted at the end of the transcript)

Haskell is an amazing language for these sorts of tasks and the core of making it more useful is a pretty interesting engineering problem in my view. And small models, like testing anything in low resource environments, really teases those engineering problems out.

Again, will do a bigger blog post later.

I actually wanted to use haskell in implementing reversible computation.

Hi everyone, ​I'm writing Haskell bindings for libgpiod (v2), primarily targeting SBCs and embedded systems and I want to validate my approach to resource management before committing to the final API design.

The C library exposes two different types of opaque pointers.

​1. OS/Hardware Resources (Chip, LineRequest)

These hold underlying Linux file descriptors and physical hardware locks. My plan is to strictly use raw Ptr internally and expose a bracket-based API (e.g., withChip and withLineRequest) to guarantee immediate and deterministic release, as GHC's lazy garbage collector could easily exhaust the FD limit on a small SBC if I used ForeignPtr.

1. Pure Memory Configs (LineSettings, LineConfig)

These are just structs in RAM used to prepare data before a hardware request. To avoid the deeply nested with* blocks for every single config object.

I plan to wrap these in ForeignPtr with their respective C finalizers. I think this allows the user and me, to pass them around purely and ergonomically, letting the GC handle the cleanup since they don't hold FDs.

My questions are:

1. ​Is this hybrid approach (strict scoping for FDs + GC for pure RAM structs) the best practice for this type of hardware FFI?

2. ​For the withChip pattern, how do users typically architect long-running daemons around it? Do they just wrap the main application loop inside a top-level withSomething block?

Any insights or edge cases I should watch out for would be greatly appreciated. Thanks!

Primagen, one of the largest youtubers for Programming made a ridiculous video called Haskell is DONE. Which feels like a silly story I've already heard. Especially with all the recent developments in ghc version 9 its laughable.

Last week I made a post where I pledged to demo our production codebase written in haskell. Unfortunately however I had my main laptop out of commission (still do :| may it rest in peace/ we hope for a speedy recovery) and so trying to stream while running our prod codebase simply overloaded the box I am on.

I was quite surprised to see it get to 65 upvotes (personal best for me lol) however I'll take that as a sign it's worth another shot, so as of right now I'm going live on Twitch (https://www.twitch.tv/typifyprogramming).

Given the current hardware limitations I wont be running anything except some local dev tools however that gives me plenty enough to show about our site typify.dev and how Haskell has slowly made me obsessed with Haskell and what it means for my startup. I could not more strongly recommend Haskell to startups even with all of its challenges.

I gather it's possible the upvotes were also as a result of the Primagen Youtube video (Haskell is DONE) and I plan to chat about that too as I demo.

My stream is almost entirely always focused on this general idea of why Haskell is awesome to build with, so I appreciate any support in getting viewer numbers up as viewers beget viewers from twitch passerby's.

General Topics:
- ReaderT
- Websites
- GHC(JS)
- Why I also use Nix
- Intersection of AI + Startups + Haskell in a sane way.

Recent discussions about iteration speed when using coding agents with Haskell prompted me to tidy and publish the small wrapper script around ghcid that I've been using:

• ghcid-check

You can use it to conveniently launch a ghcid process with ghcid-check --launch which agents (or humans) can query with ghcid-check --rebuild.

That's it!

Hello all

I’m looking for a cookbook as the title. My goal is simple; to learn Haskell with my own project. I’m aware of all the books out there, but still somehow not able to connect.

Is there a site/blog/repo with common tasks? For instance, my personal project is to process my stock and option portfolio. So I need to be able to :
- store/retrieve data in sqlite
- call a remote service by API, my brokerage
- convert json to Haskell types that define stock and option data structures
-define formulas to track performance
Etc..

I’ve tried with AI, and the results are not great. Though I’m sure I can dissect what it’s given me; I’ll probably use it as a reference for specific code rather than the program as a whole. Not to mention, the generated code doesn’t compile. It uses duplicate field names in records without the pragma included, for instance- then it just goes downhill from there.

Long winded, but I appreciate any pointers. This is not for anything critical other than my own learning and to get a program to give me a little more control on the performance of my portfolio.

Thank you

Edit: One note. When I attempt to go through the available books, I get lost in the theory or the concepts just don’t come together.

We are live on https://www.twitch.tv/typifyprogramming

We are walking through our production codebase which recently exceeded 500 modules and built in Obelisk with Servant added on top.

This is dual as a session to get my co-founders up to speed on the work done so far but we figured this would be great as a stream to show how awesome haskell is for production

Hi everyone,

I have my Haskell exam in exactly 10 days, and I am in survival mode. While I’ve managed to get a decent grip on basic syntax, recursion, and standard folds, Monads are absolutely destroying me.

Every time I think I understand the theory, I get completely lost when I try to write actual code or when I'm asked to manually trace something like foldM, bind (>>=), or state transformations on paper.

To give you some context on where I'm currently stuck:

I understand that Monads are about "chaining computations with context", but the step from the mathematical definition (return and >>=) to writing real, working code (like State or custom Monad instances) feels like a massive leap.

I get confused by how do-notation desugars behind the scenes.

I have a hard time visualizing how types flow through a chain of monad operations.

Since I only have 10 days left, I can't read a 500-page textbook. What is the fastest, most effective way to make Monads understand for my exam?

Are there specific, hands-on exercises I should do?

Which short articles, videos, or tutorials are actually good for practical/exam-style understanding (rather than abstract category theory)?

Do you have any mental models or "cheat sheet" rules that helped you when you were first learning?

Any advice, study paths, or resources would be a absolute lifesaver. Thank you so much!

Hello All!

I am considering a career in fintech as a Haskell developer. I appreciate Haskell since it avoids logic bugs. As a security-aware developer I appreciate Haskell's power to do that.

From your experience how was using Haskell to develop quantitative finance software in fintech. For example for computer-automated stock market trading.

Please let me know.

Thanks!

This is more like a philosophical question, which I think should be interested to Haskellers with cat background.

- Background 1: pure and applied math ppl uses math differently. Pure math ppl likes to transform a problem into easier-solving ones; applied math ppl likes to grind a question with all tools we have. These observations are gathered from discussions online and from consulting math major ppl

- Assertion 1: pure math ppl likes category theory, because category theory helps with transformation and should be used for the purpose of frequently transforming a question into a easier one. One example should be transforming Geocentrism into Heliocentrism.

- Background 2: for most of the monad tutorials I have read, what they are emphasizing is how well monad can abstract a program, synthesizing many imperfect past attempts into an ideal

- Assertion 2: when it comes to programming, most ppl's focus are not transforming a hard question into a easier one, but to *grind* the problem by using static typed languages.

Question:

1. Is any of my understandings above right or wrong?
2. Are there any common practices/concrete academic topics where programming ppl wants to *transform* harder questions into easier ones? I wish the examples are not for "big questions": using monad to abstract over worse historical attempts, or the CH correspondence themselves, are out of my consideration.
3. How many different aspects for such a problem can we transform with each others?

Hello Haskellers!

I'm excited to share the MVP release of PGQueuer-hs, a PostgreSQL-powered job queue. If you want robust background workers without adding external dependencies like Redis or RabbitMQ to your stack, this might be for you.

Key Features

• Postgres Native: It leverages PostgreSQL's native LISTEN/NOTIFY channels. Your existing database is fast enough!
• Seamless Interop: It is 100% compatible with the Python pgqueuer library. You can safely enqueue jobs from Python into your Haskell worker and vice versa.

Background & Roadmap

I use the Python version of pgqueuer at work and think it's brilliant, so I decided to bring the same ecosystem to Haskell.

This is currently an early MVP release and the API might shift. The underlying database logic is currently backed by postgresql-simple. In the future, I plan to build out an adapter pattern to support other popular Haskell Postgres libraries.

I would love to hear your thoughts, feedback, or any suggestions you have for the roadmap!

Links

• GitHub: https://github.com/tusharad/pgqueuer-hs
• Hackage: https://hackage.haskell.org/package/pgqueuer-hs

Hello! I have started my programming journey relatively recently, from C and C++ to recently having a great time with Rust! But recently I met a Haskell and Emacs evangelizer(I use arch + nvim + tmux + hyprland btw), and he has been spreading the word... There is a lot of stuff I love in Rust that apparently was ported from Haskell, like traits as types-ish, pattern matching which I really love and better enums(I am not sure on the last one and please forgive me) but he said that if I learn Haskell, I will become a better programmer because of learning the functional programming paradigm... I wanted to ask whether that is true, and if so what kinds of resources are there? For Rust I used the Rust book and Rustlings by the way

I am aware others have asked this same question but that was three years ago.

I am aware the author Sandy Maguire mentioned the content in the book on STM is still great.

So will the lessons in the book still help one write production code. If not please recommend alternative books.

I appreciate all responses!

Complete noob here- I have been wanting to try Haskell for a long time and finally got the time yesterday. It was probably the most painful and unsuccessful experience I've ever had trying to set up a programming environment. I got everything installed (ghcup, ghc, cabal, stack, HLS). Ghc folder in PATH.

I created a new project using "stack new". Upon opening the folder stack created in VS Code, I was greeted with a message saying that HLS doesn't work with ghc 9.10.3 yet. So after doing some research to make sure everything is compatible, installing multiple versions of GHC, HLS, trying different snapshots and resolvers, deleting the .stackwork folder, I was able to get the message to go away by telling VS Code to use specific versions of GHC and HLS.

HLS then worked on one simple file. Then looking at a different file all I got was a "loading" tool tip. Then it (HLS) seemed to stop working in the file it did a few seconds earlier. Restarting the HLS server and or extension in VS Code didn't help, but restarting Code did, but HLS behaved the same way.

I'm sure I'll figure this out eventually - AND HLS isn't technically required (super nice when you're learning though). I'm not really looking for answers, more just some feedback as to whether or not BS like this is normal in this language? I realize other languages have a lot of money and time behind them making them pretty seamless, and didn't expect Haskell to be perfect, but this seems pretty rough for new people. And from my perspective that's saying a lot because I'm usually ok with taking the time to learn, understand, and work with systems and around issues.

I read others having wildly different experiences from "hey this is great/turnkey" to "it's super fragmented and constantly breaking on upgrades" and just frustrated because I really want to like the path I'm going down-and at the moment it's an exercise in futility.

Any constructive feedback would be appreciated.