"Clojure core.async" by Rich Hickey (2013)

There comes a time in all good programs when components or subsystems must stop communicating directly with one another. This is often achieved via the introduction of queues between the producers of data and the consumers/processors of that data. This architectural indirection ensures that important decisions can be made with some degree of independence, and leads to systems that are easier to understand, manage, monitor and change, and make better use of computational resources, etc.
The objectives of core.async are:
- To provide facilities for independent threads of activity, communicating via queue-like channels.
- To support both real threads and shared use of thread pools (in any combination), as well as ClojureScript on JS engines.
- To build upon the work done on CSP and its derivatives, e.g. Java CSP and the Go programming language.
This talk will cover the motivation, design and use of the new Clojure core.async library.
Rich Hickey
Cognitect
@richhickey
Rich Hickey, the author of Clojure and designer of Datomic, is a software developer with over 20 years of experience in various domains. Rich has worked on scheduling systems, broadcast automation, audio analysis and fingerprinting, database design, yield management, exit poll systems, and machine listening, in a variety of languages.
Recorded at Strange Loop conference (thestrangeloop.com) in St. Louis, MO, Oct 2013.

[@JoshLemer]

Rich really beautifully shows here the issues with the reactive/callback/async style which I had never really appreciated before seeing this talk. Great stuff!

[@pandiatonicism]

I like Rich Hickey’s talks. I would have liked to hear more about why he chose CSP over the Actor model.

[@shegeley]

Why did It came out 1 month ago?

[@StrangeLoopConf]

The 2010-2013 videos were originally published on InfoQ. We are in the process of re-editing them and publishing them on TH-cam.

[@capability-snob]

In the first two minutes, rich explains: "good programs should be made out of processes and queues". If this statement triggers your gag reflex - that is, if you don't want to work on programs built like this, but rather want first-class API abstractions between components; the remainder of the talk will confirm your intuitions. CSP is really not a good basis for comprehensible concurrency, I understand that the watered down abstractions that javascript inherited from E are not perfect, but they are a lot more tractable in practice than channel use. Yes, Rich says that you "can send reply channels over the request channel" - but why not just use an abstraction that makes this the default, as promises do? That way you can have dynamic structure in your code.
I wonder a little if there has been a walking-back of core.async use in the broader clojure community in the last 10 years. I remember it being difficult to find libraries that did not use it.

[@estebanginocchiosilva8185]

rxjs in the js world has a great solution to this