the latest cljs has a config for it, actually

Sure thing @akiroz

(defn handler [response]
  response)

(defn error-handler [{:keys [status status-text]}]
  (.log js/console (str "something bad happened: " status " " status-text)))

(defn get-request-word [a-url]
  (GET
    a-url
    {:handler handler :error-handler error-handler}))

(defn get-url-as-hickory
  [a-url]
  (let [processed-response (get-request-word a-url)]
    (do
      (.log js/console "processed-response: " processed-response)
      (hc/as-hickory (hc/parse processed-response)))))

(def welcome-url "")

'GET' is cljs-ajax/GET

(The problem is that (:body response) is just returning null, even though I can print the raw HTML str (from the successful request) to the console.)

@chris_ Oh sorry, I got wrong the whole time... the response from cljs-ajax is not a ring response map but the actual body. I got it mixed up with another library.

but that code wouldn't work as you expected, GET doesn't return stuff so you can't so (let [processed-response (get-request-word a-url)]

should be something like this:

(defn url->hickory
  "Takes a URL returns Promise of a hickory tree."
  [a-url]
  (js/Promise
    (fn [rsov rjct]
      (GET a-url
        {:handler
          (fn [resp]
            (-> resp
                hc/parse
                hc/as-hickory
                rsov))
         :error-handler rjct}))))

not tested btw

Could anyone give me a hint how to nail issue which manifests itself with following error:

