I like lisp, however, many times I end up using Erlang because I find its
concurrency mechanism so useful. Unfortunately there are quite a few
features of lisp that I miss when I use Erlang. I am starting to think
that it would be really cool to have Erlang style concurrency in lisp.
That got me to thinking, so far lisp has been able to implement every
major paradigm that has come along. It make sense that it should be able
to handle this style of concurrency as well. That being said, has anyone
played around with anything like this? Has anyone seen an implementation
in lisp of this concurrency style?
Eric Merritt wrote:
> I like lisp, however, many times I end up using Erlang because I find its
> concurrency mechanism so useful. Unfortunately there are quite a few
> features of lisp that I miss when I use Erlang. I am starting to think
> that it would be really cool to have Erlang style concurrency in lisp.
> That got me to thinking, so far lisp has been able to implement every
> major paradigm that has come along. It make sense that it should be able
> to handle this style of concurrency as well. That being said, has anyone
> played around with anything like this? Has anyone seen an implementation
> in lisp of this concurrency style?
I have not, but it would be great to see something like this. With some
help from the lisp system (where it would guarantee that no object
shared between the threads are mutable), you could allocate from
separate heaps for each thread, do parallel garbage collection in the
different threads, and have almost zero-overhead teardown of a
short-lived thread when it finishes (by deleting the heap - no need for
garbage collection).
A killer feature IMO.
http://c2.com/cgi/wiki?SmugErlangWeenie
astor
In article <······························@gmail.com>,
Eric Merritt <·········@gmail.com> wrote:
> I like lisp, however, many times I end up using Erlang because I find its
> concurrency mechanism so useful. Unfortunately there are quite a few
> features of lisp that I miss when I use Erlang. I am starting to think
> that it would be really cool to have Erlang style concurrency in lisp.
> That got me to thinking, so far lisp has been able to implement every
> major paradigm that has come along. It make sense that it should be able
> to handle this style of concurrency as well. That being said, has anyone
> played around with anything like this? Has anyone seen an implementation
> in lisp of this concurrency style?
Isn't there some work for Gambit (a Scheme implementation)?
There is even some Erlang compiler, which compiles to Gambit, IIRC.
Rainer Joswig wrote:
> Isn't there some work for Gambit (a Scheme implementation)?
> There is even some Erlang compiler, which compiles to Gambit, IIRC.
It's called Etos (Erlang to Scheme):
<http://www.iro.umontreal.ca/~etos/>
There is also a paper on it:
Marc Feeley, Martin Larose. "Etos: an Erlang to Scheme compiler".
département d'informatique et r.o., Université de Montréal.
Rapport technique 1079. Aout 1997.
<http://www.iro.umontreal.ca/~feeley/papers/tr1079.ps.gz>
--
Jens Axel Søgaard
This is very cool. The paper is pretty interesting as well. I wonder how
it actually maps erlang processes to scheme. I also wonder how it handles
the mutability of data structures in scheme. The goal here is to use
erlang style concurrency while programming in scheme. I hear the gambit
4.0 has very good support for concurrency. Unfortunately, it seems to be
in perpetual development like arc.
On Thu, 12 Aug 2004 20:48:05 +0200, Jens Axel S�gaard wrote:
> Rainer Joswig wrote:
>
>> Isn't there some work for Gambit (a Scheme implementation)?
>> There is even some Erlang compiler, which compiles to Gambit, IIRC.
>
> It's called Etos (Erlang to Scheme):
>
> <http://www.iro.umontreal.ca/~etos/>
>
> There is also a paper on it:
>
> Marc Feeley, Martin Larose. "Etos: an Erlang to Scheme compiler".
> d�partement d'informatique et r.o., Universit� de Montr�al.
> Rapport technique 1079. Aout 1997.
>
> <http://www.iro.umontreal.ca/~feeley/papers/tr1079.ps.gz>
Eric Merritt wrote:
> This is very cool. The paper is pretty interesting as well. I wonder how
> it actually maps erlang processes to scheme. I also wonder how it handles
> the mutability of data structures in scheme. The goal here is to use
> erlang style concurrency while programming in scheme. I hear the gambit
> 4.0 has very good support for concurrency. Unfortunately, it seems to be
> in perpetual development like arc.
Take a look at this presentation of the upcoming version of Gambit:
<http://www.iro.umontreal.ca/~boucherd/mslug/meetings/20040519/minutes-en.html>
--
Jens Axel Søgaard