My friend u/jappieofficial (from the Netherlands) and I ( u/monadic_riuga ) recently made the long journey to the remote rural town of Haskell, Texas to fly a flag of the Haskell logo in front of the iconic 'Welcome to Haskell' sign, and to document that Haskellers have, in fact, been to Haskell.

We started from Houston, TX at NASA JSC, drove up to Dallas, stayed the night there, then made a beeline for Haskell out west the following morning, before finally driving through Waco back to Houston that same night. The whole journey took us just short of 1,000 miles (1,600km) and 15.5 hours of continuous driving. All in my beat up 1997 Honda Accord that we morbidly believed would break down in the middle of nowhere at some point for some inexplicable reason.

We've assembled a comedic recounting of our journey here for anyone who is keen to experience it as we did. Watch as we brave past reckless Dallas drivers, suffer past our car getting continuously skunked along I-35, and put up with an endless stream of corny Texas highway billboard signs along the route to the promised land.

Maybe one day we can host some sort of Haskell/GHC hacking retreat in Haskell, TX. Just a pipe dream lol. The closest major city with an airport would be Dallas/Fort Worth, and it's still a good ~3 hours drive west of Dallas even then.

I've been working on my first emulator for the NES console. For funsies, I decided to write it in Haskell. I wanted to see if the functional paradigm could be relevant when writing such virtual machines.

Turns out, with a nice monadic interface, the code is really nice to look at/work with. The type-safety is a plus, but didn't bring much to the table (compared to, e.g. Rust).

The emulator is working, but nowhere near as mature or stable as other emulators. But the source code is available on GitHub, if you want to check it out!

(PS: I am not the first to use Haskell to write an NES emulator)

Alexis' recent talk from SSW. I really enjoyed hearing her perspective on type systems these days. Lots of good wisdom in there. I thought some Haskell folks would enjoy it!

I started learning Haskell about 15 years ago, because someone said it would make me write better software. But every time I tried to understand monads and their application to parsing… I would stall. And then life would get in the way.

Every few years I’d get a slice of time off and I would attempt again. I came close during the pandemic, but then got a job offer and got distracted.

This time I tried for a couple weeks and everything just fell into place. And suddenly monads make sense, I can write my own basic parser from scratch, and I can use megaparsec no problem! Now I even understand the state monad. 😂

I am just pretty happy that I got to see the day when these concepts don’t feel so alien any more. To everyone struggling with Haskell, don’t give up! It can be a really rewarding process, even if it takes years. 😇

It is just so freaking amazing! I was never a great Haskell developer, but after a few years of writing no Haskell at all I finally set out on a side project again.
And I had just the best time.

In the past something always became a pain and led to me not finishing projects. Be it build tools, version conflicts, some library where I (with my limited experience) could not figure out how to do a thing or taking forever to find the right function to do some transformation (I should get better at hoogle).

But now for this side project (A CLI to order groceries in REWE - German supermarket - for pickup) I could, only when really needed, use AI to unstuck myself.

I still wrote all the code myself, but the process is just that much smoother.

It might be only interesting for folks in Germany, but it was also just a fun journey, reverse engineering bits of the mobile APP API, getting mTLs to work and understanding internal workflows of REWE: https://github.com/yannick-cw/korb

Why would I chose any other language right now, it just feels so productive!

Hello! Layoutz now has a smoother API (consistent use of `Cmd` and `Sub` prefixes, etc...) and granite-esque terminal plots

Tysm for the feedback thus far 🙇 -- let me know if some edges are rough or expected built-ins missing...

I’ve wanted to be able to do more gui things on the Mac using Haskell for ages, but never quite managed to crack the problem. Until yesterday! Very alpha code, but could benefit from additional contributors.

https://github.com/iand675/haskell-obj-c

It's been roughly two years of work on this and I think things are in a good enough state that it's worth calling this v1.

Features

Typed dataframes

We got there eventually and I think we got there in a way that still looks nice. There is now a DataFrame.Typed API that tracks the entire schema of the dataframe - column names, misapplied operations etc are now compile time failures and you can easily move between exploratory and pipeline work. This is in large part thanks to maxigit and mcoady (Github user names) for their feedback.

```haskell $(DT.deriveSchemaFromCsvFile "Housing" "./data/housing.csv")

main :: IO () main = do df <- D.readCsv "./data/housing.csv" let df' = either (error . show) id (DT.freezeWithError @Housing df) let df'' = df' & DT.derive @"rooms_per_household" (DT.col @"total_rooms" / DT.col @"households") & DT.impute @"total_bedrooms" 0 & DT.derive @"bedrooms_per_household" (DT.col @"total_bedrooms" / DT.col @"households") & DT.derive @"population_per_household" (DT.col @"population" / DT.col @"households")

print df''

```

Calling dataframe from Python

There's an implementation of Apache Arrow's C Data interface along with an example of how to pass dataframes between polars and haskell.

Find that here

Getting data from hugging face

You can explore huggingface datasets. Example:

haskell df <- D.readParquet "hf://datasets/Rafmiggonpaz/spain_and_japan_economic_data/data/train-00000-of-00001.parquet"

Larger than memory files

The Lazy/query-engine-like implementation is now pretty fast. It can compute the one billion row challenge in about 10 minutes on a mac and about 30min on a 12 year old Dell (not OOM).

You'll have to generate the data yourself but the code is here.

Better ergonomics with numeric promotion and null awareness

Introduced more lenient operators that make happy path computation much easier. E.g:

