js-csp

I've read a few articles on implementing CSP in JavaScript, and there are definitely some packages available, e.g. https://github.com/olahol/node-csp https://github.com/ubolonton/js-csp https://github.com/gozala/channel

https://github.com/ubolonton/js-csp/ ?

The CSP thing is something I've been looking at recently, and while it seems like it's a little bit lower-level than things like Rx, it seems like channels are more flexible streams (i.e. channels are two-way so you can do back-pressure etc.). I've been playing with https://github.com/ubolonton/js-csp and it's pretty nice; the "yield" statements everywhere are a little wonky, but otherwise it seems like you can implement some pretty sophisticated concurrency between processes with pretty straight-forward code. For examples of that sort of thing, David Nolen and James Long have written some really great articles on the subject: http://swannodette.github.io/2013/07/12/communicating-sequen... http://swannodette.github.io/2013/07/31/extracting-processes http://jlongster.com/Taming-the-Asynchronous-Beast-with-CSP-... There was also an article

This is cool. I've Seen a few other projects that do something similar: https://github.com/ubolonton/js-csp and https://github.com/jlongster/js-csp.

> Generators are JavaScript's programmable semicolons. Lets not take away that power by taking away the programmability. Lets drop async/await and write our own interpreters. One of "our own interpreters" (i.e not standard in JS), that I am very fond of, is js-csp [1]. It's a replica of Clojure(Script)'s core.async, or Go's channels/goroutines. It uses ES6 generator functions underneath. James Long has written an excellent post about it [2]. I find it to be the less taxing on the mind solution for coordinating complex asynchronous processes in JS, especially when paired with transducers [3]. Furthermore, powerful Go/Clojure patterns can easily be re-used in JS. In conjunction with CoffeeScript, the code becomes elegant and straightforward since there is no 'function*' ugliness required. That's the least complex solution I have found to li

I just started working with Redux fairly recently, and I definitely felt that handling async effects in Redux wasn't as elegant as most other parts of the Redux architecture. Glad to find out that Dan feels the same way, according to the tweets linked to in this article [1]. Has there been any efforts to make use of js-csp [2] to handle async operations in Redux, like how ClojureScript apps make use of core.async channels? Cycle.js definitely looks promising, but I have a vague suspicion that its approach of handling effects strictly through the output of the main function, although elegant, might make interop with the rest of the JS ecosystem a lot more painful, since many JS libraries don't have such clean separation of concerns. I believe JS interop is also one of the most commonly cited pain points for working with Elm as well, which

Once I found flyd [0] I never looked back at any of the other streams libraries. It's very simple, easy to jump into, and doesn't have the stream/property split. There's not a lot of code, so it doesn't make debugging any harder. Also, there is js-csp [1] if you want to use CSP without having to make the jump to ClojureScript. Works great. [0] https://github.com/paldepind/flyd [1] https://github.com/ubolonton/js-csp

+1 on this. Clojure's core.async[0] is the perfect example of an implementation of CSP as a library. Even JS can be used to implement such concepts via the use of generators[1]. [0] https://github.com/clojure/core.async [1] https://github.com/ubolonton/js-csp

What does your library offer over more popular alternatives such as js-csp, task.js, co, galaxy, or gen-run? [1]: https://github.com/ubolonton/js-csp [2]: http://taskjs.org/ [3]: https://github.com/tj/co [4]: https://github.com/bjouhier/galaxy [5]: https://github.com/creationix/gen-run

> I've been thinking a lot about how to bring this back into the JS world. I have yet to find any good literature on it, but I will be exploring this area more. The JS equivalent of figwheel is React Hot Loader[1]. There's a port of core.async[2] but I've also seen people using Babelized ES7 async/await for avoiding callbacks. The reloaded workflow is just a pattern around building objects with a topological sort for order initialization. I expect you could build a JS version in ~200 lines of code. [1] https://github.com/gaearon/react-hot-loader [2] https://github.com/ubolonton/js-csp I'm unaware of editor integration between an editor and browser runtime a la slime/nrepl. I think LightTable had a basic implementation but it's been a while and I could be remembering it incorrectly.

js-csp enables go-like concurrency in javascript: https://github.com/ubolonton/js-csp

I think Pulsar supports this model: http://docs.paralleluniverse.co/pulsar/#error-handling. Incidentally, in the javascript port of core.async, we are also trying to come up with a good error handling story [1]. One approach we are considering is (sort of) adapting the Erlang model, by treating goroutines' return channels as their identities. I'm researching error handling in CSP literature and prior implementations as well. [1]: https://github.com/ubolonton/js-csp/issues/14