manifold

so is this something like core's interpretation of things like ztellman's manifold (https://github.com/clj-commons/manifold)? EDIT: gpt says, Choose core.async.flow when you want a declarative, monitorable process graph over channels (pause/resume, error channel, flow monitor). Choose Manifold when you need deferreds/streams as general primitives, precise per-op backpressure, error-aware chaining, or you’re in the Aleph/Netty stack. very abstract but based on this, the answer is no.

Some alternatives to core async that I think are very thoughtful are promesa[0] and manifold[1]. We've got a large chunk of core async code that if I had to redo I would use one of those libraries. They are conceptually simpler, I think, and they don't have the same downsides as the `go` macro. That said, our code works and I'm not about to rewrite it just because some new libraries came out. As for spec and transducers, I do use spec quite heavily, though now that clojure.spec.alpha2 is on the horizon I'm holding off a bit - it will be really nice to have data-based specs instead of macro based ones. For transducers I've only used them when I've found a performance bottleneck in a data transformation pipeline, which for me means only on toy algorithm problems and not in production code. But that says more about my line of work than their

No relation to Clojure's own manifold library, I guess? I was a bit confused when I visited that github repo you posted and saw a bunch of Java code :P This is the one I thought of: https://github.com/ztellman/manifold

FYI: Manifold is a pretty popular Clojure library by Zach Tellman. https://github.com/ztellman/manifold

This is getting better but unfortunately your best bet is still to read some examples of good open source projects. If you or anyone interested in some good starting places for good Clojure see: - https://github.com/gothinkster/clojurescript-reframe-realworld-example-app for a great webapp example - All of https://github.com/ztellman work but specifically: - https://github.com/ztellman/manifold for more advanced Clojure - https://github.com/reagent-project/reagent for interop with JS and advanced Clojurescript usage

For the data processing tasks my go-to tool is Manifold[1]. Depending on how the application is structured, you can keep state in atoms, the system map when using Component[2] or vars with Mount[3]. Manifold streams asynchronously join the state transformations together while allowing control over backpressure and threading. On the data analysis side things aren't rosy on the JVM. I'd delegate that part to something which actually has all the tools built-in, e.g. Julia/Python+Numpy/R. Apache Arrow[4] is a nice project to facilitate the dataframe interop. [1] https://github.com/ztellman/manifold [2] https://github.com/stuartsierra/component [3] https://github.com/tolitius/mount [4] https://arrow.apache.org/

Low signal-to-noise posts about Clojure are damaging to adoption because it doesn't say anything about why Clojure is a good option on the JVM. Instead, I will try to give some reasons why Clojure is a good fit for high-performance stream fusion, which I presume AppsFlyer has to do a lot of: - [Onyx](https://github.com/onyx-platform/onyx) for distributed, masterless, fault-tolerant data processing - [core.async](https://github.com/clojure/core.async) for CSP-style events through a channel abstraction. I miss core.async so much in every other language, I generally end up implementing a subset of the semantics. - [Transducers](https://clojure.org/reference/transducers) for composable transformations, e.g. (filter odd?) ;; returns a transducer that filters odd (map inc) ;; returns a mapping transducer for incrementing (take 5

This was also asked a year ago, and I pointed to Zach Tellman, and that comment was upvoted by others. I'll post the same again. Because he always has excellent reasons for the decisions that he makes, I find it interesting to read his code and try to figure out why he made the decisions that he did. This is in Clojure: https://github.com/ztellman/manifold/blob/master/src/manifol... Also, it is fascinating to consider how Go routines were implemented as part of Clojure core. Huey Petersen wrote a fantastic analysis of how state machines were used to implement Communicating Sequential Processes: http://hueypetersen.com/posts/2013/08/02/the-state-machines-... You can read along while looking at the source code here: https://github.com/clojure/core.async This is a great implementation of Communicating Sequential Processes, first described by

Just one caveat to the use of core.async as a processing pipeline (as in section 6: Callbacks), make sure you're taking extra care to handle exceptions. Since the exception occurs in a separate thread, it will happen silently and will cause your pipeline to stall. Some recommended reading for how to handle such a scenario: http://martintrojer.github.io/clojure/2014/03/09/working-wit... https://github.com/zachallaun/async-pipeline https://github.com/ztellman/manifold