Hi all, has anyone here tried to use re-captcha in a CLJS project ?

@lilactown https://stackoverflow.com/questions/39291779/idiomatic-conversion-of-node-js-apis-to-clojurescript

@lilactown @yury.solovyov I wouldn't jump to using core.async without compelling reasons. Promises are pleasant to use from cljs, and they're easily available in node

in addition to @pesterhazy , I've found that I like reqctive-atoms much much more than core.async: reactive-atoms = think about relationships, core.asyc = think about processes, and reactive-atoms gives better stack traces too

@qqq, are you talking about reagent's ratoms? OP's context was using Node.js apis I think

@pesterhazy: yes, reagent ratoms, I'm pretty sure they can be used without gui; though perhaps I misunderstood OP's question

you probably can but I doubt it's a good idea...

why not? I really like the idea of functional reactive programming / specifying a graph of "when this updates, update these other things too" -- it's like spreadsheets -- I find it far more declarative / easier to reason about than core-async

ratoms are intended to used in react render functions. Maybe a similar but more general-purpose abstraction could be built but AFAICS ratoms are not that

actually, I thought r-atoms just did some black amgic to keep track what the given atom derefs, then addas watcher to the derefed atoms to auto update

I'm not sure where the react render part comes in.

Not sure if it is the appropriate place to ask the question here, but I just couldn't figure out how to make it work with rum... https://github.com/clauderic/react-sortable-hoc/blob/master/examples/basic.js

I guess there're alternatives to ratoms for doing reactive computations, e.g. freactive.core. I compiled a list of similar libs a while ago here: https://metametadata.github.io/carry/faq/#is-there-a-way-to-code-a-view-model-if-i-dont-use-reagent Although using ratoms or the like as alternative to core.async and promises sounds interesting, I wonder how to deal with error handling then? Promises have the built-in notion of errors and for core.async smt. like <? macro can be used. cc @qqq @pesterhazy @lilactown

@metametadata nice

I'm increasingly convinced that Promises are officially a Good Idea[TM] and work really well with ClojureScript

agree. had to interact with firebase which is all promise based. quite nice actually

It was OK working with promises in JS, but I bit the bullet and went directly to using core.async with <? macro in CLJS. I like that I can use built-in try-catch-finally to handle errors instead of the DSL and code reads almost as usual synchronous one (syntactically it looks quite similar to JS code with async/`await`).

i have promise-based cljs code reading almost like synchronous code @metametadata 🙂

To me core.async in CLJS has drawbacks. Extra dependency, doesn't work great in bootstrapped cljs (lumo), channel abstraction not ideal to just chain async computations (main use case), macros are not composable

The fact that it covers both cljs and clj has its cost - it core.async may be better for clojure, but for cljs it's often (not always!) overkill

@mccraigmccraig do you use some kind of library? promesa I guess?

Promises by contrast are just functions 🙂

here - using one of the promise-based js fs apis - with promesa+cats @metametadata - https://gist.github.com/mccraigmccraig/a8fe17eb500b231e8cc949bb74adb49f

@pesterhazy In Lumo I use deasync and make all my code literally synchronous 😄

https://www.npmjs.com/package/deasync

@metametadata what is this magic?

I guess it's written in C

🙂

works nicely for my shell scripting needs as I don't really want to coordinate anything asynchronous and just execute commands in sequence

ever since i realised that my utility scripts often end up being bundled up into api-side functions i started to write everything async and focused on ways of making async as easy as possible to write/grok

@mccraigmccraig same for me - you start off goofing around synchronously-ish but eventually it'll end up in your code

personally I find that channels are a much better abstraction as soon as I want more than one value over time

however, I've realized after writing it in channels that I actually don't need that functionality 😅 wishing I had gone with promises now

especially given the overhead of core.async and compiled cljs vs. using a lumo script

I rolled with just using lein's figwheel-node template for a simple command line app and the bundle is 1.5mb. can't use advanced optimizations because I used core.async too 😆

@lilactown FWIW you can run your Lumo script with -K and subsequent runs will be faster (core async compilation will be cached)

i'm working on converting it from standard cljs to use lumo now

i might just rewrite it to use promises, too

for comparison, here's how my core.async/<? code looks like: https://gist.github.com/metametadata/bb31af03c9949b3518ed2f94f3c84ce3

@lilactown for CLI apps I would really recommend deasync-ing async functions if in nature your code is sequential

it's incredibly async

it basically makes 10-20 HTTP requests and saves the json responses to files 😛

aah, ok then 🙂

that deasync library is pretty cool

that's some serious black magic

@metametadata i'm gonna use that gist as a reference for error handling in my app 😄

thanks for posting

sure, you're welcome. you'll need to find some implementation of <? though. we hand-rolled our own but it's not open-sourced yet

sure

you said you're using cats for maybe?

