3 ms·

Can someone expand on what they mean by lightweight threads for Clojure? My understanding is that lightweight threads (green threads) is what java/jvm explicitl

Can someone expand on what they mean by lightweight threads for Clojure? My understanding is that lightweight threads (green threads) is what java/jvm explicitly moved away from way back when; it's user-mode threads bound to one processor, so if the processor gets busy, then all of the lightweight threads for that processor get blocked. Meanwhile, Java/jvm uses kernel threads and context-switching so you can do real multi-threading. I'm aware of how Quasar purports to be the best of both worlds, and it looks like Pulsar is a Clojure API for Quasar, maybe that's what they're using. It doesn't appear Scala has something comparative, but I have a hazy sense that Scala people believe that Akka and monads are better for easy asynchronous programming.

patrickthebold 11y ago
Clojure's core.async has "go routines", (this is more or less the same as in go), basically you can put and take messages on a channel. These operations will block the green thread, so you end up writing synchronous code. The idea is that synchronous, blocking code is easier to understand then async code. Since these are lightweight threads it will scale better than using real threads. I'm pretty sure it's fine to have hundreds of thousands of go routines. This abstraction sits on top of java's real threads, so you can have several real threads doing the work and they can switch between the go routines once the go routine hits one of the blocking operations. Or something like that... read this: http://clojure.com/blog/2013/06/28/clojure-core-async-channels.html http://clojure.com/blog/2013/06/28/clojure-core-async-channe...
astine 11y ago
It's likely that they're refering to core.async which is a Clojure library that provides IoC threads via the `go` construct.
_halgari 11y ago
Core.async uses code rewriting to turn blocks of code into state machines. From there puts and takes from channels become state transitions. It works almost exactly like async/await in C# or Yield based generators in other languages. The cool bit is that core.async does this as a library, not a compiler level feature.
lmm 11y ago
Scala has Future (which yes does form a monad) which is very much the same thing as Clojure's core.async macro or Quasar's annotation-and-bytecode-manipulation and is very much directly comparable, it's just Scala's type system is powerful enough that you can do that in ordinary code rather than a language-level special feature. Akka is also an option, though not one that I like.

patrickthebold 11y ago

Clojure's core.async has "go routines", (this is more or less the same as in go), basically you can put and take messages on a channel. These operations will block the green thread, so you end up writing synchronous code. The idea is that synchronous, blocking code is easier to understand then async code. Since these are lightweight threads it will scale better than using real threads. I'm pretty sure it's fine to have hundreds of thousands of go routines. This abstraction sits on top of java's real threads, so you can have several real threads doing the work and they can switch between the go routines once the go routine hits one of the blocking operations. Or something like that... read this: http://clojure.com/blog/2013/06/28/clojure-core-async-channels.html http://clojure.com/blog/2013/06/28/clojure-core-async-channe...

astine 11y ago

It's likely that they're refering to core.async which is a Clojure library that provides IoC threads via the `go` construct.

_halgari 11y ago

Core.async uses code rewriting to turn blocks of code into state machines. From there puts and takes from channels become state transitions. It works almost exactly like async/await in C# or Yield based generators in other languages. The cool bit is that core.async does this as a library, not a compiler level feature.

lmm 11y ago

Scala has Future (which yes does form a monad) which is very much the same thing as Clojure's core.async macro or Quasar's annotation-and-bytecode-manipulation and is very much directly comparable, it's just Scala's type system is powerful enough that you can do that in ordinary code rather than a language-level special feature. Akka is also an option, though not one that I like.