@micha: this what might happen if u forget to pay your internet bill in hong kong:

onetom@retinatom ~/g/b/boot> make install
(cd boot/base && mvn -q install)
[ERROR] COMPILATION ERROR :
[ERROR] error reading /Users/onetom/.m2/repository/org/projectodd/shimdandy/shimdandy-api/1.2.0/shimdandy-api-1.2.0.jar; error in opening zip file
[ERROR] error reading /Users/onetom/.m2/repository/org/projectodd/shimdandy/shimdandy-api/1.2.0/shimdandy-api-1.2.0.jar; error in opening zip file
[ERROR] /Users/onetom/github.com/boot-clj/boot/boot/base/src/main/java/boot/App.java:[24,32] package org.projectodd.shimdandy does not exist
[ERROR] /Users/onetom/github.com/boot-clj/boot/boot/base/src/main/java/boot/App.java:[40,20] cannot find symbol

the shimdandy.jar file contained a payment notice html 😉

wow

micha: quick question, why am i getting Unable to resolve symbol: regular-sync in this context when i run boot itc-regular-sync?

(deftask itc-regular-sync []
  (with-pre-wrap
    fileset
    (require '[itunes-connect.regular-sync :refer [regular-sync]])
    (print (resolve (regular-sync)))
    fileset))

(getting off the ferry, check back later)

@onetom: resolve takes a symbol, you probably want sth like ((resolve 'regular-sync))?

martinklepsch: ah, sorry. i was just trying resolve because i was getting that error message i showed. that's the real problem. but checking now what happens otherwise

yeah you need to do like this

(require 'itunes-connect.regular-sync)
(let [regular-sync (resolve 'itunes-connect.regular-sync/regular-sync)]
  (regular-sync ...)
  ...

the reason is that the clojure compiler compiles top level forms sequentially

meaning it fully compiles and evaluates each top level form one after the next

this is why you can do this at the top level

(require '[foo :refer [bar]])
(bar)

but if you do this you will get an exception:

(defn doit []
  (require '[foo :refer [bar]])
  (bar))

it treats the entire defn as a unit

it compiles the whole defn, and then evaluates it

but in the former case it would compile the require and evaluate that by itself

and then compile the call to bar and evaluate that

which succeeds because when it goes to compile the call to bar the call to require has already been evaluated

micha: thanks!

Hi. I have file like this http://dpaste.com/314RJ06 and what I want to do is "development in loop". Each time I save file (somewhere on the project) I want (main) fn to be executed. What I got now (with line 29 both commented out and not) so that it executes main and "speaks" two times each time I save the file. What am I doing wrong?

@juhoteperi: This is brilliant: https://gist.github.com/Deraen/eb3f650c472fb1abe970#file-edn-cljx

@danielsz: Transit version is a bit dated, one sec

@juhoteperi I love the edn version more

I rewrote it for cljc

The performance difference between EDN and Transit is so huge for browser env that Transit is usually better choice

The EDN version should probably use the same read and write functions as Transit version

cljs-time methods used in EDN version are really slow

there is a toIsoString thing in btw: http://google.github.io/closure-library/api/class_goog_date_DateTime.html#toIsoString

Yeah, I wonder why I did not use that

RFC3339 = ISO8601?

RFC3339 is one profile of ISO8601

@juhoteperi I hear you, but I'm working with a 100% Clojure system where all data flows as edn. Using transit just for performance reasons doesn't seem compelling to me in this scenario.

Speaking about dates, what do people think about implementing a date handling library completely on Clojure? It would remove the differences between JVM and Browser envs

@juhoteperi: Well, that is what you achieved with this gist

@danielsz: Yeah if you aren't reading the EDN in browser it's fine

The performance difference is only in browsers

you mean like a joda time in cljc?

@martinklepsch: yes

sounds like a big yak

@juhoteperi what do you mean with not reading the EDN in browser?

@danielsz: In browser EDN reader is implemented in Cljs/JS but JSON reader is implemented in C or such by the browser so reading JSON is much much faster than reading EDN. And transit is built on top of JSON so it's faster than reading EDN in browser.

@juhoteperi I know it's faster, but what are we talking about? Milliseconds. Not something I can notice (or the user).

@danielsz: Will be noticeable if the documents start getting larger, maybe tens of milliseconds for something like 200KB document.

it's definitely noticeable

for the kinds of apps i make

the clojure reader is extremely slow

@juhoteperi I don't think it's the size of the document that is the determining factor, it is the number of date instances in EDN that you read and write.

@danielsz: Nope, even with optimized date readers and writers EDN is slow

@martinklepsch: That's what I fear but currently handling dates is quite hard in shared domain logic code

@juhoteperi: maybe it's easier/more efficient to just wrap jodatime/goog.date in uniform way?

If you only have a couple of such EDN instances, I think it's perfectly acceptable. Not an optimization priority.

@martinklepsch: Yes, that's what I'm doing currently. Probably I just should finalize and make a library out of this to see how well it really works.

@martinklepsch: that's what's this gist does. It turns joda dates into edn entities that are read and written in an uniform way via the clj-time and cljs-time libraries (that offer the same API)

It is exactly what you want to do with dates.

@danielsz: They really don't. Cljs-time formatting is really limited.

And slow.

Unrelated idea: I'm thinking of making a lambda fn that takes a git repo as argument and returns documentation info (like cljs-info or codox but as edn/transit). From that it would be quite easy to make an app that can provide api docs for any git hosted clojure codebase — thoughts?

@juhoteperi: You keep saying that

At this point we need benchmarks

@danielsz: Yeah well usually it's not a problem but try rendering a table with 2000 dates and it is noticeable.

@juhoteperi: That's what I'm saying. I don't have 2000 dates. I have two dates.

@juhoteperi: @danielsz the gist only handles serialization ...I understood @juhoteperi as if he wants a thing that also provides uniform APIs to modify/compare/etc dates

Yeah, if/when I will implemented something proper I'll do benchmarks but currently if have just seen that in certain cases if will be a problem.

@martinklepsch: The beauty of this solution is that you don't need anything. The API is provided by clj-time/cljs-time.

Which lets you compare, add, etc.

That's leveraging the power of edn

Custom reader tags for the win

Yeah and it works the same way with Transit

Perhaps having a cljc-time lib would be one solution for even nicer shared code

That lib would also provide namespaces for EDN and Transit readers and writers one could use in a project without copying the code

@juhoteperi: Sure. That would be convenient. What I appreciate in this solution is the generality. Once you understand how to leverage EDN in your application code, you can apply that for any non-native type/object. joda time is just one particular case.

@andrewboltachev: what is your command line like? how are you running your code there?

@juhoteperi: @martinklepsch All this reader tags and edn affair in Clojure is in essence a streamlined and somewhat constrained version of Lisp's reader macros.

https://gist.github.com/chaitanyagupta/9324402#json

@martinklepsch: BTW, I like the idea you mentioned about the lambda fn generating docs from a git repo.

@danielsz: unfortunately there are plenty of html documentation generators but none of them has a simple api for getting this information as data 😕

@micha: boot db0001

If boot show --pedantic shows a few "conflicts", is that cause for concern?

not really

pretty much unavoidable

you can eliminate them by adding :exclusions to your dependencies

but i haven't found that to help much really

unless the exclusions are needed, like if aether is not choosing the transitive dependencies you want (i.e. you want to resolve the conflict differently)

conflict resolution is of course deterministic

so adding extra exclusions annotations probably isn't going to improve anything

ah

makes a ton of sense

I guess it's called --pedantic for a reason

it's important to be able to see the conflicting versions, because sometimes you need to tell it to resolve them differently

like if you add dependencies and all of a sudden everything is broken with weird exceptions coming from code you've never heard of

it's probably because some transitive dep was swapped out

yeah, I've had that happen to me a n few times

has anyone used closure modules yet from boot-cljs ?

@pandeiro: yes I use the Dom lib from google closure

Ah @flyboarder actually I'm talking about modules in the compiler sense, not the Closure library modules

i.e. http://swannodette.github.io/2015/02/23/hello-google-closure-modules/

I have an app at work that needs to be divided and I'd like to explore creating several JS artifacts with app-specific and shared code, rather than do two whole separate builds

I'm not sure if boot-cljs supports this yet

I'm guessing that with the *.cljs.edn convention, it doesn't

@pandeiro: ah I misunderstood, I don't think at this time it does

Which might be why boot has several artifacts and is made with make

I took at brief look at building boot with boot but it's a bit beyond me, I'd really like to get it working on clr

the .cljs.edn convention is what will make it possible to do automatically in the future

Oh yeah @micha ? Have you guys already thought about how to integrate this?

given a set of .cljs.edn files, the compiler has enough information to automatically partition your namespaces into modules in an optimal way

because the .cljs.edn files contain all the information about which namespaces are needed in which compiled js file

and we make a new shim or whatever to load the modules correctly, automatically

so what would the API look like in boot-cljs? an additional parameter of some sort...

yeah just --use-modules

no configuration needed

maybe it could be the default for advanced optimizations

I like

Is the naming default?

that's an implementation detail

the user never needs to see it

so we gensym the name

there is nothing reusable in those modules

you can't distribute them or anything

right, but you need to have index.html load the e.g. common.js module

so you need to know what it's going to be called

no, that would be done automatically

in the js

even in advanced, it would be shimmed in?

via document.write()

yeah

whoa

we did it before, it worked fine

that's how we originally solved the --unified mode thing

before cljs adopted the technique

cool

does the use of modules have an impact on compilation times? do you know?

you wou'd only use this in advanced mode

right, only in advanced, sure

it probably takes longer to make the modules

yeah I imagined

you don't do it very often though

but I also imagine the time is significantly less than producing two whole builds

you have to produce the whole builds though

ah, right

you still need both cljs.edn files

plus the extra work of figuring out the module stuff

hmm

i bet it takes 50% longer

i was thinking it would somehow be a single pass through

oh, yeah that might make it faster

could two boot-cljs processes be run at the same time in parallel?

and would it even make sense to do so?

like, to speed up two builds

yeah it would be twice as fast

i imagine using the new (target ...) task that was added recently

if you have enough memory

interesting

could you build both simultaneously to the same target?

yeah you could also use the --target option to point the different boot instances at different target directories

no, that would be madness

lol

but cp -R ... is your friend there

yeah sure, I can bash at that level

I think

there is a way to do it all from inside of boot if you really want to

I'm gonna try that, though I wonder if the instances we're using to build will have the requisite memory

How would that be?

like with futures?

https://github.com/micha/multi-module-build

that's an example

that is cool

what is with-pass-thru ?

it's in master now

it's equivalent to this:

(with-pre-wrap [fs]
   ... ;; do something
  fs)

now you can do this instead:

(with-pass-thru [fs]
  ... ;; do something
  )

sometimes a task is only for side effects

and doesn't touch the fileset

that's what with-pass-thru is for

ah ok, nice