#hoplon

what are the tradeoffs of lifecycles in your opinion?

lifecycles are a hack

like they make it impossible to make good abstractions

things that can be composed transitively

without exposing the transitive dependencies

because lifecycles don't compose

like IBeforeMount

once you start composing things you start to need IBeforeBeforeMount

ad inf

i've run into this myself many times

when i was being confused

it always ends up that later i realize my confusion and rethink things, and the lifecycles go away

to be replaced by composition and scopes

scopes and closures are the lifecycles of lisp

it's interesting though. because the thing we are building hasn't had to worry much about that sort of thing. we only have one hook in componentWillMount which is to add a watch to the cell/formula and then render which is merely the dereferenced value of the cell/formula.

oh and of course when the thing unmounts, you need to remove the watch. it's a very small amount of code.

when you start to make general purpse components and you compose them into other general purpose components you will need them

like most people make web apps the same way they used to with php

the app might be clientside, but it's still just a big printf

lol

once you go beyond that you start to have problems

i want to do more ambitious things

like get free of text files

we do have some issues wrt controlling when certain things happen and where that happen, notably things which must operate outside of the render part of the lifecycle.

i want to make elements that can be composed uniformly

well you'll get no argument from wrt text files.

and compose them in a visual tool

when you have lifecycles you can't really just compose things anymore

it's funny that you mention that because that is exactly the next thing we're doing once we get the compiler/data-format stabilized.

yeah it's crucial

the virtual dom is working against you with that

like with a visual design tool

because the dom isn't virtual

hey michaniskin whats up !

hey man!

how's the research?

speaking of research, michaniskin do either your alan have any links to spread sheet papers that are *free*?

will research again in march. closing of my consulting gigs :)

omg php

noprompt: the flapjax paper was all we needed really

there really isn't much more to it than that

michaniskin: how is the css-hoplon thingy coming along ?

mr-foobar: i haven't had much time to work on it lately

been busy with work and boot and stuff

noprompt: its not so bad given hiphop :)

michaniskin: I think my biggest pain with css is automatic cascading

what I really want is mixins but runtime !

came across a presentation by react folks who are looking into inline dynamic css or something

michaniskin: i suppose the next reasonable question to ask is: what are your thoughts on centralized application state?

noprompt: i'm for it!

noprompt: centralised state too simplistic. What you really want is a centralized database !

noprompt: with cells you can do it a lot better than with om for instance

for us, we've taken that approach in the extreme. there is no component local state. everything reads and writes data to the same location and that data source coordinates the propigation of that data through the cell network.

because you can have multiple "stem cells"

right.

noprompt: oh, that i'm against :)

it's important for "custom elements" (i don't want to say "component" because i don't mean the react type of component) to manage their own state

we never do any equality checks below the central source.

that interferes with separation of ceoncerns and composability

in my experience

michaniskin: not if it's transparent.

it's crucial i think to have scopes

we don't invent a new scope model, we just use the existing lisp scope mechanism

which is deifnitely sufficient for any programming need

when you have all state in a global blob, you either have to reinvent a coconut scope and a lisp-in-lisp interpreter, or you give up on the concept of scope

we don't want to do either of those things

i agree there. i mean it is possible if you want to go off main source to let a cell. our compiler has no issues with that.

yeah we leverage that to the max

elements can have their attributes set to cell values

that's how they connect to the rest of the program

but those cell values can be anonymous cells created by another element

michaniskin: there is one important use case for globalish scope. error handling and the likes of it.

we have state that's stored in "stem cells", which are cells that contain state external to the program

mr-foobar: i agree there, but that's via dependency injection in debug mode

like when you're debugging you can walk the cell graph and see the anonymous cells, no problem

but you don't want to expose that explicitly

not in debug, but in the application level.

oh, i don't see any need for that

how do you handle data flow jerks ?

in fact i haven't found error handling to even be a thing in javelin

jerks?

a -> b -> c -> oops the value isn't right -> d ...

i don't understand

you get an exception there

you fix the bug, and move on

it's pretty hard to have wrong values in cells like that

yup thats pretty much where globalish stuff can help.

definitely a bug you want to fix

right, but in debug, not in production

even in production you need to show some kinda error right ?

nothing other than a generic "something went wrong" message

it's extremely rare to have that happen, in practice

like how often do you get ###VALUE### in excel?

i mean once you've debugged your formulas

hardly ever

but its definitely useful to have something more than a generic error

what would be an example message?

that would be like ENUM in C :)

*ERRNO

you're not going to show your users some kind of weird cell stack trace

you're just going to tell them that what they tried to do failed

for some technical reason that they can't do anything about

heh I want to show precisely a cell stack trace.

then deploy production in debug mode?

except in better prose.

so you need a specialized debug mode

in games for example, "loading scenes, loading graphics .... "oops something went wrong" ...."

well that wouldn't have anything to do with cells though

sequential processes aren't modeled with cells

you'd do that using js promises, core.async, or just queues manually

yup and some globalish stuff.

core.async + cells are win !

one for data flow and other for control flow

right

michaniskin: you should checkout pure data https://www.youtube.com/watch?v=70KvnEUHS4U

oh cool

i need to listen to more experimental stuff.

i've been avoiding it for to long.

michaniskin: those are the kinda apps I want to do in hoplon :)

lately i've been getting back into the work of early surrealists. so many great ideas in the late 1800s and early 1900s wrt art.

debugging and error handling become important for end-users because they sorta program the application

that book is wonderful.

woah .. that's definitely not real :)

error messages -> error handling -> debugging in that order.

most of the time, debugging is necessary because error messages are so shitty.

cljs is not really a good choice if you want to make an application that can be reprogrammed at runtime

you end up making a coconut lisp inside of it to get dynamic behavior

programmers have not been sufficiently learned in the art of communication in english.

oh it is I assure you !

but you are right about re-implementing lisp in lisp.

however I would re-implement unix pipes rather than lisp.

if you find yourself doing something like [:foo bar baz], where that means call a function associated in a map with :foo, you're making a coconut lisp

yup. I would go more low level and start with a some kinda job processing system.

i'd probably look around for a dynamic lisp that can run in the client

something self hosting

there must be some that are good

i think it is okay to reimplement a basic lisp if your requirements call for it.

there none I am afraid. you don't all the goodies.

noprompt: sure, but reimplementing it inside of a better lisp is what i think is coconuts

rather than just using the lisp you already are in