bREPL can now properly handle absolute paths (it wasn’t quite complete before)

@dnolen Shift-Ctrl-Cmd-4, then Space and then click on the window

@mfikes I fixed up most of your new reports btw

self-host appears to work now, etc.

Cool. Eradicate all the bugs 🙂

I'm curious what clj aliases people have found useful for CloureScript dev. I've been using a :local/root one that also adds the main opts, which it looks like David must be doing with -A:cljs

:aliases {
     :cljs-dev {:extra-deps {org.clojure/clojurescript {:local/root "/Users/mfikes/Projects/clojurescript"}}
                :main-opts ["-m" "cljs.main"]}
  }

@mfikes I actually am not using local root for :cljs - too slow 🙂

I just put in the latest build

probably a :cljs-dev one for :local/root makes sense

Oh, so you do a script/build, then you edit your ~/.clojure/deps.edn to match the build number?

yeah that’s what I’m doing at the moment

Cool. Glad I asked. Still trying to learn what workflow works best with this new capabiliity.

hrm … should we just set -d to a temporary directory if a user invokes -r (not the -c case)

via (File/createTempFile "out" nil)

Yeah, I was trying to think what conditions that might make sense. The only thing I could think of is if any directories in the classpath (usually only "src") doesn't exist on the filesystem...

I was also pondering if any other systems use something akin to -d TMP or some symbolic representation of the idea...

@mfikes :output-dir is just for compilation artifacts anyway - in the -r case you just want to make a REPL

you don’t really care that we need the file system

I didn't know about that createTempFile API. It looks like it doesn't make a directory. I used

(defn- ^File make-temp-dir []
  (.toFile (Files/createTempDirectory "cljs-cli-test" (make-array FileAttribute 0))))

Agree to have reasonable non-invasive defaults unless you pass explicitly :output-to or it is in -co

But, yeah, if there are clearly combinations of flags where the out dir is just a "scratch space" that makes sense.

At this point it could even be a subfolder in .cljs

On an unrelated note, today I have open a CLJ Jira having the end goal of passing an option map to the cljs socket repls: https://dev.clojure.org/jira/browse/CLJ-2331

master now makes temp dirs for -r only cases w/o -d set

no affect on -c + -r

I guess -m could work this way too?

Only thought I have on that is that if you are, say, running unit tests using -m to start your test runner, then maybe making a temp directory would cause everything to be rebuilt? But, perhaps that is OK, because if you want it to be fast you opt into explicitly setting -d.

Actually, this is pretty close to the way Planck and Lumo work. They don't cache unless you opt into it.

Backing up, maybe the question is: When do you really care about the output directory? - When you are compiling something and you actually care about the artifacts. - When you are running something "again" and you want it to be faster?

yeah, otherwise you don’t really care

and with global caching, it’s not even going to be that slow

Maybe the idea of "I care about the output directory" equates to "I'm explicitly passing -d"

Hmm.

I’ve done this for -m as well

feedback welcome but I suspect you’ll almost always combine -r with -c if you want to keep working on something

Cool. This might work out to make things simpler for a lot of use cases. No dirtying the filesystem unnecessarily or adding the complexity of end-users worrying about it.

-c gives you default local :output-dir which it feeds to -r

@mfikes yes

Do you automatically recursively delete the temp dir? Or is this one of the directory types that Java cleans up for you on exit?

