@darwin understood. I'll bring the with-meta up a level and try that.

I could send...

be careful with that if the web worker can potentially be compiled against different cljs version

(with-meta ... worked, btw)

good

what do you mean, against different versions?

my point is even more subtle, assuming you compile both web worker code and main frame code under :advanced, but different sets of sources, the names of javascript functions will be renamed to different names

so even cljs.core library function names won’t match

understood

Yeah, we'll see if sending sources is sufficient. I could be that most of the functions people would want to send over will often have dependencies on functions that don't have source, nor exist on the worker agent side...

why do you need to send the sources? why don’t you let them compile their own js file for the web worker

and then just define mechanism how to dispatch those functions from main frame

(send-off compiled-fn param1 param2)

simplest one would be to use ^:export and call them by string name

(how do I apply compiled-fn to param1 and param2 on the worker side, if compiled fn is js and param1 and 2 are cljs datastructures?

param1 and param2 must be serialized to JSON, there is no way around it

right

so I guess you need some kind of pluggable marshalling in place

yeah, I have the marshalling in place. Using butler

so that user can specify how his data is serialized and de-serialized

but the resulting js has no .call function, that I can tell

what is "resulting js"?

It's probably something simple, but I couldn't figure it out. js* is a single parameter function

what would be wrong with: (dispatch-on-worker “some.fn.name” param1 param2 …)

just sending the + function will send the js of that function, rather than the name or the var

and your code would do the marshalling and call js/some.fn.name in the worker’s context

I'd like it to be even smoother: (dispatch-on-worker + 1 2)

what goes over the "wire" to the worker is the js of +

this is not going to work. good luck 🙂

🙂

in general case I mean 🙂

right if I could apply the js that '+ returns to things, I could just send the js

But regarding sending sources, I have that working now.

Won't know how useful it is until I implement more of the nuts and bolts

I understand that you can eval arbitrary js snippets in worker’s context. But that does not solve other code that the snippet might depend on.

so your saying the munged names of core fns referenced in one js snippet may not match the names in another worker? or something different? What if both the main thread and the worker are leveraging the same munged code base?

or is there something more sinister afoot?

let’s assume :none for now, and both have the same cljs compiler version

then names will match and API will match as well

you can write a macro which will expand (dispatch-on-worker + 1 2) to something like (dispatch-on-worker 'cljs.core/+ 1 2)

on worker side you would interpret that 'cljs.core/+ and invoke proper core function with de-serialized params

serialize the result and send it back to main frame

that's essentially what I'm doing

by shuttling code

cljs code

this is not sending code, this is just sending an identifier what to call on other side

kinda poor mans RPC

Well, + would resolve to 'cljs.core/+ on the other side. But if there are any vars not defed on the other side, the sent code obviously won't run. So if you want the other side to have that function, you should send it the "(def code..." fn and then it's available there. right?

and who would compile the cljs code for the worker?

the worker speaks js not cljs

the worker. It has a repl on that side, using replumb

aha, ok, then that’s a different story 🙂

so you have full self-hosted cljs compiler in the worker?

yeah, it's a "self-hosted" hack sort of story 🙂

so there's a large body of gotchas for the end result

but you end up with something that feels like a clojure agent

because agents are supposed to be asynchronous anyway

I’m not familiar with clojure agents, I’m sorry

this sounds a bit heavy-weight to me, but depends on your use case

very heavy weight, as of right now

also I assume you would want to have multiple agents (workers), so each would have its own self-hosted compiler with own compiler/REPL state

yup. averaging around 4 in a pool. Spawning others as necessary.

interesting project, but I’m concerned about its practicality 🙂

have fun!

mostly not practical in the browser 🙂

The book Clojure Programming, by Chas Emerick, Brian Carper and Christophe Grand, has a pretty good example of using agents to implement a web crawler. So if you want a web crawler in your browser 🙂

Thanks! I'm having too much fun on this, for real.

anecdotally, last time when I needed to move some more serious clojurescript work off to a worker was reading/parsing jobs in my experimental ClojureScript editor[1], I ended up sending diffs of the data structures serialised as JSON, it was fun to write it, but ended up not very practical [1] https://github.com/darwin/plastic

hah I'm a huge fan of structural editors. I def think clojure and some structural editor will be the perfect combo one day.

I'll check out plastic

not usable

ah

I’m still tempted to restart the project, but next day I realise I would kill few years of my life this way 😉

What else are you going to kill a few years with 😉

some other experiments 😜

just recently I discovered this: http://skew-lang.org, the author did amazing job, I think skew could be great language for low-level engine and cljs for high-level business-logic part (e.g. this example https://github.com/evanw/sky)

unfortunately he is busy working on his startup and nobody really took over

So I have a lot of this agent stuff implemented =>(def a (agent 1)) #'re-pl.repl/a => a #object [Agent 1] => (add-watch a :logger (fn [key atom old-state new-state] (println "old:" old-state) (println "new:" new-state))) #object [Agent 1] => (send-off a inc) #object [Agent 1] old: 1 new: 2 => @a 2

this is hard to read, why don’t you use gist or that “+” button in slack client? it syntax-highligts clojure

oh nice

cool

Though that inc won't actually work without a version that has source. I could make send-off a macro and have it quote the fn parameter if it's not a MetaFn... which would assume the symbol is bound somewhere on the worker side. hmm

Now that spec is around, how are people doing testing for clojurescript apps? I like the idea of generative testing, but I don’t know how to begin for testing a UI.

Generative testing (whatever that means in practice) is very interesting, but I don't think it's a replacement for manually written tests.

Testing UIs is inherently difficult, IMHO.

I'm inclined to think that the best approach for relatively small projects is to look at them, when it comes to testing what they look like.

But that's a very good reason to do as much as you can to decouple what things look like from what determines what they look like.

You can test the latter.

^^ this is why libraries like React/Om are great. Pure functions of data -> dom. Test the data. If there is branching in your UI code, that’s where bugs will live. So minimize that as much as possible.

I agree. I've been doing a lot of snapshot testing lately actually and...

Honestly, it's the sort of thing you would have a had a hard time convincing me of a while back, but..

I think I am a convert now.

I've stopped thinking of manually written tests as some sort of proof of correctness. I've started thinking of them more as a tripwire to tell me when I've really broken things.

different types of tests can be used for different reasons

e.g. driving a design vs. a regression suite

and others

Well, I've never been much of a TDD person.

it’s a good practice to get good at, it comes in handy every once in a while

but I don’t TDD every line of code that I write

I write tests first only in the absence of a repl, tbh.

but when I’m struggling for a design, maybe

For instance I wrote a computational geometry library in C a couple of years ago, and...

It was written test first because... how else was i going to exercise the code?

But that didn't require a great deal of design.

Just functions that had to be correct.

The tests still missed some cases 😉.

I imagine combining spec with something like https://github.com/tmarble/webica will have interesting results for UI testing

though something like this would probably run the tests much faster: https://saucelabs.com/blog/headless-browser-testing-with-casperjs

but I'm not sure if you'd get to see the results with a headless solution

like, visually

Yeah- the thing I guess I am getting at is that with a decent repl, and editor support for it...

TDD becomes less a thing, IMHO.

Tests remain important.

I'm doing lots of node and JS for work these days and... the lack of an integrated Repl is making me nuts. It's enough to drive me to TDD 😉.

I am inclined to think that TDD, if purely practiced, leads to a lot of hill-climbing.

Then again, so do other ways f writing code, so...

In fact, if I had to levy one real criticism against the code-bases I've written and had to work with, that were not obviously bad...

It would be that they tend to get stuck at local maximums.

@tagore We do have quite a lot of automated tests, and these days I am trying to do generative testing (without success). We use reagent, and we have basically 3 types of tests: unit tests for usual functions, and for controllers which basically transform the state atom (a lot of async tests here). We also test the reagent components, in 2 ways: "in tests" which is when we pass some data, and it gets rendered on the screen so then we check whether what was supposed to be rendered is rendered, and "out tests" where we render the component and perform some action trying to see it it invokes the right functions with the right params.

I think we could use generative testing with the components, basically generating what goes in, just to see if it still renders on screen, even though speed might be an issue here.

Can anyone share a good way to load a configuration file into a clojurescript project?

runtime or compile time, @danielstockton ? if the former, it’d have to be on the page (as a <script> tag) or via XHR, if the latter, via a macro?

Compile time, macro could work yeah.

@danielstockton I recommend sticking to goog-define and :closure-defines to configure CLJS. this way the closure compiler can make intelligent use of the configuration and maybe even remove some code it otherwise could not.

also there is currently no way to tell CLJS to recompile a file if your config file changed

so you have to manually clean everything if you change it

I looked at :closure-defines but it looked like they already had to be @defined by closure. goog-define looks like a macro to define my own defines? Do you know of an example of this being used anywhere?

Nvm, found this: http://cljs.github.io/api/cljs.core/goog-define, thanks!

yeah thats it

The problem with closure-defines is that I have my project.clj checked into git. This config should be outside of git so that my fellow developers can change some settings for their local environment.

you can execute code in the project.clj

maybe that can read the defines from some other file?

You're right, thanks.

trying to get started with leiningen following: https://clojurescript.org/reference/dependencies#using-leiningen

however lein cljsbuild auto just results in Compiling ClojureScript. - it never completes

(after retreiving all the deps)

It is waiting for changes?

any ideas?

the only output I get is Compiling ClojureScript.

Change a file.

according to tutorial I should get a green complete message

nothing happens when changing the files

Hmmm, strange...

now I'm not familiar with clojure etc but these dependencies seem old?

:dependencies [[org.clojure/clojure "1.6.0"]
                 [org.clojure/clojurescript "0.0-3149"]
                 [cljs-ajax "0.3.10"]]

isn't clojure up to 1.8? and clojurescript "0.0-3149", sounds like pre-alpha?

That's a good question. You can certainly have more recent versions than those.

dbackeus there’s a very nice plugin called lein ancient that answers these sorts of questions automatically

https://github.com/xsc/lein-ancient

if you let it, it can even upgrade all your deps automatically

Recent versions of lein-ancient probably won't even clobber your project.clj while automatically upgrading

and yes, those are all very old deps

well that's nice, but first off I'd like to get the build to work at all

I updated to the latest versions in the project file

bja if my project.clj wasn’t in git any consequences of that are my own fault anyway 😄

ok first run was similar to old versions where the last message would be "Retrieving xxx from clojars" and it would be stuck forever

I was just commenting that it actually works now. The first few times I tried it, it got confused and made me git checkout project.clj again

second run Watching for changes before compiling ClojureScript...

let's see if I change a file now...

but I feel like I used that a couple jobs ago in like 2012 or 2014

err, 2013 maybe

oh hold on

I just created the core.cljs in the root of the project but I guess that needs to live under src?

I was only interested in Leiningen so I assumed I didn't have to go through the entire beginning of the tutorial

yes working after putting it in src/hello_world/core.cljs

a bit surprised at the ajax lib adding 110KB to the bundle, I'm assuming it has some more dependencies, is there a command I can see to understand the current deps tree?

dbackeus a pedantic point - “core.cljs” is just a convention, and it was arrived at because there isn’t a generic way to know what to call a project’s primary namespace. The one who institutionalized the convention is on record as suggesting that people should use other names if possible.

@dbackeus lein deps :tree

is cljs-ajax the idiomatic library for ajax communication or is there some newer thing around? (just thought it fair to ask since the tutorial seemed to use ancient versions of everything to begin with)

cljs-ajax is fine, but using js/AJAX directly is also cromulent

cromulent eh 🙂

https://media3.giphy.com/media/o1tTfJdrgEOcM/200_s.gif

even my Scottish wife was not aware of that word (I'm Swedish myself)

oh, sorry, it’s a joke

https://en.wiktionary.org/wiki/cromulent

yeah I looked it up

no worries 😄

thanks for the pointers, out for now

thoroughly impressed with this one line though: (GET "")

that's the kind of world I want to live in

@dbackeus Many people will also use goog.net.XhrIo directly and avoid pulling in a library. My remote namespace is 2-3 functions that use XhrIo.

@dbackeus I'd recommend using a more recent tutorial

and cljs-ajax is popular. as is https://github.com/r0man/cljs-http

https://github.com/ptaoussanis/sente and https://github.com/ptaoussanis/sente are my preferred options

both of those provide both server and client side implementations, making shoveling data back and forth super easy.

oops, sente and https://github.com/jarohen/chord, rather

never seen this:

https://github.com/jeluard/happy

apparently has interceptors, perhaps ala pedestal