Skip to content

Latest commit

 

History

History
66 lines (47 loc) · 3.07 KB

README.markdown

File metadata and controls

66 lines (47 loc) · 3.07 KB
Raw

Lamina is deprecated

Lamina has an enormous amount of functionality, but like many other concurrency libraries (Rx, core.async, etc.), it's a walled garden that doesn't play nicely with others. In recognition of this, pieces of Lamina have been reimplemented as standalone libraries that can be used with a variety of concurrency primitives and execution models.

  • lamina.core, lamina.cache, lamina.time -> Manifold
  • lamina.query, lamina.stats -> Narrator
  • lamina.executor -> Dirigiste
  • lamina.viz -> nothing, yet
  • lamina.trace -> nothing, yet

The latest version of Aleph is built on this new stack. Questions about adopting the new libraries can be answered on the Aleph mailing list.

Lamina

Lamina is for describing and analyzing streams of data. It provides a rich set of operators for dealing with these unrealized values, both individually and collectively. If you're new to Lamina, you should start by reading about how it deals with individual events.

Installation

Add the following to the :dependencies section of your project.clj file:

[lamina "0.5.6"]

Rationale

Streams of events are represented by channels, which are used in Aleph to model network communication over a variety of protocols. Much like Clojure's sequences, we can apply transforms to all events that pass through the channel:

> (use 'lamina.core)
nil
> (def ch (channel 1 2 3))
#'ch
> ch
<== [1 2 3 ...]
> (map* inc ch)
<== [2 3 4 ...]

Underneath the covers, channels are implemented as a directed graph representing the propagation and transformation of events. Each new transform we apply adds a node to the graph, and the resulting topology can be rendered with GraphViz.

> (use 'lamina.core 'lamina.viz)
nil
> (def ch (channel))
#'ch
> (map* inc ch)
<== [...]
> (map* dec ch)
<== [...]
> (enqueue ch 1 2 3)
<< ... >>
> (view-graph ch)

Since we can have multiple consumers for any stream of data, we can easily analyze a stream without affecting other code. Lamina provides a variety of operators for analyzing the data flowing through channels.

Lamina also provides mechanisms to instrument code, allowing the execution of data to throw off a stream of events that can be aggregated, analyzed, and used to better understand your software.

To learn more, read the wiki or the complete documentation. If you have questions, visit the Aleph mailing list.

License

Distributed under the Eclipse Public License, which is also used by Clojure.