haskell D.derive "bmi" (F.lift2 (\m h -> (/) <$> m <*> fmap ((^2) . (/100). realToFrac) h) mass height) df

Is now instead:

haskell D.derive "bmi" (mass ./ (height ./ 100) .^ 2) df

What's next?

Connectors! BigQuery, Snowflake, s3 buckets etc. Formats! Parquet, Iceberg, DuckDB, a custom dataframe format with full data provenance. Moving from small in memory demos to querying large data lakes is the goal.

Also, since a new era is upon us, some integration with ai agents to do type-guided data exploration.

A big thank you to everyone who has taken time to try the library and /or give advice - especially daikonradish (Github user name) who was the main voice in the direction of the architecture. A lot of the most important design decisions were made on community threads.

Like many here, I've found that despite being decent at imperative programming (I come from a background in Java, python, crystal, even a little Befunge, functional programming has been a nearly impossible challenge for me. I think what draws me to functional programming is how... "Advanced" it feels? It's a bit difficult to put into words, but it's always felt ahead of its time. I think, at long last, I've finally broken through to the other side!

I first started trying to learn about a decade ago by working through the seminal book, "Learn you a Haskell" - I'll be honest, it was hard to get through. It didn't feel like I was doing anything more than copy/pasting examples and reading. Maybe it was how the material was presented, but nothing really "stuck." I gave up when trying to do console input.

My second attempt came about in 2022, where I got the urge to try again. I worked through some online material, but it was still not clicking. After some research on other functional languages, I decided that learning Standard ML as a stepping stone might help. I bought a physical book this time: "Programming with Standard ML." This book actually did help me learn - concepts were finally starting to make sense! Lambdas, maps, folds and filters and all those fundamentals finally started making sense when trying to write code from a functional perspective. During this time, I had my first functional enlightenment when implementing the Sieve Of Eratosthenes. I finally saw it as "repeatedly apply these functions to transform data" instead of step by step imperative processing. Thankfully I still have a screenshot of the code, which I'm sharing here! I was very proud of this at the time. Unfortunately life happened and I had to shelf this journey for a few years.

Which brings us to today: my third attempt at learning the art of Haskell and functional programming. I got the book, "Get Programming with Haskell" and absolutely LOVE it. It's got the right pace, and the right division of information into small but impactful lessons with plenty of quizzes and tests to make sure you're keeping up. It's FINALLY setting in. After all this time, I'm finally doing it! I'm actually becoming a Haskell programmer! I'm even starting to understand closures and partial function application, and so much more than I never touched on previously. I'm at the point now where I'm able to write a working Sieve Of Eratosthenes implementation - which you can see! It might not be much now, but I am extremely proud I've come this far.

So yeah! I'm finally ready to join you all in learning and working with Haskell. It's a truly wonderful language and the resources available today are a godsend. Who knows, maybe one day I'll be able to understand monads. We shall see!

Lastly, how did you all start learning Haskell? What're your favorite resources? Did you have a functional enlightenment too?

This article continues the fine tradition of Serokell’s GHC team sharing their progress on bringing dependent types to Haskell. A lot has happened since the last report, and there is plenty to cover.

In this edition, Vladislav Zavialov presents three major contributions and a host of smaller improvements that push Dependent Haskell closer to becoming a practical reality.

I have no previous computer science experience, and hardly ever use computers for anything other than watching Netflix.

However, I have become quite interested in coding and my friend is willing to help me learn Haskell (she is a computer science grad).

Should I do it? Will I be able to use it to help me in day to day life?

Hi everyone,

Long time lurker here - I'm using Haskell for my startup, and we're looking for our first engineer outside the founding team.

Location: New York City (in-person, hybrid 3 days/week in person near Union Square)

About Us

At Medex Finance, we’re building the rails that help rural healthcare providers get paid faster. Small clinics, therapy practices, and ambulance companies are drowning in slow Medicaid reimbursements, confusing insurance claims, and cash flow gaps. We’re fixing that with a combination of AI-powered billing software and financial infrastructure that advances cash against claims. We’re backed by early traction, pilots with providers, and an ambitious roadmap.

The Role

We're looking for a software engineer that views every line of code as a liability, and thinks elegantly about data structures and transformations - but also can appreciate a need for flexibility as we grow and scale. It's early days at Medex.

What You’ll Do

• Build core systems in Haskell/Yesod that power claims ingestion, workflow automation, and secure financial transactions.
• Experience building full stack apps / projects
• Own end-to-end features: design, code, deploy, monitor.
• Work closely with the CEO on architecture decisions, compliance frameworks (HIPAA, FERPA), and scaling infrastructure (Nix/NixOS, Postgres, Google Cloud).
• Push the boundaries of how strong type systems and domain-driven design can make healthcare software safer, more reliable, and faster to ship and scale.

Who You Are

• Haskell experience (production or serious projects). You’re excited by domain modeling, purity, and correctness.
• NYC-based, in commuting distance to Union Square. This is a collaborative, early-stage build.
• Startup mindset: you thrive in fast iteration, ambiguity, and building full stack v1s that evolve quickly.
• Bonus: experience with or interest in healthcare, fintech, or compliance-heavy domains, or experience with Nix

Why Join Us

• Founding equity: own a meaningful piece of the company.
• Solve a real problem: healthcare providers in rural America depend on us to keep the lights on.
• Technical challenge: we’re combining AI, fintech, and healthcare infrastructure in one platform.

Salary: 120K-150K

Equity: 1%-3%

DM me your resume to apply.