Clojurians Log v2

It’s a very clever library, but to me personally it feels incredibly clunky in comparison to a more expression based style. Also the performance improvements over just writing vanilla functional JS are flaky at best.

I don't think performance improvements are a goal?

I'd expect it to be slower, even

slower than copy on write with object/array spreading?

would expect it to be faster

I'm comparing it to plain mutation

but my bigger problem is it feels clunky to me and it breaks my flow and both reading and writing. when I see imperative code I expect it to be imperative

> I’m comparing it to plain mutation ah that’s for sure

I do wish there were things like assoc-in and friends

but as a selling point for integrating into current code that relies on mutation this setup is probably nice

ah yes, spreading is also not nearly as ergonomic as that

and also modifying deep structures in clojure suuuuuucks where something like this would probably do a lot better job

it's all trade-offs. this seems like a step in a good direction for comprehensible apps, to me

you still write out the whole path and have to query with loops etc with this

sure, but you can operate on things directly. for clojure you have to chain update-ins

or use zippers

in some cases normalizing is the way to go

I love clojure but this is definitely one of the weaker parts

We've been using https://immutable-js.com/ at work for a while. I wonder how this compares?

I'll bet there's some similarity

this is “just” JS syntax and you don’t need to translate between normal objects/arrays

immutable is faster and IMO more ergonomic if you stay in immutable world. immer can be used more in an ad-hoc fashion

Ah, good to know. Our front end team is big on immutability.

but I tend to use neither now and just use the spreading operator all over the place. looks kind of ugly but it’s one less dependency and “weirdness”

we just use good ol discipline to keep from mutation

yes that

occasionally i get bit. like when I forget that sort mutates

and when there is mutation it is meant as such

i hate that 😄

it takes a lot of discipline for sure

you get used to it

but I'm sure sisyphus said the same

I'm fairly certain my life is happier for not having JS in it...

did you know you can sort nodelists and the dom updates accordingly? it’s kind of wierd

neat! (and terrible)

that's the whole js story I think

My partner has a T shirt that says "That's a terrible idea! What time?"

I like using a variety of languages and platforms and tooling and such. so many things I want to learn even after 15 years as a pro

I think that’s great! This is such a fun profession 🙂

some day i'll have my own programming language, i'm sure of it

it'll be terrible and full of hacks and dubious features and I'll love it

make a lisp!

there’s not enough of those

I mean that was the idea

another hosted language, probably

maybe something akin to hy

or fennel

WASM is a cool target, it’s pretty small and easy to learn

and it's already all sexps!

you’ll have to write some kind of GC though

it even supports hot reloading apparently: https://epiccastle.io/blog/hot-loading-wasm/

just a gc, nbd

I try to learn a new language every year or two (per Pragmatic Programmer) and I'm still enjoying learning new stuff after doing this professionally since the early '80s 🙂

why not write threading, too!

here: https://craftinginterpreters.com/garbage-collection.html

fun!

marks & sweeps & marks & sweeps

Writing new languages used to be so much easier when we had fewer expectations of them. When I was at uni, lots of postgrad students were writing their own languages, mostly FP, mostly in the mold of SML in some sense. GC was still somewhat in its infancy back then so folks were experimenting with that too.

that's the big win in a hosted language that does straight compilation to the host language like hy or fennel, you don't have to meet the expectations yourself they're already there

(like everyone else at the time, I designed and implemented SURE -- Surrey University Recursive Evaluator -- and it had an interruptible GC intended for better interactivity... because we only had single-threaded systems back then!)

I never made it to a full language. that’s still on my bucket list. but it sounds very fun

SURE you did, Sean. SURE

🤪

My first job out of uni was essentially a compiler company. That was fun. We got to play with prerelease silicon which often had missing instructions (an early version of what became Motorola's 88000 RISC chip had no divide instruction).

TIL from that job: the Microfocus COBOL compiler was written mostly in COBOL at the time.

I mean they warned you, it's just an extra-reduced instruction set

COBOL in COBOL? in the spirit of pypy I'm going to call that COBCOB

This would be a fun language to learn next: https://en.wikipedia.org/wiki/INTERCAL

seems appropriate it has more than one version

Not gonna lie, looking at documentation Immer sounds amazing. I think it's probably one of those things that I would think "wow, this is incredible", then when I start to use it I'll think "oh gosh, this is so bad it hurts" or something 😄

That’s what happened to me to some degree. When I see mutation I expect mutation, not structural sharing. It would be somewhat equivalent to seeing set! or swap! in a function, but instead those are macros that turn imperative code into functional code. Just think about how a program flows and composes much better if it is expression based, has functional HoCs etc. versus a bunch of imperative loops, statements and mutations.

on top of that inside of React/JSX for example you write functional expressions anyways. This basically only makes sense in reducer code (Redux or useReducer hook) if we’re in React world.

I often do multiple transforms on data into different structures that are handy for different interfaces where something like this would be really helpful

but yeah, it might irk me that it's so magic, I'm not sure

@corasaurus-hex did you think about creating a function where you pass the original data, a map with keys/vals and transformations, and apply then all to produce a result? Something like (transform-all <my-data> {:person {:name str/upper-case :age inc}}), for example?

That could be a good experiment to check how well this would make transformations work, and how easy (or hard, or horrible 😄) it would be to use something like this 😄

have you seen specter and meander?

and supdate?

they're there for this purpose but it's hard to justify bringing them into a project in my experience