@peterromfeld: thanks

@tbrooke: nice!

Pretty impressive flexbox library for reageant — doing some interesting things there - with impressive demo. Something to learn from for hoplon perhaps :http://re-demo.s3-website-ap-southeast-2.amazonaws.com/#/h-box

that's great! too bad those aren't functions

they sure are documented like them 😉

pretty big library

let's write a macro that rewrites the damn thing into hoplon

lol

I really do think having equivalent out-of-the-box functionality for hoplon would be a huge win as far as interest / uptake of hoplon.

jumblerg showed me some interesting flex type stuff he's been doing with hoplon this morning

Expand on what micha started with boot - but integrated tightly and mostly inline.

@micha: he needs to open up that code!

i think he's going to write it up, i hope so anyway

yeah his library uses hoplon as a low level foundation

he doesn't use any of the hoplon stuff directly in his applications

his library sits on top of hoplon

he definitely codes bottom-up

which is exactly what we intended

yeah

the existing DOM model isn't good for what we do with it

hopefully we can build something better on top of it

but without losing the simplicity etc

like we don't want to build swing on DOM

lol

lol

a set of light-weight components built using flexbox would be a great start

he actually did something even better, i think

he implemented custom attributes that you can use with any element

that implement the flex constraint stuff

seconded. I would gladly learn 50 new functions (that return custom DOM elements) that make sense. Right now it seems like everything is a div in html

using a combination of css and js under the hood

his library doesn't ship components, other than i think a few primitive ones

mostly it's attributes that intelligently maintain constraints and whatnot

basically he's reengineered the DOM

that's what the web needs anyway, no?

is this closed source or what

yeah it's part of his project at the moment

not open source

he's made a few iterations of the concept now

over the past year or two

I should start writing my app so I get more hands-on experience with hoplon, but got too much work on my hands lately. And I'm really lazy setting things up 😞

looking at this I don't see this defined in castra https://github.com/hoplon/demos/blob/hoplon6/castra-chat/src/castra/demo/core.clj#L24

I see wrap-castra-session and wrap-castra in the middleware namespace. I guess those can be used as other ring middleware?

the wrap-castra-session is specific to castra

i'm using it to simplify passing credentials with CORS

so something like (-> app-routes wrap-castra app-defaults) makes sense right? app-routes being the defined route(s) and app-defaults coming from ring defaults

castra will try to handle any POST request that makes it to it

but it doesn't look at routes at all

so you might want to put castra inside your routes

eg wrap castra middleware with your routes middleware and the other stuff

so it gets to castra last

giving all your other middleware a chance to handle the request first

I see, will try to set that up, thanks

gotta run now

later!

😉

alandipert: micha: as i understood it's possible to provide kids as a cell to a hoplon dom element but it's not recommended. the reason is performance, if i understood it well. we have experienced a massive "memory leak" and huge slowdowns in our app because our menu implementation was something like this:

(div :id "module-segment"
   (cell= [(when (= "#/module-x" route) (module-x)))
           (when (= "#/module-y" route) (module-y)))
            ...]))

as a side-effect - in the chrome js profiler - we've noticed tons of timers being spinning, mostly kicked off by when-dom

under certain situation which we couldn't narrow down, when-dom seemed to never terminate.

i guess it's something which never should happen but it did, so i was thinking maybe it's a good idea to add some guard conditions to when-dom, just to make it fail a bit more gracefully. something like this maybe:

(defn when-dom [this f]
  (if-not (instance? js/Element this)
    (f)
    (timeout
      (let [retry (atom 60)]
        (fn doit []
          (swap! retry dec)
          (if (.contains (.-documentElement js/document) this)
            (f)
            (if (pos? @retry)
              (timeout doit 20)
              (do (.log js/console "This element is never attached to the DOM:" this)))))))))

@onetom: yeah the when-dom spins and it should do like how you say there

@onetom: the "cell children" thing is only recommended when the contents of the cell are stateless, meaning the only allocation is dom elements

and the reason isn't performance, it's memory leaks

loop-tpl is for when you need to allocate for local state in the elements

that will pool them and ensure that memory isn't leaked

so how would u define "stateless". some dom element which attributes or kids doesnt depend on any cells?

right

the other day u said something like "nested formula cells are not a good idea, because something something"

nested formula cells are just a pain to use with the cell= macro, and i haven't yet seen a case where they're needed

whenever i think of doing that i always refactor to get something better

so far at least

if you have nested cells you can use the formula function and not use cell= at all

so i was thinking what exactly does it mean.

(defc stem1 nil)
(defc= formula1 (some-transform stem1))
(defc= formula2 (other-transform formula1))

