@qqq @micha i think d3 has key functions too, for diffing data structures that need to be rendered to the dom (not just strings), so the approach a lot older/more common than just a react internal

Hi guys, i have some vague questions about about how to approach working with structured data for a to-do list app.

I am used to working in outliners, so I'm looking at zippers, and trying to understand TheLarch Hoplon example.

https://bitbucket.org/alandipert/thelarch/

btw https://github.com/tailrecursion/orcus/ is a slightly simplifed thelarch

ps. I noticed a commented out reference to thelarch in Panoply. https://github.com/hoplon/panoply Since Panoply is a todo list, is there any relation?

we're not sure what panoply will be yet, last idea is a chat app lol

i just lifted the oauth code

I still have to digest Hoplon TodoFRP too https://github.com/hoplon/demos/tree/master/todoFRP, But I think that doesn't have any nesting.

Oh ok

I have heard Micha talk down on clojure.zip in favor of Jquery as a zipper library. But in what context? I think I will be working with clojure data (immutable?)

And I've heard others distance themselves from zippers in favor of Specter (which in addition to the lens approach, has it's own zipper library)

https://github.com/nathanmarz/specter

Does Specter play nice with Javelin? Are there advantages to using it over Javelin lenses? I don't want to get to far away from Hoplony goodness 🙂

I'm doing primarily cljs with Firebase ala @flyboarder Brew library. https://github.com/hoplon/brew/blob/master/src/hoplon/firebase.cljs.hl Since I still have not figured out how to deploy a proper clojure app (Heroku noob)

I am still a clojure noob in general, and am eager to get something working. Should I be wary of zippers, in favor of lenses, for easier grokking?

@alandipert Thanks for the Orcus link, I didn't have that one

... Or should I stick to the theLarch pattern as pretty idiomatic Hoplon/Javelin?

In my outliner apps, I like to use aliases and saved queries on metadata. So then the tree really becomes a graph. So should I be looking past zippers for more graph-oriented patterns? Perhaps Datomic/Datascript?

Again, I want to edit this thing with Hoplon UI, so I dont want to steer to far from Javelin

ps. maybe with all of this I need to be less focused on fancy libraries and getting more familiar with Clojure data (Zippers, Seqs, patterns, etc)

Any guidance would be appreciated.

@micha I know your have some experience with zippers so I would love your opinion. Thanks!

hi @chromalchemy !

i think i was referring to "functional zippers", meaning the immutable things

like where you operate on a zipper to get a new zipper

leaving the original untouched

imo that has little value as an abstraction over the dom

because the dom is not immutable

zippers can be useful for navigating immutable data

i think we did something like that in thelarch

but if you want to do stuff to elements in the dom, i find the immutable zipper abstraction to be inferior to like jquery for example

I am thinking more like I have data that I CRUD w Firebase, then render to and edit in a page.

Am I correct that my case is a different one than accessing the Dom-as-data (with zippers, etc), and that the functional zippers might be very appropriate (vs Jquery)?

definitely

@micha Ok. What do you think of clojure.zip vs Specter vs Javelin Lenses? (especially on the cljs side for Specter vs Javelin)?

and all that vs Datomic/Datascript?

I guess if I had datomic I wouldn't need Firebase. I am not at the level to re-implement my own database. But I like how Firebase seems simple and accessible, (and client-only deploy) and might be very good as an accessory db.

i like the idea of firebase

specter could be used in javelin formulas, no?

it's just functions right?

I tried something and got errors, I'll have to try again.

Is using Specter redundant considering I already have Javelin lenses at the ready? What is the conceptual overlap?

i haven't used specter, but isn't it a library for destructuring clojure data, basically?

i don't think there is any overlap with javelin really

the specter functions can be used in javelin formulas

or lenses or whatever

"abstraction called navigators which complete the story around immutable programming and make it easy to transform and query nested data structures. It allows you to concisely specify what you want to change within a data structure, and get a new data structure back with only your changes applied – everything else is reconstructed and the types of data structures throughout don't unexpectedly change."