e.g. this one https://github.com/alexanderkiel/async-error

no, cats is what promesa uses as far as I understood

promesa doesn't use cats, but cats has a promise-monad implementation for promesa

https://github.com/funcool/cats/blob/master/src/cats/labs/promise.cljc

just sayin' - promises give you error handling as well

@qqq “it’s like spreadsheets” Great, isn’t it? I ported my reactive Cells library from CL to CLJ/CLJS (re-christened Matrix) and started on a web framework but am just starting on the doc. I have a TodoFRP treatment here: https://github.com/kennytilton/todoFRP/blob/matrixjs/todo/MatrixCLJS/README.md A lot of that is still a copy/paste from the sister JS version ../MatrixJS. Ping me if you have Qs at kentilton at gmail.

is it possible to wait for promise by de-refing it in cljs?

(let [value @promise])

@yury.solovyov no, because Javascript is single-threaded

I meant is it possible to make js promises feel the same way?

yes, for example with core.async, the go macro will rewrite your linear-looking code to be callbacks under the hood

it is pretty easy to convert js promises to go channels and back

I know it is possible with core.async (I really need to write questions better), but what I'm trying to get into, is I want to be able to use js promises as in clojure or in go blocks, but with all that stuff hidden from me

maybe it is possible to implement new kind of promises that wrap native js ones and "wait" on deref?

with whatever is needed under the hood

the semantics of a ratom and a promise are quite different though

@yury.solovyov I'm not aware of any experimental work being done in that area

a ratom is never in an "incomplete" state

@yury.solovyov no, not possible. due to the async nature. once you go async everything has to be async.

core.async go is a good boundary for that

just like the async keyword in JS, if you use it once you have to use it everywhere basically 😉

but in cljs go is basically free, right?

indeed, you would still need something like go macro to wrap your code in

or I can imagine someone trying to emit async/await modern javascript

which is AFAIK very similar thing, it can be transpiled into callback-style code

@darwin async/await is basically the go macro of JS

but must be explicitly bounded

does pretty much the same thing just as a language feature

well, that's fair, thanks

btw. I tend to view core.async as generalization of promises, they can be called multiple times and yield a stream of values instead of one

so the conversion promises -> channels is quite clear, the other way must introduce some strong assumptions

also error handling / exceptions problem is quite blurry in my mind - depends on situation

so it is not that easy to cross that boundary in more general cases

I kinda wish I had to deal with less channel passing all over the place

it is just different manifestation of the callback-hell, less error-prone I would say

try to design core of your app to be synchronous data-in -> data-out, and then wrap it on the edges with async stuff

similar approach as with purity

that's what I did, but the async part still need some love w.r.t. generality

I think Tim covered some of the ideas how to "hide" async parts of your app here in this talk:

https://www.youtube.com/watch?v=096pIlA3GDo

it takes a while to "see" these places tho

and then to come up with an elegant replacement

I'm not complaining, it just takes time to develop these senses

yes, instead of working with channels directly, you should be building transducers (still sync code) and glue all together at the edge of your app (where you be async)

yup, I even have a TODO with "transducer here?" 🙂

sounds pretty abstract, but he showed some concrete examples

https://github.com/YurySolovyov/eion/pull/17/files#diff-584f3c2948116a881b7717bb0529a24fR160

think about transducers as functions which do not work with input and output data structures directly, they are abstracted from it

so instead of threading a data through a set of functions to transform it, you first compose transducers of those transformations and get a composed transducer back, and then use some machinery to put transducer, input data structure and output data structure together to get the same result

but they have to be sync, right?

so then you need to pipe some channels or something

if there is some asynchrony associated with input or output, you are not affected by it when working on transducers

and that's the trick how to keep core of your logic synchronous

well, what if to know the next value, I need to call an async thing?

pretend that you have it 🙂 and some machinery which will be composing your code at the edge of your app will wire it with async stuff 🙂

but this is getting too abstract, it is not always easy, transducers or function composition is just a tool

ok, now I don't get it, how can I pretend? say I'm reducing a channel with sum of values, to get the next value I need to call something async. how do I pretend?

ok, maybe it is too abstract

In your example I was concerned about the function +, that is syncronous and does not need to be involved in async ops, reduction over a channel is that machinery happening at the edge of your app

the question is how can you restructure your code which is a chain of async ops to be a chain of synchronous operations which get assembled by something at "outer" level and that something knows how to do async/await

I get it when people say that I need to move async stuff to "the edge of your app", but it is too hard to act on, like I still need to build that part, even on the edge of my app, and for some reason nobody talks about it 🙂

watch the talk

ok, I'll re-watch it cause I've seen it, but probably missed something the first time

Still thanks for a chat

what’s a good way to load code from cljs/user.cljs only during dev?

(I’m assuming that there would be an analog to the clojure user.clj file)

nvm. preloads