(Thinking of (File/deleteOnExit ...)

@mfikes oh are /var/folders not managed by the OS?

They are on macOS, definitely. I think on reboot or after a long time or somesuch.

yeah, so I’m not worried about it then

Maybe the Linux and Windows folk would care. Yeah, they can provide patches.

also this only for user driven behavior via cljs.main

not general behavior for REPLs

It's interesting that cljs.main and shared AOT caching, when combined, are more than the sum of their parts. 🙂

Surprising outcome 🙂

yes

I’m tweaking master so that you can combine -c with -s

for advanced builds (REPL doesn’t make sense)

clj -m cljs.main -O advanced -c hello-world.core -s

or

clj -m cljs.main -O advanced -c hello-world.core -s localhost:9001

done

the default stuff is pretty fancy now 🙂

Awesome, I can't measure a difference in

time clj -A:cljs -d out -re node -e 3

time clj -A:cljs -re node -e 3

ha 🙂

yeah everything in the ClojureScript jar itself get’s cached

I didn’t really intend that, but of course anything in JAR goes through that path

pprint for example is a killer

Haha! This is gonna put Planck and Lumo out of business. 🙂

that’s why the REPL is starting so fast now

@mfikes hah, not quite - but it certainly makes CLJS feel snappy

which it definitely did not before

Well, truthfully, Planck and Lumo are fast to start up, but oftentimes I wan't to check behavior for non-self-hosted ClojureScript. And this is much faster to start up a REPL and more easy than before.

yes - just sharing problems this is a game-changer

Jannis Pohlmann’s om.next report was particularly cool example

or all your reports in JIRA now @mfikes

My current workflow is lumo REPL + JVM compilation. The biggest winner (I would consider switching to Cljs non-self-host!) for node is the socket Repl. Prepl is the way to go for tooling. I am putting together some work on inf-clojure for improving things and hopefully at some point we'll have a socket prepl that runs the same as the terminal one. It is just a matter of coming up with the correct accept function I know 😄

The cli stuff is great for CI as well, so I will probably also move tests to clj + cljs.main

Fortunately it is going to be just a small script change.

@richiardiandrea good to hear, yeah after the release I want to loop back and see if we can make the REPL/pREPL + socket repl smoother - the Clojure API is a bit limiting

cljs.main can probably just support it directly and we have enough flags to give you control w/o writing a lot of custom code

@richiardiandrea hrm actually I see for -Dclojure.server.repl="{...}" you can pass :args for the :accept-fn

anyways - should ruminate

above I’m implying you really shouldn’t try to use cljs.main instead just invoke the REPL you want with the options you want via :args

@dnolen yep you can and the Jira is exactly about that: now args accepts a vector of strings...if we could pass a map (or edn, more generically), we are good to do -D....="{:accept .... :edn-args $(cat cljsc_opts.edn)}"

ah k

yeah so changing cljs.server.REPL fns to take args

Yep take an arg that is map-like...or we'll need to convert to vec of strings and back to map

Sorry on mobile

Doable, but uglier

Actually probably not duable because we have nested maps in cljsc_opts.edn

:args looks like it will be EDN

in Clojure socket REPL already

not string

Oh, so I am misinformed then :)

I saw this guy here: https://github.com/clojure/clojure/blob/master/src/clj/clojure/core/server.clj#L90

Sorry wait

Line 90

And https://github.com/clojure/clojure/blob/master/src/clj/clojure/core/server.clj#L77

@richiardiandrea https://github.com/clojure/clojurescript/commit/265f398c2eec62aef2c7daff108c89da865ac562

@richiardiandrea you don’t need to compose with main

I think this is all you need

we could add main support later, but this should be good enough to get you going

first step is to just compose with Clojure stuff 🙂

Thanks awesome, yep that was necessary too. Will try things out, probably that jira is still good as improvement but I can close over my own accept fn with you last patch

@richiardiandrea you don’t need your accept fn anymore

that’s what this fixes

all standard socket REPL accept fns take args now

Ok cool will dig more, tomorrow for sure

I have to say I haven't played with the new stuff yet so I might be missing a piece 😉

yep this is fixed

clj -J-Dclojure.server.repl='{:port 5555 :accept cljs.server.browser/repl :args [{:env-opts {:port 9001}}]}'

then in a different terminal

nc localhost 5555

just works

and it is awesome 🙂

Oh ok, so it is a vector of edn...that was my missing piece

It is!!!

