I’ve SSR’d re-frame just fine on NodeJS. I had a whack at nashorn once, but it was horribly hard to get right.

Since I’m exploring Ions at the moment, I’ve gone with Rum for now, for SSR. On Ions, there’s no way to run nodejs that I’m aware of.

hi everyone. is there a reason why on-drag-end wouldn’t work unless I don’t drag over different items? basically if I just click on an item and if I don’t change the position at all, then it fires

if I change the position, it doesn’t fire

If I create a ratom and then refer it in the component, now when I reset the value of the atom, how internally does reagent figure out which component is derefing that atom and refresh it ?

I am looking at the source code, but could not figure this out

@rnagpal reagent sets a dynamically bound variable before running the render function. the implementation of ratom/dereflooks at that variable and adds the component to the watch list

look at the usages of this variable: https://github.com/reagent-project/reagent/blob/5693716a7559a4f31bf2baf85378b3394a54e84e/src/reagent/ratom.cljs#L9

(defn- notify-deref-watcher! [derefed]
  (when-some [r *ratom-context*]
    (let [c (.-captured r)]
      (if (nil? c)
        (set! (.-captured r) (array derefed))
        (.push c derefed)))))

derefed is the atom or the component ?

IDeref
  (-deref [this]
    (notify-deref-watcher! this)
    state)

@lee.justin.m ☝️

I think c is the component and derefed is the atom. the nil-check is to see if this component has already derefed other atoms, and if not, create an array of atoms

(set! (.-captured r) (array derefed)) if nil this is executed

the code is crazy confusing because it does all this caching by setting properties on itself

so seems like derefed is component

right: it creates an array of the derefed atom if empty, otherwise it pushes it

why would it be called derefed if it were a component?

you deref atoms, not components

but from this I understand that

IDeref
  (-deref [this]
    (notify-deref-watcher! this)
    state)

yeah

I agree

But dont see the code where reagent capture the componets

Can you please point me to the line, where reagent know which component derefs an ratom

no i cannot 🙂

aah, this is pain for me

I tried 2-3 time to understand and make sense of the source code

I really wish I had a stepping debugger

but always failed

i’ve been trying to understand this code for 6 months. it’s too convoluted

I think this is the part where I miss the connection

the only way to understand what reagent is doing is to treat it as a black box, create some experiments, and add some print statements

are you trying to solve a problem or are you just curious?

just curious

juho teperi is the only guy who seems to really grok the innards of reagent

Who is the maintainer of the project ? I would love to add docs, if someone can review and merge it everynight

juho does most of the work, but there are several contributors. the original author disappeared around 2016. i don’t know what happened to him. several of us contribute to docs and more help would be welcome. doc PRs are welcome and are usually merged within a couple of days

Cool. Thanks @lee.justin.m

it’ll be nice to have async Rendering and suspense built in to react so we can all ditch reagent 😉

well you’ll need something to deal with the ratom state management part

add-watch works 😛

no cursors

yeah. I actually decided to eschew reagent and just use plain react with add-watch last night

ran into lack of cursors right away. added a “should-update” that at least saves some renders, but reagent does do a lot to try and squeeze performance out of the paradigm

i’ve actually thought about what lighterweight wrapper would look like

part of me wonders if a light react wrapper + a redux implementation would get you a lot of what people like about re-frame without the mountainous heap of complexity

i’m not so sure auto-watching is really all that useful. it isn’t hard to declare your subscriptions up front

i also don’t think there is that much utility in the magic of form-1 and form-2 components

as someone who has onboarded (well, still kind of in the process) an entire team to reagent, I can say that the ratom (and especially form-2) components are confusing as hell

@rnagpal it looks like this is where those atom derefs are captured: https://github.com/reagent-project/reagent/blob/5693716a7559a4f31bf2baf85378b3394a54e84e/src/reagent/impl/component.cljs#L135

@lee.justin.m I agree, I think that using atoms as state containers is nice because it’s very Clojure-y, but I also think that being explicit about what you’re tracking is better

I cannot seem to find the reference docs on Reagent’s hiccup syntax. Best I’ve found is this random (but concise) reddit comment: https://www.reddit.com/r/Clojure/comments/75d054/hiccupreagent_syntax_help/do5o0qh Are there any other goodies that I’m missing out on?

Thanks @lilactown for helping. Going through that part