Clojure core.async and Lamina

Question

Is core.async a replacement for Lamina, or is it going to be a replacement for Lamina?

If not, are there clear situations where it is preferable to another?

Answer 1

I am the author of Lamin. I think core.async is a well-made library, with more clarity in design than Lamina. There are things that I think are better than Lamin, mainly related to introspection, performance, and extensibility.

The big problem that I am encountering with core.async is that in addition to stream abstraction, it brings a runtime model (everything happens in core.async thread pools), which means that if you use it anywhere, it limits the design and implementation of everything else in your codebase.

I saw several “asynchronous” libraries that expose streams as core.async channels, which means that you can only use libraries if you are comfortable using the core.async runtime model.

I am going to release a library that tries to be a "minimal" representation of a stream, which can be used instead of the cells core.async, Lamina, Java, etc. called Manifold . The manifold stream can be bound to the core.async channel, the Lamina channel, etc., And any of these things can be forcibly returned to the Manifold stream.

I think that the “asynchronous” landscape is still quite young, and there are many unknown problems wrt how well the abstractions scale well, how easily they are debugged in production, etc. The JVM provides many tools for introspection, but since asynchronous use mechanisms use a completely different execution model, we basically start again from scratch. I would not tell you to use Lamina over core.async, but I would caution that core.async is an application level abstraction, not a library level.

Answer 2

core.async and Lamina are two different projects, and they are not intended to replace each other. Actually, they could play beautifully together if you want ... Lamina is a stream-oriented approach, and core.async is a message-oriented one.

Which one do you need. In Lamina, it’s important that you define the callbacks for the channel, and in core.async, the channels and go blocks are decoupled, and this is more flexible and modular.