clj -J-Dclojure.server.repl='{:port 5555 :accept cljs.server.browser/prepl :args [{:env-opts {:port 9001}}]}'

also just works

note prepl

Greeeeeat, I will have a lot of fun tomorrow lol

I would have done this before but I missed :args

so next release will also be party time for tooling 🙂

Definitely

@dnolen for completeness, I found out where the read-string is done. A bit hidden, but that is why it works. Probably a lucky side effect. The jvm properties are read with read-string ;) https://github.com/clojure/clojure/blob/master/src/clj/clojure/core/server.clj#L153

@richiardiandrea right but that’s intentional

there’s other cases where these Java style directives are EDN

Ok cool then, if it's intentional I will then need to close the Jira :)

Good news: https://dev.clojure.org/jira/browse/CLJS-2607 implies that we might not yet be fully utilizing the shared AOT cache (and that things will run even faster in the end for cold runs).

@mfikes great! will take a look at that tomorrow

Cool!

@dnolen only a possible improvement on naming on that one. Should we have :compiler-opts instead so that everything is coherent? (Main opts are using that term)

they aren’t really compiler opts

they are repl options

you can put compiler stuff in there, but it’s a super set

this is already true in cljs.main btw, it’s really not a cut and dry thing

Ah yeah I think I read it somewhere, it is just probably worth exposing a coherent interface and the merge internally like in cljs.main, I can put a patch together

and there are some corners - but they aren’t that common

Oksss

I don’t really think it’s worth spending too much time on this

As long as I can pass in the same cljsc_opts.edn in there I am fine 😄

the command line stuff is very sugary

it does not map well to the real stuff

but that’s ok IMO

Will try tomorrow and will open jiras in case like last time

Cool thanks, gotta rest now 😄

sure

@anmonteiro I think you’re half-right about add-js-sources being were .mjs modules fail to be added. Specifically, add-js-sources -> js-dependencies fails adding all .mjs dependencies of the top-level .mjs module (in this case, module$Users$jannis$Work$oss$clojure$clojurescript$node-modules$graphql$index-mjs). It tries them in the loop in js-dependencies but the following always returns nil for them:

