Being a JavaScript developer I see this issue in a different angle. I don't use Java. So using Clojars is like "using two package managers", since I've been using npm for so long.

Lumo is moving away from JVM. And it sounds more natural to use npm as the package manager, just like all other compiled-to-js languages, despite that npm is far from perfect.

seriously though: if there was a shadow-cljs publish command. would you care where it ended up?

“it is easier to deploy to npm” is not a valid argument to use it since 99% of the time you just want to USE the dependency not deploy it

@thheller when a shadow server connects to the browser, is there a way for the browser’s code to ask the server questions like “what build am i” or issue commands like “build release”? (ie. building blocks for a UI)

shadow.cljs.devtools.client.env might already have everything you need?

ok i’ll check there, wasnt sure where to look

https://github.com/thheller/shadow-cljs/blob/master/src/main/shadow/cljs/devtools/client/env.cljs

shadow.cljs.devtools.client.env/build-id

issuing commands is not yet possible

but I’m happy to create any kind of endpoint you need 🙂

can’t really issue commands from the build itself

so repl-call is used to evaluate expressions that you are sending to the browser

well its for the REPL

but none of that should be used if you want to build an actual UI, ie. the UI should not become part of the build

it should be standalone IMHO

i am imagining the UI would be a :preload? like re-frame-trace

there is some prior art for the UI I have in mind

https://github.com/oakmac/cuttle

saw that the other week, it looked nice

https://www.youtube.com/watch?v=hHruZtz62no

a benefit of something injected into a build is that you could show warnings/build status directly there, in the window that you’re looking at while developing

à la figwheel

a basic HUD already exists

that is a preload yes

but the UI that controls shadow-cljs should not be part of the build itself

i see

i don’t think I’ve noticed the hud

its not enabled by default

:preloads [shadow.cljs.devtools.client.hud]

its too ugly

🙂

more or less just a test of how it could be done

pretty sure it doesn’t work anymore

ok

let me try and fix it

not a good demo if it doesn’t work 😉

ah no it actually still works

still ugly but it works 😉

ah open in editor link is missing a name

transit really needs to fix that uri? issue

or did they…

there is a new release! 🙂

they did, I bumped it in shadow-cljs already

ah i had the old version in maria’s deps

I don’t really like the HUD as a concept

I want to see errors in my editor ASAP

having to look at the browser for that is meh

like that … one day …

this could definitely become nicer looking

errors in the editor… is there a standard way to communicate stuff like that to an editor? (ie. something that would work with Cursive and emacs?)

short answer: no.

I spent quite a bit of time in that rabbit hole

https://github.com/thheller/shadow-cljs/issues/2

http://langserver.org/

thats an attempt at some kind of “standard” for this

quite a few editors support it

cursive or rather intellij doesn’t

https://youtrack.jetbrains.com/issue/IDEABKL-7409

> Language server support cannot be combined with existing IDE tooling; it’s an either/or proposition. If IntelliJ used the language server for Java, it would lose 95% of its feature set for Java development.

I don’t think its coming to IDEA anytime soon

does appear to be a rabbit hole 😞

well, when developing for the browser, warnings/errors there will show up at essentially the same speed as if it was connected to the editor, if you have a side-by-side view on your screen

my setup usually looks like this

“almost” in my editor

need to bug colin so I can send special nrepl messages the UI understands … but he is busy 🙂

Last night I was surprised to find that my parsing lib runs ~8x faster with :simple optimisations than in dev

Anything to do with perf tweaking/debugging might be another user case for watching release builds

hmm

the issue with watch for release is that running it on every file change is too slow

in dev thats non an issue since it usually takes less than a second

but say you are fixing a release bug and touch 3 files to “fix” it

if those 3 files are not saved at once the watch may trigger early

but I can implement it regardless if you want. its not hard to do.

my workflow typically consists of poking at it in the REPL

then when I’m done trigger release manually

release is pretty expensive compared to watch

in cursive you could create a custom REPL command to trigger a release build

I should into these custom REPL commands

*look into

Can't edit on a phone. Sigh.

I actually can't find what you mean by custom REPL commands

tools -> REPL -> edit REPL commands

allows you to specify a string of text to send to the REPL

and bind it to a key

ie bind (shadow.cljs.devtools.api/release :browser) to a key

