mwotton

I had some code for the Servant type-level HTTP API library in Haskell that does type-correct property testing on arbitrary web apis without user input, then Servant changed their type structure from a basic list-based format to a record-based one. This was a good change for lots of reasons, but adding the type-level code to make my library (roboservant) compile was absurdly hard, i burned days on it.

GPT 5.something got it in two prompts.

I used sqlite as a backend for scraping 160 million websites a day. It works extraordinarily well if you hold it right - in my case, that meant devoting a database file to each thread. (Arguably in this context, it's competing with flat files, but it does a really good job there.)

Me too. Got its quirks (I wish it noticed stack-relevant changes and ran intero-restart itself) but I find it really valuable, especially with Anthony Cowley's suggestion-handling stuff.

I've implemented this. It isn't too bad up to a certain point. You have to be a bit careful about your filesystem/layout of files, lots of filesystems don't particularly like it when you have a few hundred million files in one directory.

I have a crawler downloading 160 million websites a day, almost all in Haskell. It is a much more practical language than the alternatives.

as a contributor to the other ElasticSearch client - kudos. This is much nicer than ours in many ways :)

yes, I probably should have mentioned the other 90% of the project, hey :)

This is true :) been a great tool to write a spider in, fast native code, a strict type system and very cheap threads has made it much faster than it otherwise would have been. ZeroMQ has also been a great help in modularising it. I'll try to get a piece out on the technical architecture later. (I'm the CTO, btw.)

What benefit does that have over what's actually there?

Row polymorphism has something to say about this, doesn't it? Coming from Haskell, I'm still finding concatenative programming hard to handle.

well, let's look.

map f (h:t) = f h:map f t

map f [] = []

member x (h:t) = x == h || member x t

member _ [] = False

I think the only difference is that you can't match for equality directly in the pattern.

My startup involved custom hardware and realtime messaging. I still would have been better off in the early stages writing it in Ruby.

ha. I didn't think that at all when I was writing it, but I can see how it's applicable. I'll be sure to analyse that more explicitly next time I write a presentation.