Akka-like framework in Clojure ?

[Eric Le Goff]

Hi,

After a long background with imperative languages such as Java, I recently spent some time learning functionnal programming, starting with Scala. I had the opporrtunity to build a demo project based on the Akka framework.

Now I am starting learning Clojure, and would be curious to know if there was some clojure based framework available which could implement rather similar features to Akka.

In particular, I would be interested in an implementation of the Actor Model [1]

Thanks.

Eric


[1] http://en.wikipedia.org/wiki/Actor_model

[Tim Visher]

Hi Eric,

On Fri, Dec 27, 2013 at 3:54 AM, Eric Le Goff <ele...@gmail.com> wrote:
> After a long background with imperative languages such as Java, I recently
> spent some time learning functionnal programming, starting with Scala. I had
> the opporrtunity to build a demo project based on the Akka framework.
>
> Now I am starting learning Clojure, and would be curious to know if there
> was some clojure based framework available which could implement rather
> similar features to Akka.

I know of no such library for Clojure specifically (although I did not
look and have never needed to), but it appears that Akka is a Java
library, so worst comes to worst you could use it via [interop][1].

[1]: http://clojure.org/java_interop

--

In Christ,

Timmy V.

http://blog.twonegatives.com/
http://five.sentenc.es/ -- Spend less time on mail

[Tibor Mlynarik]

Hi Eric,

I haven't tried it's Clojure api, but Quasar/Pulsar [1] looks promising.

https://groups.google.com/forum/#!msg/clojure/1xxxTti6Vi0/m9HtBXankzUJ

cheers,

 Tibor

[1] http://puniverse.github.io/pulsar/ 

[Jan Herich]

Hi Eric,

Maybe pulsar is what you are looking for, but i recommend you to also discover the other way of doing concurrency in clojure instead of the actor model -> have a look at CSP and its clojure implementation the the form of the core library called core.async

Dňa piatok, 27. decembra 2013 9:54:16 UTC+1 Eric Le Goff napísal(-a):

[Bruno Kim Medeiros Cesar]

I haven't dabbled yet on actor-based concurrency, can someone point out (a blog post about) a comparison between Akka actors, Clojure agents and other solutions?

[Paulo Suzart]

Hi,

Am I wrong or Galaxy project (behind pulsar) is quite inactive? Does anybody know how promising are they?

Cheers

--
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clo...@googlegroups.com
Note that posts from new members are moderated - please be patient with your first post.
To unsubscribe from this group, send email to
clojure+u...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
---
You received this message because you are subscribed to the Google Groups "Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email to clojure+u...@googlegroups.com.
For more options, visit https://groups.google.com/groups/opt_out.

--
Paulo Suzart
@paulosuzart

[Alex Baranosky]

You can just use Akka directly w/ Clojure's excellent Java interop.

[Sean Corfield]

I got the impression - from talking to someone who tried to wrap Akka
in Clojure - that Akka's API was pretty nasty to use from Clojure?

Sean

Sean A Corfield -- (904) 302-SEAN
An Architect's View -- http://corfield.org/
World Singles, LLC. -- http://worldsingles.com/

"Perfection is the enemy of the good."
-- Gustave Flaubert, French realist novelist (1821-1880)

[kovas boguta]

The bottom line is that the definitive clojure distributed computing
solution is yet to be invented, but there are a number of things out
there including the aforementioned.

1. clojure wrappers for Akka, for instance

https://github.com/jasongustafson/akka-clojure

(there are several others, of varying quality.. just search github / google)

2. solutions implementing the idea of supervisor hierarchies, for instance

https://github.com/MichaelDrogalis/dire

(I believe there are other contenders in this category also)

3. RPC libraries, like https://github.com/sunng87/slacker

4. Batteries-included cluster-aware computing: http://immutant.org/

[Joshua Ballanco]

On Saturday, December 28, 2013 at 6:05, kovas boguta wrote:
> The bottom line is that the definitive clojure distributed computing
> solution is yet to be invented, but there are a number of things out
> there including the aforementioned.
>
> 1. clojure wrappers for Akka, for instance
>
> https://github.com/jasongustafson/akka-clojure
>
> (there are several others, of varying quality.. just search github / google)
>
> 2. solutions implementing the idea of supervisor hierarchies, for instance
>
> https://github.com/MichaelDrogalis/dire
>
> (I believe there are other contenders in this category also)
>
> 3. RPC libraries, like https://github.com/sunng87/slacker
>
> 4. Batteries-included cluster-aware computing: http://immutant.org/

One more to add to that list:

5. Clojure integration with Vert.X: http://vertx.io https://github.com/vert-x/mod-lang-clojure

Vert.X has a lot of really interesting properties (so long as you’re willing to stay within the JVM) while remaining nicely lightweight. Clojure support is still very new, but it’s being written by one of the main authors of Immutant. Essentially, if you’re looking for distributed computing (not so much web-based, necessarily) but don’t want to lug around JBoss/WildFly, it’s a good alternative to Immutant.

[Jakub Holy]

I too have heard that using Akka from Clojure is not so easy, see Distributed Actors in Clojure (5/2012) – a discussion of options for Akka-like stuff in Clojure. Akka is great but “interfacing to Akka from Clojure is not nice, and certainly not idiomatic”. Though there have been some new Akka-Clojure libs since that (akka-clojure, okku).

I also believe that Rich Hickey has some good reasons for why / when not to use actor-based concurrency. I cannot find the reference now, perhaps it is mentioned (also) in the StrangeLoop 2013 Clojure core.async Channels talk.

On Friday, December 27, 2013 9:54:16 AM UTC+1, Eric Le Goff wrote:

[Cedric Greevey]

On Tue, Dec 31, 2013 at 9:26 AM, Jakub Holy <jakub...@iterate.no> wrote:

I also believe that Rich Hickey has some good reasons for why / when not to use actor-based concurrency. I cannot find the reference now, perhaps it is mentioned (also) in the StrangeLoop 2013 Clojure core.async Channels talk.

Does anyone else think we could use a central, searchable clearinghouse containing all of the various arguments, rationales, and philosophical essays underpinning Clojure's design choices in text format? AFAICT a lot of that stuff is currently scattered hither and thither across the web, and a lot of it is buried in the audio tracks of videos where search tools can't find it, and even the videos aren't gathered in one place (e.g. a Youtube channel) but instead are disseminated all over the place across dozens of different hosting sites.

[Manuel Paccagnella]

I think I'd be very useful since understanding Clojure's design philosophy is of great value, even outside the Clojure(Script) camp. But I also think it'd require work from a certain number of volunteers (sounds like a wiki would be a useful tool for this).

There has been some work in this area:

• A suggestion from Michael Nygard for a book on "the Hickey/Halloway paradigm"
• An unofficial guide to Rich Hickey's brain :)
• The book "The Joy Of Clojure" from Chouser and Fogus (soon to be released the second edition)
  

But certainly a syntesis of the philosophy and design of Clojure, with links to presentations, articles and code would be useful.

What do you think?

Cheers,
Manuel