https://news.ycombinator.com/item?id=10295060

" Specter is (at least in main use cases) Haskell's lens package"

looks like it's just functions

you can use any function in a javelin cell, no problem

like here for instance http://nathanmarz.com/blog/functional-navigational-programming-in-clojurescript-with-sp.html

you can do (def banks (cell= (user->bank world-cell name-cell amt-cell)))

whatever

"Definitely more lens than zipper. If you think of a lens, in simple form, as a path into a structure then a zipper is a structure plus a path into itself. This constrains the form that a zipper can take. If you examine these paths on their own then you get into general "optics" which is where the lens type lives and where specter lives (it seems). In particular, we start talking about generalized folds and traversals."

Ok , thanks for the insight. I'm just trying to orient. I haven't used it barely at all yet.

I thought that if Specter is promising an easier approach than zippers. But if it is essentially lenses, and Javelin has lenses, maybe Specter is redunant for my purposes.

I remember @laforge49 had a project with both Specter and Javelin lenses in it. Javelin on the client, Specter on the server.

https://github.com/tiples/welcome

specter works on immutable data

specter doesn't provide a "reference type"

javelin, on the other hand, doesn't do anything but provide a reference type

so there isn't any overlap really

in other words

specter's api is a collection of functions, correct?

and macros

let's call those f, g, ...

Yeah.

there is no reason why you couldn't do (cell= (f x))

where x is some other cell perhaps

Ok, I'll play with them both together. Thanks for the clarification.

@laforge49 What is your impression of Javelin lenses (strengths, limitations?) after doing your own lens implementation https://github.com/hoplon/demos/tree/master/lens, and also using Specter

Javelin lenses are best on the browser, where the scope is narrow enough (single user) and the resources per user is maximal (100%). And Javelin has a number of optimizations that can at times be helpful. On the server side, specter looks really great and I used it, once. I just don't seem to encounter enough use cases, for which I am currently blaming myself. I've ended up adding notifications capability to my Datomicish database, but even there the usage to date is minimal.

@chromalchemy maybe interesting to you, https://github.com/alandipert/intension

competes with specter in the 'get' arena. no facilities for update

also, wildly inefficient. but that could easily change... https://github.com/halgari/odin is another recent thing that uses a different logic language

@alandipert Very interesting! I definitely want to play with Datalog

@alandipert Can Intension be used in cljs?

hypothetically

ok, yes it can

https://github.com/alandipert/intension/blob/master/src/alandipert/intension.cljc

not much to it

Cool! Will try it out.

this is tl;dr of how it works https://pbs.twimg.com/media/CXkTdHaWwAAmrhM.png

@chromalchemy http://github.com/mynomoto/github-client is a project using hoplon and datascript if you want to take a look.

@alandipert : although I like hoplon's frp model more than I like reagent's reactive model, re-frame's re-com and re-frisk (amazing!) has won me over; I hope hoplon / javlin / casatra have more public libraries soon!

@qqq did you check out https://github.com/hoplon/ui?

damn you're a good salesman

haha, 'one last thing'

is there a live demo of all gui widgets? I can't find it on https://github.com/hoplon/ui/wiki

no, it's sort of a well-kept secret, very close to 1.0 release tho afaik

http://re-demo.s3-website-ap-southeast-2.amazonaws.com/ <-- see, this is re-com's marketing

nothing we have has the momentum of reagent/react/re-frame

they're piggybacking on React

@dm3: why would "piggybacking on React" be an advantage of a cljs lib ?

it's good for marketing

all the devs coming to Cljs go: Google [React clojurescript]

at this point the cljs web devs i know won't even look at something that doesn't involve react

which has kind of stunted our growth a bit... but we are still slowly growing

you need to market Hoplon as "CLJS Beyond React"

not: Google [react too complicated clojurescript ui]

so it also gets all the "CLJS React" searches

in fact, I'd go a step further and rename the "hoplon" oroject to "cljs-beyond-react"

yeah i dunno

