ztellman

lamina

Clojure2012–2015

ztellman / lamina · Archived

lamina

not under active development - event-driven workflows for clojure

Languages & Compilers Automation & Workflows

Explore on GitHub Read Hacker News discussions

8Distinct people

9Mentions

0Explicit recommenders

713GitHub stars

REPOSITORY AT A GLANCE

What to know before exploring

What it is

not under active development - event-driven workflows for clojure

GitHub

Where it is used

No documented product use has been verified yet.

What people are saying

No recommendation phrase was found in the indexed comments.

No classified warning is attached to this page. Read the discussions before treating silence as approval.

Also in these discussions

No other repository is repeatedly linked in the same discussions.

This week on Hacker News

Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 5:04:57 PM UTC.

No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.

Mentions over time

HN mentions by year9 dated mentions

Observed mentions: 2012-04-10 16:49:35 UTC to 2015-01-09 17:10:09 UTC.

Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.

View mention counts and date ranges

UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
Period	Start (UTC)	End (exclusive, UTC)	Mentions	Comments
2012	2012-01-01 00:00:00 UTC	2013-01-01 00:00:00 UTC	3	3
2013	2013-01-01 00:00:00 UTC	2014-01-01 00:00:00 UTC	4	4
2014	2014-01-01 00:00:00 UTC	2015-01-01 00:00:00 UTC	1	1
2015	2015-01-01 00:00:00 UTC	2016-01-01 00:00:00 UTC	1	1

What Hacker News says

9 sources

lkrubner·Jan 9, 2015

There are Clojure systems with good support for handling exceptions. Zach Tellman's has an event driven channel/pipeline system in Clojure called Lamina. It offers good support for monitoring and recovering from exceptions: https://github.com/ztellman/lamina/wiki/Probes-and-Instrumen... Any system that is concurrent needs first-class support for handling exceptions that occur in a thread pool. I appreciate that Lamina puts an emphasis on this.

In Master Concurrent Processes with core.async

lkrubner·Aug 30, 2014

I have not worked at the scale discussed by Joseph Wilk, but I am pleased so far with my ability to build out micro-services with Clojure. The eco-system around Clojure seems to get stronger every day. I'll mention a few of the libraries that I'm using. For building out a RESTful API, I found Liberator to be very clever and original: http://clojure-liberator.github.io/liberator/ For handling internal queues, I use Lamina: https://github.com/ztellman/lamina For instance, when saving something to the database, I usually put the data in a closure, put the closure in a Lamina "channel" and let some workers execute the closure when the thread-pool and IO constraints allow. I just started experimenting with the Ribol conditional restart system, for error handling: http://docs.caudate.me/ribol/ For the integration of frontend with backend (Mongo

Read the rest

DB) we were originally going to use DerbyJS, but I talked the team into trying Sente instead: https://github.com/ptaoussanis/sente We are not done, so the jury is still out, but I am very impressed, so far, with Sente. For dealing with MongoDB, we use Monger, a library that just keeps getting better and better: http://clojuremongodb.info/ In terms of my personal development, I have struggled to find a workflow that allows me to be efficient at the REPL. I am just now starting to use Daniel Szmulewicz "system" which I am hopeful about: https://github.com/danielsz/system

In Building Clojure services at scale

gdubs·Jun 28, 2013

Interesting -- this looks similar to Lamina [1], which I've used an really like. 1: https://github.com/ztellman/lamina

In Clojure core.async Channels

adambard·Jun 28, 2013

This has me super excited to build something cool with ClojureScript in the near future. I'm used to using lamina (https://github.com/ztellman/lamina) in Clojure, but for working with the browser this is a whole new world.

In Clojure core.async Channels

w01fe·May 2, 2013

Re: interactive visualizations, we haven't gotten there yet, but it sounds like a really cool (and feasible) idea. On this front, libraries like 'lamina' look like a nice place to start. https://github.com/ztellman/lamina Graph backtraces look like ordinary stacktraces -- the compiled output is basically the same if you wrote the function by hand. For logging, we wrap each node in an 'observer' with the path through the graph injected, which automatically records execution time and exceptions from each node, and lets you spit stuff out to the dashboard that will appear in the graph structure. There's an example of this in the graph_examples_test.clj, I believe.

In Graph: Faster Abstractions for Structured Computation

dmix·Mar 27, 2013

Yep there's plenty of solutions to callback hell. My particular favourite is the Lamina library in clojure which takes the event-driven approach https://github.com/ztellman/lamina/wiki/Introduction

In 21 Nested Callbacks

migueldeicaza·Oct 22, 2012

It looks like Tame is a pre-processo that outputs C++, hardly a C++ language feature. I mean, more power to you if you like to use those, but that is hardly C++. The Scala question seems to have too many caveats, you should read the comments as there is no full translation of the F# async translation in the stackoverflow question. The answer with the most question states "with some important features lost". The comments on the question and answers should be read as well. Cute Http Stack though. The lamina code runs the code on a separate thread (https://github.com/ztellman/lamina/wiki/Introduction) hardly what C#'s async does. Not that I care that much, but that is what the docs say. You forgot to show us how Node.js is supposed to support async-like programming without callbacks. I suspect in a rush to enumerate a bunch of langu

Read the rest

ages, you merely listed everything you could think of and hoped some of it would stick?

In The future of .NET

codewright·Oct 21, 2012

Let me help you. https://github.com/okws/sfslite http://www.read.cs.ucla.edu/tamer/ http://stackoverflow.com/questions/5579602/what-is-the-scala... You will note that it's a comparison between F# and Scala. http://dispatch.databinder.net/Dispatch.html The standard HTTP client of choice is async, although the simple API wouldn't necessarily tell you as much. https://github.com/ztellman/lamina From the clojure people. Agents bear mentioning too.

In The future of .NET

prospero·Apr 10, 2012

I haven't really written about this anywhere, and the code in its current state is far from self-documenting, so I'll give it a shot here. The code transformation is pretty much all local. Since everything in Clojure is an expression (this is not true of Python or JS, I'm not sure about F#), I don't need to perform much analysis, I just need to make sure that each expression doesn't care about the difference between a future and a realized value. Let's assume three primitives: * an asynchronous future [1] * something which merges a list of futures and realized values into a single future representing a list of values * something which takes a function and a future, and returns a future representing '(apply fn value-of-future)', that will be realized once the future is realized All we need to do is take every expression where a function i

Read the rest

s called, merge the arguments together, and apply the final primitive to the expression. The expression will return a future, which can then be picked up by the parent expression, and so on. This glosses over how special forms are handled, and how the 'force' functionality works. Also, as I mentioned in the presentation, how the code executes is pretty opaque, and some sort of higher-order analysis would be nice so that it could be visualized using graphviz or something. This is still an experimental feature, and will probably remain so until the 1.0.0 release of Lamina (I'm working on 0.5.0 right now). I'm not aware of any other macro that rips apart normal Clojure code quite as completely, which means that this is sort of uncharted territory. I want to make sure I've avoided all the pitfalls before calling it ready for production usage. [1] https://github.com/ztellman/lamina/wiki/Introduction

In Event Driven Programming in Clojure