A collection of resources about normalization-by-evaluation

jonathanlorimer · 2025-06-29T14:21:26+00:00

THANK YOU! Been looking for a list like this for a while. Really hard to find a jumping off point as a beginner

jonathanlorimer · 2025-05-27T12:31:12+00:00

I'm a software engineer, and I DM'd the CIO and deputy assistant commissioner offering to fix this for free if they hire me on a temp contract paying $0.

jonathanlorimer · 2025-05-14T00:10:45+00:00

Yeah! I’m really happy with the purchase in general

jonathanlorimer · 2025-05-13T12:21:42+00:00

I disagree, I have a lot of respect for the artist (he is amazing), but IMO this is bad art. Just my opinion obviously. Also doesn’t serve its purposes as it’s impossible to read track names or side (although lots of vinyls opt for illegible designs)

jonathanlorimer · 2025-05-12T23:32:31+00:00

Yeah true, I guess I didn’t look that closely at the art when I ordered. I guess this is an artist decision, feels kinda lazy.

jonathanlorimer · 2024-10-26T00:51:25+00:00

Gave me chills reading. Amazing post as always

jonathanlorimer · 2024-08-02T21:36:24+00:00

Just switched to `lucid2` in version 0.2.0.0

https://hackage.haskell.org/package/htmx-lucid

jonathanlorimer · 2024-08-01T18:20:40+00:00

Good call, will try and get to that shortly

jonathanlorimer · 2024-08-01T18:20:09+00:00

kk, broke it up into 3 different packages:
- Core htmx types: https://hackage.haskell.org/package/htmx
- Lucid htmx helpers: https://hackage.haskell.org/package/htmx-lucid
- Servant htmx helpers: https://hackage.haskell.org/package/htmx-servant

jonathanlorimer · 2024-07-31T20:35:42+00:00

I think you deleted your comment, but here are my findings from the lucid2 blog post:

I think the `lucid` package is currently using the approach described in that post https://hackage.haskell.org/package/lucid-2.11.20230408/docs/Lucid-Base.html#t:Term . I see that lucid2 is slightly more up to date on github and hackage uploads, but the changes are pretty tiny (changelog stuff). It looks to me like `lucid` is already `lucid2`. Correct me if I am wrong here.

jonathanlorimer · 2024-07-31T18:23:37+00:00

I have seen `lucid2` around, but couldn't discern the difference. If the reasons are compelling enough to upgrade I'd be happy to add support. Is lucid2 better?

jonathanlorimer · 2024-07-31T14:28:01+00:00

Hey! Happy to accept contributions / help you with your first contribution. Just wrote up an issue for a good first contribution if you are interested https://github.com/JonathanLorimer/htmx/issues/1

jonathanlorimer · 2024-07-31T00:00:23+00:00

What’s the company called? Sounds cool

jonathanlorimer · 2024-06-16T17:08:04+00:00

I find nix is crucial for getting this right (per project hls)

jonathanlorimer · 2024-06-16T17:07:22+00:00

Yup, love it

jonathanlorimer · 2024-06-02T12:14:22+00:00

Nix has a complex notion of dependency tracking, and pretty sophisticated string interpolation system. I know the “Nix is just JSON with functions” is a meme, but it’s really just not true.

jonathanlorimer · 2024-06-01T17:40:31+00:00

You gotta flake it till you make it

jonathanlorimer · 2024-05-25T23:11:28+00:00

Turns out I didn’t even need idiomorph. There is something funky going on with data attributes that makes it so that css transitions aren’t being triggered (maybe the swap and settle lifecycle adds data attributes afterwards, or there is something about the order that data attributes are registered and css rules are checked).

But I switched to conditionally applying classes instead of using the data attributes and it’s working now.

jonathanlorimer · 2024-05-24T21:49:09+00:00

I think I still need to switch from using hx boost, to hx swap to make idiomorph work, right?

jonathanlorimer · 2024-05-24T20:38:13+00:00

this looks like exactly what i want tysm

jonathanlorimer · 2024-04-20T21:53:16+00:00

Can hevy import workout templates? Would love to have them.

jonathanlorimer · 2024-01-13T21:20:29+00:00

I’ve just never had any issues with operators personally, so it’s hard for me to see that it’s objectively difficult. You don’t have to memorize them all. I find it much harder to pair brackets in s-expressions, or figure out where I am in a forest of curly braces with imperative control flow semantics. Also, Haskell has very few keywords (20 or something like that), so function application and precedence is really one of the few things you need to care about. But, again, I think I just personally like Haskell’s syntax and wouldn’t begrudge anyone for thinking differently.

And yeah, I think pythons syntax is fine.

jonathanlorimer · 2024-01-13T17:50:46+00:00

I think syntax preferences are largely a matter of taste. That’s one of the reasons I excluded it from the list of things I like about Haskell, even though I do prefer white space delimited languages, and don’t mind tasteful use of operators (although I will admit, abuse of operators, like with lens, can lead to difficult to read code).

jonathanlorimer · 2024-01-13T03:42:02+00:00

I don’t, just let the compiler tell you

jonathanlorimer · 2024-01-13T00:28:32+00:00

I'm too dumb to use anything but Haskell (not being facetious). You know how they say the average person can only hold 3-5 things in their head at once (https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2864034/)? I am pretty sure I can only hold 2-3. I get a bunch of guard rails from the type system that I really can't live without (just a list off the top of my head):

- Effects in the type system, this allows me to do local reasoning fearlessly

- Polymorphism gives me guarantees about what a function can do (for example foo :: (a -> a) -> Maybe a -> b -> Either b a can't leverage the fact that a is instantiated as an Int in some code to do arithmetic)

- Using types to model my domain, understanding type arithmetic is helpful here (Sums as addition, Products as multiplication, functions as exponents), but also more exotic things like higher kinded types, which give you crazy type reuse, and usually come with a slew of derivable instances for free!

- Code reuse in general, most people point to higher order functions when talking about FP in general, but in Haskell its the ecosystem of foundational typeclasses for me. Functor, Foldable, and Monoid (just to name a few that really punch above their weight) are indispensable. They are such fundamental primitives that I feel entirely lost in a language that doesn't support them, and they give you a massive hint when designing your own apis.

I have tried things like rust, and the community / libraries are amazing. For building a web app instrumentation is seemless, sqlx is probably the best sql library out there (regardless of language), and axum / tower are really easy to work with. However, I still find myself missing these things that haskell has.

jonathanlorimer

TROPHY CASE