(defc stem1 nil)
(defc= formula2 (other-transform (cell= (some-transform stem1))))

that gives you more control over how names are interpreted

the nested cell= in the second example seems redundant

sure, in this simple example...

but in practice that what happens when we work with hoplon, just there are a few more layers in between

generally if the formulas are getting complicated you're probably better off making a function that takes regular data and just calling that from the formula

i mostly use cells for the plumbing, not really for computing so much

like cells allow you to guide the dataflow

but you don't want to do hardcore computing in there, instead you compute in functions that you can call from the formulas

(defelem elem1 [] (div :class (cell= {...}))
(defelem elem2 [] ...)
(defelem container []
  (cell= (if condition (elem1) (elem2)))

and there u have a formula cell (the map for the :class) created/allocated within another formula cell (the conditional kids)

i hardly ever use cell children, i use static allocation whenever possible

i got that, but is there anything inherently wrong with this structure, or it's just more prone to memory leaks or it does memory leak for sure?

it really sucks that browsers don't have weak references

it will memory leak if the things it's creating keep references to live things in them

which u mentioned before but i still have no idea what does it mean 😞

ah, i see

weak refs are like pointers, but the things they point to can be garbage collected

i.e. they're pointers that don't increment the reference count of the thing they point to

and what happens if u dereference them after the data they r pointing to got GCd?

you get undefined

@onetome you will get DOM errors that way (I am dealing with this right now)

or the point is that u won't do that because the structure of your program just wont allow that to happen?

well like javelin for example needs to keep a graph of all the cells and how they're connected to each other

currently this means that the graph needs to be GC as a whole

flyboarder: can u give an example of an error u r talking about?

because there are references to all the things in there

it would be better if the graph could be GC piecewise, depending on whether your code references cells or not

a cell only referenced by the cell graph should be disposed of

micha: but then u would run ur own special cell graph GC to clean up the refs to the disposed cells, no?

no, it would just work i think

@onetom: sure, yesterday I ran into the issue where my nested cell's wouldnt work as expected because the cell's had already been evaled (maybe dereferenced?) so trying to reset the cell wouldnt work i.e. "Error: cannot change Number 0...." something along those lines it wasnt a cell anymore

we'd use strong references from a cell to the cells it depends on

and weak references from the cell to the cells that depend on it

flyboarder: thats sounds something different...

i was using the same method as your example

okay. what i mean i never saw such an error u just showed, that's why i suspect there was some other reason for that

pressing a button would constantly throw the error, I asked micha and he suggested getting rid of the cell=

and i saw quite a lot of errors and they are very memorable...

haha yeah 😛

especially when you are seeing them all day 😞

exactly

how are your nested cell's being built?

nested cells is a strong indication that something can be refactored and made simpler

@micha but what about the case as @onetom pointed out? that will happen in most apps at some point no?

i don't have nested formula cells in any application i've made with javelin yet

every time i thought i needed them i always realized that there was a simpler way to do it

brain explode

so i explained this to my colleagues today like this: u can control the attributes of dom elements reactively via cells, but the dom elements themselves should not be added to or removed from the dom reactively. loop-tpl however can "safely" add/remove elements to/from the dom so if u really want some elements to be sometimes present sometimes absent from the dom, then use loop-tpl somehow.

right or just show/hide

show/hide? u mean toggle?

loop-tpl will cleverly pool any allocated memory and reuse elements from the pool when possible

right

so although loop-tpl removes things from the dom it doesn't try to deallocate them

it puts them back in the pool and reuses them later

brain more explode

and wouldnt it make sense to have a similar solution for toggling?

onetom: yeah you're probably right

when i ask myself "why would it be good to not have the invisible elements in the dom?" im not very sure what would i answer, beside it's a bit confusing / disrupting / annoying to see a bunch of style="display:none"s in the chrome inspector

plus there is no 1-to-1 mapping between what i see rendered and what i see in the dom inspector

think about how hoplon would know where to reinsert it

like if it removes something from the dom

how does it know where to put it back?

im not sure but u solved that somehow with loop-tpl ;D

right

but it's slightly more complicated than just hiding

we'd basically make a mini-loop-tpl for toggle

we can totally do it

but do we agree on the reason why would such a thing be good? are there any other reasons? do these reasons worth having the added complexity?

i see this more like a social benefit

we would have to make a macro probably also

or at least a function

to lower the impedance between what ppl expect and what hoplon delivers

we couldn't use an attribute

i keep finding myself worrying about what goes into the dom... it's just not a good mental model that "things are there just hidden"

yeah, perhaps

not sure if CSS rules which rely on adjacency wouldnt break for example with the current model

imagine u have sections below each other but u dont want extra top margin before the 1st and after the last

what happens however if the 1st section is hidden?

this is a good example of when it's safe to use cell children

in this case all allocation is handled externally

the toggle function doesn't allocate dom elements or wire them up to cells

flyboarder: is there anything left from your brain still?

micha: i feel like im starting to understand what are we talking about

💥 :thumbsup:

we want to get to the point where we've carefully designed all the places where we're moving things in and out of the dom

because managing memory manually is a huge bummer

loop-tpl helps you in that way

we could add more like this toggle function and like that

right

well that shouldn't leak

because the old spans aren't referenced by anything

but like

(div (cell= (if show? [(span :foo some-cell "hi")] [])))

that will leak because now it can't be collected until some-cell is

is that good or bad 💥 ?

good

this is kind of why we don't want to even deal with this directly

it's not easy to reason about

this is what i don't like about reactjs really

the lifecycle protocols

which i found myself telling to other people too, but then i realized i couldnt explain myself clearly enough what does that mean, so probably they dont understand it either..

the IWillMount etc

init and cleanup for when things go into and out of the dom

yeah, i know what does it mean on the surface, but then thats it

like detaching event handlers?

also breaking references that will cause leaks

like if you hold a reference to 2 things in a closure

like (fn [x] (+ x a b))

this now links the GC of a, b, and the closure

if anything holds a reference to that closure then it can't be collected

and that means that a and b can't be collected either

with hoplon we can eliminate 90% of this kind of thing by just not churning things into and out of the dom

i also wanted to ask u if this when-dom is really necessary and why? is it just the handling of some edge case or it's a regular state during the dom assembly?

it might be useless now

it's from the beforetimes for sure

i saw there is with-dom using it but with-dom itself was not used anywhere within the hoplon lib at least

?

i think it might be from the first implementation of loop-tpl

(defmacro with-dom
  [elem & body]
  `(when-dom ~elem (fn [] ~@body)))

where we actually put a placeholder sentinel element in the dom

micha: oh, yeah, another important thing i wanted to mention. we saw some errors thrown from the test.clj... 1st i was puzzled and thought some test suite got packaged together with hoplon, but then i saw it's a helper namespace which was made to house a test result reporter within the browser. but it defines some cells and those were throwing errors when we were having these memory leaks...

maybe they shouldn't be there by default?

https://github.com/hoplon/hoplon/blob/master/src/hoplon/test.cljs#L22-L26

yeah we should probably make that separate

how was that being compiled though?

you didn't :require hoplon.test namespace did you?

and to make it absolutely clear: i was not trying to use it. i was not even aware it's there...

it's really weird that it would eevn end up in your project

perhaps there is an issue with the cljs compilation

yeah, i definitely haven't required it

i've also upgraded to 1.78.122 as i saw in hoplon/build.boot is it necessary for some reason or just that was the latest cljsc version which u tested?

i was experimenting with goog-define and there is a bug with that that was fixed in .122

i see. thx.

(that sounds a bit scary though... such an instrumental piece in the gcl still have bugs after so many year?!?)

it could be a bug in boot-cljs, i dunno

@onetom: not much left of it 😲

i'd use :toggle unless there were some reason not to

@micha do you know of any examples or references for castra with a db?

i'm using it with SQL server currently

have used it with datomic and postgres and mysql in the past

id like to use it with mongo

sure

but im not sure how im to wire the user auth up with castra

i'm going to make a screencast for castra soon

there is a clojure mongo client

i think it's called "monger"

yeah I was looking at that one

you'd want to use that probably

user auth usually involves storing the user id in the session

you can have a precondition (the :rpc/pre key) that checks that and throws an exception if no auth is in the session

castra exposes the session as castra.core/*session*

it's an atom you can deref to get the contents or swap! / reset! to set the contents

so thats how I can persist session data between calls

is there a session accessor in hoplon?

seems i need to run a local copy of the old site 😛

you need to use some ring session middleware

there is one that uses cookies which is what i use

it stores the session data in an encrypted cookie in the client

pretty much any ring session middleware will work with castra

castra exposes the session to you via *session*

so you can read and write to that atom

and the session data will be persisted in the cookie in the client

@micha: ok im looking at the castra-chat example https://github.com/hoplon/demos/blob/master/castra-chat/src/castra/demo/core.clj is this still a valid example ?

it's a little old

ok so then I dont really do much work with the response at all, just drop it at a cell and let the formula's react on it, the real work should be on the backend yes?