Gotta say, programming OpenGL from Common Lisp made programming new again. I imagine audio would be the same. I had this idea for a computer music centered code camp. Sadly, I know nothing about music.

Common Lisping the past few years had the effect on me the past few years

when i crack open Cello and see beauties like define-symbol-macro ... 💓

Symbol macros! It's a huge language, but after ten years I had used it all. Except iterate. 🙂

haha

on the last Clojure survey i requested *macroexpand-hook*, i try to request at least one CL feature a year

https://gitlab.com/embeddable-common-lisp/ecl/-/merge_requests/277/commits btw. and http://turtleware.eu/static/ecl/ecl.html is a (very) rough demo, but on that page is a genuine ECL image running in a wasm blob

the era of True Cells (tm) in the browser is nigh 📖 ⚡ 🌪️

World domination cannot be far behind. Fascinating to see this project. Thx for the heads up! 🙏

an improvement here could be, we probably know enough to tell you the loop before locking

That will teach them! 🙂 Yeah, I imagine you have the dependency chain at hand. In Cells, I dump the chain, I think including each cell body, which gets captured in symbolic form by the cell-generating macros. Ain't macros grand?!

hell yeah

unfortunately capturing compile-time stuff and doing cool things with it at runtime in cljs has always been fraught because of the gclosure shenanigans

and, you know, no EVAL-WHEN 🧔

in Cells do you walk the chain to find the loop a priori? or do you detect the loop on the 2nd iteration

Ah, I will keep my eye open for that. Thx for the heads up. EVAL_WHEN! Less, :compile, :load, :eval? And there were two syntaxes: :*-toplevel. re the loop: Cells is all run-time, no code inspection. Each formulaic cell gets pushed onto a dynamic stack var when it starts calculating. When a cell needs recalculation, we check if it is already calculating, ie in the stack. If so, we go boom, displaying the stack members. If I ever get a good use case for supporting cycles, I'll add an :on-cycle handler, but it has never come up. Fun stuff!

very nice, makes sense, thanks for explanation

that seems like the optimal solution in javelin too

Ain't *specials* grand? (I seem to be repeating myself.)

the best

we already do https://github.com/hoplon/javelin/blob/master/src/javelin/core.cljs#L213-L227 to suspend propagation within a transaction, as i imagine you do

which was always something i could never really express the awesomeness of to people who were more excited about having one big everything-atom they could swap! on

Suspend propagation? In transactions? That might be one problem with my hack, no transactions. We could roll back the cascading calculations, but side-effects are dispatched as each value changes, and we would not be able to roll those back since they operate outside the Cells system. One big atom? That came up in the call. I was already yapping too much so I did not want to make things worse, but I hope H/J stays granular. Flux et al was a prima facie good idea that just made everything harder, when we already had existence proofs like H/J that a DAG could be maintained "in place", property by property. Twenty-four Redux training videos later... don't get me started! :rolling_on_the_floor_laughing:

don't worry, complete Hoplon training video series forthcoming

Like the last one, feel free to post topics you'd like to lodge for discussion, or anything you'd like to present, and I'll make sure we get you on deck

One thing I'd be happy to do is walk through what's discussed https://clojurians.slack.com/archives/C08BDAPRA/p1682618921457579, or the grimy details of what happens in a situation where a formula calls itself indirectly. and collect ideas about what we could do better. What Ken proposed sounds easy (and way better than just locking up) Update: made an issue https://github.com/hoplon/javelin/issues/43

My pleasure! Not sure it matters, but in Cells I used a LIFO stack (just a CLJ list onto which I cons the current cell), not a set. Having a list allowed me to show the dependency cycle in order. Hth!

yep, solid. though i think we'll use a clojure set to get random order for a little extra job security