.then(() => doSome(thing))
with bare
doSome(thing)
and
.catch(err => doOtherThing(err))
with
catch (err) {doOtherThing(err)}
A breakthrough indeed!
I just don't see how's that fundamentally different and why one should have synchronous-like semantics for async operations.
Moreover I do a lot of RxJS and like stuff and it's perfectly normal for me to have async computations steps wrapped in functions. Luckily no one tried to "improve" JS syntax specifically for RxJS.
So I totally get async/await syntax and semantics but it forces me to switch mental context for no good reason and thus is useless and disconcerting.
And it's ridiculous to see this minor "feature" as a reason to switch from CLJS to ES6/ES7
You seem oblivious to the advantage of organizing your async code in the same manner you organize your sync code. But the bigger reason I gave up on CLJS (besides core.async and its CSP model being a ridiculous over kill for simple async management yet being the primary choice the language gives you out of the box) was that ES6/7 are advancing at a much rapid pace than all of those Compile-to-JS languages and no one I know in the JS world would want to program a web app in a Lisp-like language (it's like using an RPN calculator rather than a normal one to do your taxes) for advantages that are disappearing fast relative to JS.
The Extensible Web Manifesto embraces the Babel inspired iterate-before-you-approve spec development model and that just makes JS evolution go so much faster.
So there is no hope for any niche language to unseat JS, and staying with a healthy and growing mainstream standard is far more appealing to me than writing web apps in Lisp-like language that once was a great choice (compared to ES5) but is no longer in that position.
I hope ClojureScript continues to be a niche strong language but I'm really hapoy with the progress being made with JS as a language and ecosystem. Fatigue (what the article is about) is self inflicted IMO.
.then(() => doSome(thing)) with bare doSome(thing)
and
.catch(err => doOtherThing(err)) with catch (err) {doOtherThing(err)}
A breakthrough indeed!
I just don't see how's that fundamentally different and why one should have synchronous-like semantics for async operations.
Moreover I do a lot of RxJS and like stuff and it's perfectly normal for me to have async computations steps wrapped in functions. Luckily no one tried to "improve" JS syntax specifically for RxJS.
So I totally get async/await syntax and semantics but it forces me to switch mental context for no good reason and thus is useless and disconcerting.
And it's ridiculous to see this minor "feature" as a reason to switch from CLJS to ES6/ES7