cljs.user> (require 'react-bootstrap-typeahead)
----  Exception    ----

      java.lang.RuntimeException : INTERNAL COMPILER ERROR.
Please report this problem.
...

Any tips welcome, thanks!

@pawel.kapala looks like a Closure Compiler problem

@dnolen yep, NPE I guess:

null
  Node(NAME animationEnd): /tmp/example/node_modules/dom-helpers/transition/properties.js:17:4
    animationEnd = void 0;
  Parent(VAR): /tmp/example/node_modules/dom-helpers/transition/properties.js:15:0
var prefix = void 0,

  java.lang.NullPointerException : 

----  Exception Stack Trace  ----

java.lang.NullPointerException: null
 at com.google.javascript.rhino.Node.replaceWith (Node.java:872)
    com.google.javascript.jscomp.ProcessCommonJSModules$RewriteModule.updateNameReference (ProcessCommonJSModules.java:1075)
    com.google.javascript.jscomp.ProcessCommonJSModules$RewriteModule.maybeUpdateName (ProcessCommonJSModules.java:954)
    com.google.javascript.jscomp.ProcessCommonJSModules$RewriteModule.visit (ProcessCommonJSModules.java:712)

I’d have to try to isolate it and report it https://github.com/google/closure-library, right?

@pawel.kapala Closure Complier, not library

https://github.com/google/closure-compiler

duh 🙂 thanks!

On top of my issue with the DCE https://clojurians.slack.com/archives/C03S1L9DN/p1501573388897284?thread_ts=1501519537.283529&cid=C03S1L9DN I'm seeing this in my output js:

ReferenceError: $cljs$core$MultiFn$$ is not defined

$cljs$core$MultiFn$$.prototype.$cljs$core$IMultiFn$_add_method$arity$3$ = ....

@lsenta sorry I don’t have time to look at this, I’ve already said that I don’t think your approach is going to be fruitful

trying to do your own DCE seems ineffective to me - Closure’s DCE works

all of Google major JS properties leverage it

so whatever conclusions you may be arriving at about DCE I would not put a much stake in it yet

as I said yesterday

DCE won’t work if there are side-effects

multimethods are one of those cases

Hey David, this is super confusing, could you at least open the file and let me know what's not done in the clojurescript way?

https://github.com/lsenta/cljs-dce-demo/blob/master/src/catalyst/js.cljs

you seem to say my approach is broken, I redid all my code using the default, dumb goog-define, I really don't see what's "my" in this

exporting will pin everything in the call graph

DCE is whole program optimization, Google will crawl everything to determine dependencies at the level of values

if you export, then it will determine all values that your exported thing depends on

side note: this stuff is pretty well covered in Google Closure documentation, and it’s pretty easy to find more details on the Closure Compiler mailing list, the O’Reilly book is also a great resource on what expectations you should have

@lsenta I also see your misunderstanding here

DCE doesn’t work inside fns like you expect

only at the fn level

Does that explain why the DCE works in one case, bot=001 and not when its bot=004

?

DCE simply does not eliminate at the level of fn contents

either a fn is used or it isn’t

if it’s used it’s assumed anything it calls is needed

the cond is using a goog-define with "identical?"

which gets optimized / inlined in the output js

so the result js knows that a single module is used

and in one case, the optimization works, only bot004 is present in the output

anyways I really don’t have time to work through DCE with you 🙂

but in the other case, both bot are present, as if the DCE doesn't handle inner nodes

you can easily ask the exact same questions on the Google Closure compiler list 🙂

I understand and thank for trying to make this more clear

I'm still very frustrated by the impression that one switch-case is optimized and not the other is a bug. And I don't see how any of your answers adress this

there’s no way to answer that without looking at a lot more of your code

I mean (if true a b), b is eliminated, (if false a b) a is not eliminated

but trust me something is wrong somewhere without a doubt

there’s a small chance you have found a bug

I'm telling you, my code is almost empty, there's like 50 loc of cljc

I’ve spent weeks on this stuff 🙂

this is why (js/console.log "Hello world") is just a couple of K under advanced compilation

and I trust you write deterministic code 😉

this is why code motion works - you have to be very very careful if you want something specific to happen

David, is there anyone else that'd have time to read these 50 lines of cljc and at least check that the bug is in my code?

@lsenta a better use of your time is to just write the same thing in JS and see what happens

then I don’t have explain anything 🙂

then you also have a example which you can ask about on the Closure mailing list if something seems wrong

that's a fair point, will you review the js and the demo repo if I find something doesn't match?

no 🙂

figure out what’s different

if I was you however I would not spend any more time on this - I would just use the provided :modules code splitting feature and spent my time on more interesting stuff

parse times for 100K LOCs of JS is measured in milliseconds

I am using modules...

@lsenta I think you should look into :modules more and the new cljs.loader maybe

if you’re not seeing real performance issues, what’s the point of this exercise?

and change your configuration in that the catalyst.js does not require the bots but the bots register themselves on load

then you can control which bots get loaded by configuration

:modules already solve exactly what you are trying to do if I read everything correctly

instead of trying to figure out why code doesn’t get DCE’d you should probably focus on not feeding the code into closure in the first place

If I had to guess why your code doesn’t get remove its the concat in 004

closure does not understand lazy seqs so won’t remove them

basic question: how do I turn a hashmap into a prettified string?

(doseq [namespace '(project.a project.b project.c)]
  (require `'~namespace)
  ;; (require namespace)
  )

Arguments to require must be quoted. Offending spec

@deadghost pr-str

@pesterhazy doesn't seem to actually prettify it

(with-out-str (clojure.pprint/pprint {:foo :bar}))

@pesterhazy nope still not seeing any pretty printing

even when adjusting it to cljs.pprint

@deadghost works for me: https://github.com/binaryage/dirac/blob/3b3451f59a19e344f11d5c58a5b2b7b4c93a74eb/src/shared/dirac/utils.cljs#L152-L156

@akiroz Thank you! -- I tried out httpurr and cljs-http, and I think the underlying issue is that I don't understand asynchronous programming in the slightest! So I'm going to work on that.

@pawel.kapala if you end up creating a minimal closure repro I’d be interested in adding that somewhere to the CLJSJS docs, it’s something more people will bump into with the new module processing stuff

@martinklepsch I've spent some time minimizing dom-helpers, so I might have something for you, prolly tomorrow.

awesome, I wish much success 🙂 😛

The problem is probably this one: https://github.com/google/closure-compiler/issues/2450

Var from combined var statement being exported

var prefix = void 0,
    transitionEnd = void 0,
    animationEnd = void 0;
exports.transitionEnd = transitionEnd;

This is fixed in Closure-compiler master, but combined var statements are broken in another way currently

(This is the problematic file from dom-helpers: https://unpkg.com/[email protected]/transition/properties.js)

with cljs, can I do anything besides :optimizations none :parallel-build true to speed up my builds ?

@qqq don’t blow away :output-dir unless you really need to

@dnolen : sorry, I don't understand what :output-dir has to do with this

oh, you mean incrementla compiles?

Yes

does :optimizations :none even call google-closure ? if not, is all the time clojure code doing "cljs -> js" conversion ? if it does call google-closure, is there a split of cljs -> js time spent and calling closure on js time spent ?