(or (get (@env/*compiler* :js-dependency-index) (first requires))
    (deps/find-classpath-lib (first requires)))

So now I’m thinking handle-js-modules may be the culprit.

@dnolen Sorry about the race between you and me on CLJS-2606. FWIW, I think the patch you applied is probably the one I would have went with in the end.

(Not worth over-engineering that one, definitely.)

yeah, it’s fine, being able to override is nice for some cases - this really mostly affects people working on the compiler anyway

Agree

getting to point where I think feedback on this before release would be good https://github.com/clojure/clojurescript-site/blob/1a288e33ba58a3d87e8192caafc75458f53f70e7/content/guides/quick-start.adoc, going to cut a release, update this and ask people to try it out

Yeah, I think that is a good idea. Seems like there are no critical bugs and broader beta testing at this point would be valuable.

1.10.126 is the next Maven artifact, just waiting for it to show up

@dnolen 1.10.126 showed up for me

@mfikes yep I’m posting on the various channels

I see. 🙂

Code complete. Defect fixes and documentation polish over the next week. 🙂

@mfikes yeah bugs + I’ll try to go more carefully over your site update PRs

For me (Safari), the (ffirst [1]) first impression will be off-putting, given the synthetic directory structure.

cljs.user=> (ffirst [1])
Error: 1 is not ISeqable
	 (/private/var/folders/gx/nymj3l7x4zq3gxb97v2zwzb40000gn/T/out667248762303295388152139830015529/out/cljs/core.js:4441:17)
	 (/private/var/folders/gx/nymj3l7x4zq3gxb97v2zwzb40000gn/T/out667248762303295388152139830015529/out/cljs/core.js:4460:22)
	 (/private/var/folders/gx/nymj3l7x4zq3gxb97v2zwzb40000gn/T/out667248762303295388152139830015529/out/cljs/core.js:5904:23)

^ https://dev.clojure.org/jira/browse/CLJS-2610

@mfikes hrm really, that’s -c + -r

you shouldn’t get temp dir from Quick Start

OK

Perhaps user error

true that will happen in normal case - but probably something simple, source maps are relative so it should resolve

oh but maybe that’s a bug in our source mapping code for REPLs?

(yeah, this isn’t browser but direct REPL support)

Ahh, I do get an out directory, but something else is causing those odd paths. Maybe it is the cached core path.

I dunno. Hrm. I need to head out.

@mfikes hrm ok, well people kicking Quick Start is a good way to suss out a lot of bugs 😉

tried the yesterday's cool introduction of the socket REPL yesterday...it work, but suffers of the same bug with :main https://dev.clojure.org/jira/browse/CLJS-2612

it is very cool though, it compiles when the accept function is triggered

I attached a patch to https://dev.clojure.org/jira/browse/CLJS-2612, if you folks have some time to try a couple of combinations with -c, I am making sure the REPLs are fixed. I think this seals it @dnolen 😄

crap no, still :npm-deps are not read problem in the socket REPL

but the patch above works, without it is not even going to start

will open a jira, I now have to switch to inf-clojure stuff 😄

@richiardiandrea your patch is not the right approach

you don’t need to mess with CLI for now, in fact I want to leave it alone

if you want a socket REPL use cljs.server.FOO

that just moves the dissoc up one level, not touching cli

we’ll sort main support some other time

you don’t need to dissoc main

rewind and see how the REPLs worked before

stop thinking about cljs.main stuff, it does too much

no yeah but even then, if someone has :main key in the :opts it will break

REPL take REPL options, which is a super set of compiler options

@richiardiandrea so just don’t pass main

this is not a real problem

I see that that's the solution 😄

first get whatever you want working - and think about convenience later

yeah my thing already works if you exclude :main

dupe your options for now and verify that what you want can work at all

ok that’s what I want to know

I would clean 2612 or close it

and reopen a simpler ticket

actually no David, :npm-deps does not yet, so there is that maybe to open

ok cool

but this note this stuff is way lower priority

it’ll get sorted later

well I am trying to help 😄 this is the stuff that for now keeps me from using CLJS jvm from REPL so I am on a personal quest here 🙂 🙂

I would like to see it working of course 😄

what I mean it’s not a priority for the coming release

we can have subsequent smaller releases with socket REPL fixes

I will open a ticket for :npm-deps try to see what I can do, you define the priorities of course

release is going to be dominated by that is all I’m saying

so I will probably ignore these tickets for the time being

kk sounds good

but yes you should open them 🙂

we should track, just setting expecations

if I can express my opinion, that's a pity though, because this is great stuff for tooling...but I see your point as well. Priorities need to be set.

yes we need to be realistic

just sorting through cljs.main stuff is taking tons of time, and I suspect as feedback comes in it will get tweaked

but don’t worry

I have access to the build button 🙂

we can release as much as we need to

later

that's not even :main stuff, it is socket REPL super cool enhancement lol 😄

yep not worried

cider and inf-clojure are not doing crazy tricks for starting CLJS REPLs and this is actually the first time I see a smooth path to it

that is why I am pushing lol

anyways, opening Jira

(I would add, learning a ton in the meantime)

ok opened https://dev.clojure.org/jira/browse/CLJS-2613. The comand I am using is really cool so thanks for that:

clojure -J-Dclojure.server.repl="{:port 5555 :accept cljs.server.node/repl :args [{:opts $(cat cljsc_opts.edn)}]}" -Srepro

I silenced browser REPL

things are fast enough now

all REPLs now look more or less the same

When running through the tutorial, I find that REPL evaluations often block if the REPL page is in another non-visible tab. I wonder if Safari really throttles down JavaScript execution in that case.

@mfikes that’s actually true for most browsers, we should probably mention that

Yeah, otherwise people will thing things are broken