oh the tools -> REPL menu might only show up when connected to a REPL

there was something weird about that

I ignore probably 80% or more of IntelliJ.

I just discovered Preferences > Appearance & Behavior > Menus and Toolbars

Life will never be the same

hehe

would it make sense to apply :simple optimizations to bootstrap js?

this is a great workflow, REPL command with shortcut

all the ^boolean type hints seem to have zero effect, in any kind of optimization mode

you can tell if they have an effect by the generated code

hmm wonder if I broke that when I “fixed” the incorrect ^js tag behaviour?

nope not broken, you had me worried there 🙂

all the ^boolean tag does is remove the cljs.core.truth_ call

without you get if(cljs.core.truth_(demo.browser.thing)){...

with you get if(demo.browser.thing){ its only really needed in cases where closure is supposed to kill dead code

and super critical loops maybe

is there a particular lib you use for cljs perf testing?

for my parse lib, using sequential keyword-identical? comparisons vs. (contains? #{…} the-kw) results in a 2x overall speedup

I use the chrome devtools occasionally to profile

(contains? #{…} the-kw)

did you try (contains? the-set-but-from-a-def the-kw)?

just realized i was mistakenly using keyword-identical? with strings. still had correct result, but slightly faster i think to use identical?

i did not

bootstrap js and :simple no, then you’d lose the ability to load individuals namespaces

but, this is in a really tight loop and i am not sure one can go faster than successive identical comparisons

contains is a hash lookup

just re-creating the set on every call is not good

somehow i imagined that a literal set wouldn’t be re-created

yeah the compiler is not that smart

re: bootstrap :simple - would not have to pile all the files together?

i am just surprised at this 10x speed up using :simple

hmm true

10x might be from constants

in :none constants are not optimized so every keyword or symbol is allocated

in optimized code its allocated once and shared

if you allocate too much you force a GC

tight loop with keywords might do that

:simple but still separate files gave me an idea

that might be worth doing yes

SSL with self-signed certificates is so annoyingly complicated

well, this is interesting. when the parsing lib and sample text are loaded by themselves, the :simple optimization mode makes a much smaller difference, maybe 20%

but when the exact same test is loaded as part of Maria’s live build, then it slows down 10x when not in :simple

hmm

:static-fns maybe?

hmm not sure I understand. as part of the live build means loaded by the self-host?

i don’t fully yet understand either. so the live build is :optimizations :simple, nothing fancy. It does load the bootstrap build but I am not using the compiler to perform this test

i’m trying to reproduce and can’t yet. i thought maybe it had something to do with loading it in an iframe, but that doesn’t seem to be the case

I do think iframes get a lower priority but not sure

maybe it has something to do with memory usage

how do you guys feel about the shadow-cljs - config: /Users/zilence/code/shadow-cljs/shadow-cljs.edn version: 2.0.35 line?

should I keep it?

trying to trim some unnecessary output from commands

i like seeing the version number

unsure if path is necessary

echo :foo | shadow-cljs clj-eval --stdin
shadow-cljs - config: /Users/zilence/code/shadow-cljs/shadow-cljs.edn version: 2.0.35
:foo

cat script.clj | shadow-cljs clj-eval --stdin

node packages/shadow-cljs/cli/runner.js clj-eval "(shadow/release :thing) (something-after-release)"

might be useful

oops

shadow-cljs clj-eval "(shadow/release :thing) (something-after-release)"

like this of course

wanted something that lets me string together a few things … like calling rsync after release 😉

:simple for bootstrap is not so simple unfortunately

hmm, how does it behave?

the closure compiler doesn’t like compiling like that 😛

thought I can abuse the :npm-module stuff I have already but that doesn’t quite work

------ WARNING #1 --------------------------------------------------------------
 File: cljs.core$macros.js:2

 namespace "clojure.walk" is required in module cljs.compiler.js but provided in module clojure.walk.js. Is module cljs.compiler.js missing a dependency on module clojure.walk.js?
--------------------------------------------------------------------------------

Closure compilation failed with 6 errors
--- cljs.js.js:2
namespace "cljs.core$macros" cannot be provided twice

not really sure what is happening … a bunch of weird stuff

hmmmmm so, it appears that :async-require is what’s behind this weird slowdown

really? how does that happen?

absolutely no idea! 🙂. but that’s a console log after reloading, only difference commenting out that part in devtools

oh its loading the dead js deps

thats not supposed to happen 🙂

can you try to js/setTimeout the start of the test?

or how do you trigger the test? just on load I assume?

can you try in the :after-load fn?

so its done after the code loading process finishes?

my test code is:

(dotimes [n 5]
  (js/setTimeout
    #(time (tree/ast "..."))
    n))

ah ok

and if you remove the :async-require its normal?

yup

hmm the async require loads code via xhr and then js/evals it

maybe that doesn’t get optimized be the JIT?

appears so: https://github.com/turbolinks/turbolinks-classic/issues/135

did you try with compile and not watch?

hmm 2012

https://jsperf.com/tag-vs-eval-fn-construction#chart=bar

yep still relevant

but I can probably do the script injection

also slow

(compile)

wow, what weirdness

indeed

this is so weird, append a script node and remove it directly after

code still gets eval’d properly 🙂

oh hmm

you are in an iframe right?

I think eval(code) is window.eval(code)

maybe its weird because of the iframe

create a shadow/build/async-closure-import.js in your project source path

https://github.com/thheller/shadow-cljs/blob/9a6da82179dd789a7dc1d680139e530486cd27c0/src/main/shadow/build/async-closure-import.js

so this little trick they do:

var createScriptFunction = function(args, body) {
  var prevDash = window._,
      script = document.createElement('script'),
      sibling = document.scripts[0];

  script.text = 'var _ = function(' + args + ') {' + body + '\n}';
  sibling.parentNode.insertBefore(script, sibling).parentNode.removeChild(script);

  var result = window._;
  window._ = prevDash;
  return result;
};

don’t want to do a release if it doesn work

ok just a sec

function scriptEval(code) {
    var node = document.createElement("script");
    node.appendChild(document.createTextNode(code));
    document.body.append(node);
    document.body.removeChild(node);
  }

instead of straight eval

page loads just fine after

don’t have a benchmark handy I could use to test

currently building

seems to be somewehre in the middle, ~1800ms

but wait

i am not sure if things are compiling normally

might be best to stay away from async-require if that fixes it

did quick benchmark myself. 6.5sec without async require, 6.5 sec with async require + script, still waiting for eval 😛

still waiting …

might be a big boost for bootstrap as well if eval is really that slow

still waiting … geez

is this code supposed to be running on the shadow-cljs server?

hmm?

i mean shadow-cljs server — does that need to be restarted after adding this js code

i have just got into a weird state where the same benchmark code is now running at the midpoint of slow and fast and nothing i do seems to change it.

let me dig myself out of this hole 🙂

no you just put the file into your classpath

and trigger a compile

it will basically just be prepended to your build .js file

the difference is crazy .. I had to kill the tab

it just didn’t finish

140ms with scriptEval

11514ms with eval

so crazy 😛

yeah

madness

[email protected]

is this Invalid SemVer Range something simple to fix?

uh right .. I forgot about that

well I can fallback to just string compare in that case

oops typed description in image title

[email protected]

also has the faster script eval for things loaded by the devtools

and the bootstrap/load

hmm I should have done the benchmark in firefox as well

you never know 🙂

also fixed the semver thing

firefox doesn’t care at all

eval is the same speed

nah not quite the same speed

250ms vs 400ms

vs chrome 11sec 😛

how is this not a widely known thing?

i don’t know but it’s nuts

and i don’t understand the logic. they don’t prevent dynamically supplied code from being optimized, they just make it awkward?

maybe just a low priority thing.

not really intentional.

https://github.com/vhf/v8-bailout-reasons

eval is on that list without comment

no idea what it means

wow, didn’t realize that about try-catch

Don't put try/catch inside computationally intensive functions.
You could try { test() } catch

oh, this page is more recent: https://github.com/petkaantonov/bluebird/wiki/Optimization-killers Functions that contain a try-catch statement (Optimized in V8 commit 9aac80f / V8 5.3 / node 7.x)

says that functions that call eval() are ‘likely never optimizable’

yeah that I knew

but the eval’d code should still be optimizable

but that the eval code itself is also not optimizable, is a separate thing

right

its super weird

also very hard to google properly

too many “eval is evil” results