it's not really related to or inspired by react in any way, other than that it solves a similar set of problems

so it would be disingenous to say we're going beyond react when we haven't even used react yet 🙂

yeah

it's an alternative

with React you can use stuff like React-native

I've used React (via reagent, re-frame, om)

adds nothing over Hoplon for web-apps

or, I guess, adds a number of pre-defined patterns of how to structure the application which matters once you grow to a certain size

a lot of people like that

people with more rails type mindsets, and junior people. clear directions

I wouldn't recommend Hoplon to a team of 5 people where noone is experienced with it

much easier to start off with re-frame

I'd say that reagent offers nothing over hoplon, but re-frame's single db source of truth + subscribers + event handling system is neat

it's neat, but the single db is isomorphic to the network of cells

javelin / reagent basically provide the same primitives, with javelin/cell == reagent/ratom

so you ultimately gain nothing

that's the part i personally would avoid.. having built a medium-sized eventbus-based thick client 5 yrs ago

its part of the reason we decided it was important that cells can be anonymous

that's the difference between javelin and ratoms i think

the dependency graph

plus the cell manifesto type guarantees

ie each cell updates at most once per propagation

javelin gets dependency graph via macro analying the code; and re-frame gets it via running the reaction, and looking at what's dereferenced -- right?

javelin doesn't need macros

that's just syntax sugar

isn't cell= a macro?

it is

without macros, how do you analyE which cell depends on which cell ?

but it just expands to a call to the formula function

how do you figure out what cell depends on which cell -- do you do it at compile time or at runtime?

(cell= (+ a b))
;; same as
((formula +) a b)

where formula is just a function

(cell= (+ (* a b) (/ c d))) expands to ((formula +) (* a b) (/ c d)) ... but now, isn't this fucked, because we need to know it depends on a b, c, d, -- rather than use their values ?

if you macroexpand (cell= (+ a b)) you'll see that's what it emits

no that's not how it works

(cell= (+ (* a b) (/ c d)))
;; same as
((formula (fn [v w x y] (+ (* v w) (/ x y))) a b c d)

it doesn't "hoist" core names, like +, *, or /

but if you did like

(cell= (f (g a b) (h c d)))
;; same as
((formula (fn [x1 x2 x3 x4 x5 x6 x7] (x1 (x2 x3 x4) (x5 x6 x7)))) f g a b h c d)

can se say: cell= finds all the "leaves" of the following sexp cell= then cfeates a new function, where there ar e"holes" for each leaf, and it applies formula new-func leaves

it hoists names that could be cells

by deep code walking macrology

it knows how to extract names of things that could be referring to cells

syntactically

there is also the formula-of macro

(cell= (+ a b))
;; same as
(formula-of [a b] (+ a b))

okay, so very broad strokes of cell= ` (cell= sexp) leafs <- leafs of sexp possible-cells <- filter [some matic function] leafs new-func <- sexp as a function with holes for "possible-cells returns [ formula new-func possible-cells ]

sure

there is also fomulet

but the dependency graph is important

if you have like

yeah, that's where you run topolotical sort

to ensure everthigni is updated only once?

yeah to guarantee they are updated in the correct order and only at most once

reagent's "possible multiple update" is quite annoying

I don't understand why they don't just run topolotical sort after they extract dependency graph

so no formula can see the world in an incomplete state

the ratom depends on dynamic vars and stuff

that's intersting; I never considred out-of-sync udpates as "world in incomplete state"

it's not a real reference type, as in first class as far as i know

a javelin formula is more of a declarative way to establish an invariant

and less of an event handler

the ratom seems more like an event handler

this is kinda disguisting; but maybe I can use javelin / reagent / re-com

when you want to make complex things from small pieces the dependency graph becomes important

so my dependency graph is expressed via javelin

then at the edges of the javelin cells (i.e. the leaves with no children), I attacha reagent atoms

those regent atoms then lets me use re-com ui elements

this is frankenstein, but I like it

haha maybe it will work?

I will let you know in a few hours 🙂