Sorry if my question sounds stupid, as I don't know anything about
actors except that Erlang base it's concurrency on it and that's the
secret for running so many processes, but after reading that scala got
it's actor library I'm interested is it possible to implement Actors
in lisp without going under the hood , I mean messing with the
implementation ?
On Jul 13, 1:37 pm, Slobodan Blazeski <·················@gmail.com>
wrote:
> Sorry if my question sounds stupid, as I don't know anything about
> actors except that Erlang base it's concurrency on it and that's the
> secret for running so many processes, but after reading that scala got
> it's actor library I'm interested is it possible to implement Actors
> in lisp without going under the hood , I mean messing with the
> implementation ?
Links I forget to mention:
http://lamp.epfl.ch/~phaller/actors.html
and
http://lamp.epfl.ch/~phaller/doc/ActorsTutorial.html
Slobodan Blazeski <·················@gmail.com> writes:
> Sorry if my question sounds stupid, as I don't know anything about
> actors except that Erlang base it's concurrency on it and that's the
> secret for running so many processes, but after reading that scala got
> it's actor library I'm interested is it possible to implement Actors
> in lisp without going under the hood , I mean messing with the
> implementation ?
Actors are already provided by Common Lisp and Scheme.
Actors ARE closures!
This was discovered by Sussman and Steele (IIRC) when they tried to
implement actors in scheme, they got the exact same code as for
closure in their eval function.
See for example http://www.brics.dk/~hosc/local/HOSC-11-4-pp405-439.pdf
pages 19 and 20.
There's no way around it, lisp has it all! ;-)
--
__Pascal Bourguignon__ http://www.informatimago.com/
NOTE: The most fundamental particles in this product are held
together by a "gluing" force about which little is currently known
and whose adhesive power can therefore not be permanently
guaranteed.
Thanks for everybody for their recommended readings , I'll check on
those in the weekend. Now let's describe what I'm actually asking for
and please correct me where I'm reasoning wrong:
1 *Common-Lisper* wants to do a erlang like programming with thousands
of threads so he uses cl-muproc which depends on underlying lisp
implementation process-system. Erlangers could make ten of thousands
of them and a lisper is stuck with few hundreds.
In the meantime what scala actor libarary offers , or it says it
offers (didn't tried it myself):
1. Actor library on top of a usual java runtime - no changes to
language (scala ) nor the runtime.
So Lisp fails short. So do lisp have an actor library that we could
use to implement for example cl-muproc on top of it so we could run
comparable numbers of processes with Erlang (and now Scala) ? If we
don't have anything for practical use what's closest thing coming from
the researchers.
thanks
bobi
* When I say lisp I eman common lisp
** I would ignore for a moment difference between processes & threads,
as per my understanding one share data and the others don't
In article <·······················@w3g2000hsg.googlegroups.com>,
Slobodan Blazeski <·················@gmail.com> wrote:
> Sorry if my question sounds stupid, as I don't know anything about
> actors except that Erlang base it's concurrency on it and that's the
> secret for running so many processes, but after reading that scala got
> it's actor library I'm interested is it possible to implement Actors
> in lisp without going under the hood , I mean messing with the
> implementation ?
'Actors' and 'many processes' is not the same.
'Actors' are a paradigm like message passing. You can
implement it with many, few or even with one process.
What Actors does give you is a model of object-orientedness
that explicitly contains ideas of parallel computation
of messages.
http://www.dekorte.com/docs/actors/
There have been published books about Actors in
Lisp.
For example:
ABCL, An Object-Oriented Concurrent System: Theory, Language, Programming, Implementation, and Application. Akinori Yonezawa editor.
MIT Press, 1990, ISBN 0-262-24029-7
http://www.yl.is.s.u-tokyo.ac.jp/pl/abcl.html
http://www.yl.is.s.u-tokyo.ac.jp/pub/abcl-info/abcl-implementations.text
http://www.yl.is.s.u-tokyo.ac.jp/pub/
Recently I made ABCL/R2 to work in OpenMCL. Somehow.
--
http://lispm.dyndns.org
If you're interested in actors, you may also want to check out Gul
Agha's book:
http://mitpress.mit.edu/catalog/item/default.asp?ttype=2&tid=9756
I believe it is one of the first, and it has a Lispy actors
implementation (perhaps less practical and more theoretical than
you're looking for, though?).
--matt
On Jul 13, 6:59 am, Rainer Joswig <······@lisp.de> wrote:
> In article <·······················@w3g2000hsg.googlegroups.com>,
> Slobodan Blazeski <·················@gmail.com> wrote:
>
> > Sorry if my question sounds stupid, as I don't know anything about
> > actors except that Erlang base it's concurrency on it and that's the
> > secret for running so many processes, but after reading that scala got
> > it's actor library I'm interested is it possible to implement Actors
> > in lisp without going under the hood , I mean messing with the
> > implementation ?
>
> 'Actors' and 'many processes' is not the same.
>
> 'Actors' are a paradigm like message passing. You can
> implement it with many, few or even with one process.
> What Actors does give you is a model of object-orientedness
> that explicitly contains ideas of parallel computation
> of messages.
>
> http://www.dekorte.com/docs/actors/
>
> There have been published books about Actors in
> Lisp.
>
> For example:
> ABCL, An Object-Oriented Concurrent System: Theory, Language, Programming, Implementation, and Application. Akinori Yonezawa editor.
> MIT Press, 1990, ISBN 0-262-24029-7
>
> http://www.yl.is.s.u-tokyo.ac.jp/pl/abcl.htmlhttp://www.yl.is.s.u-tokyo.ac.jp/pub/abcl-info/abcl-implementations.texthttp://www.yl.is.s.u-tokyo.ac.jp/pub/
>
> Recently I made ABCL/R2 to work in OpenMCL. Somehow.
>
> --http://lispm.dyndns.org
On Jul 13, 1:59 pm, Rainer Joswig <······@lisp.de> wrote:
> In article <·······················@w3g2000hsg.googlegroups.com>,
> Slobodan Blazeski <·················@gmail.com> wrote:
>
> > Sorry if my question sounds stupid, as I don't know anything about
> > actors except that Erlang base it's concurrency on it and that's the
> > secret for running so many processes, but after reading that scala got
> > it's actor library I'm interested is it possible to implement Actors
> > in lisp without going under the hood , I mean messing with the
> > implementation ?
>
> 'Actors' and 'many processes' is not the same.
>
> 'Actors' are a paradigm like message passing. You can
> implement it with many, few or even with one process.
> What Actors does give you is a model of object-orientedness
> that explicitly contains ideas of parallel computation
> of messages.
>
> http://www.dekorte.com/docs/actors/
>
> There have been published books about Actors in
> Lisp.
>
> For example:
> ABCL, An Object-Oriented Concurrent System: Theory, Language, Programming, Implementation, and Application. Akinori Yonezawa editor.
> MIT Press, 1990, ISBN 0-262-24029-7
>
> http://www.yl.is.s.u-tokyo.ac.jp/pl/abcl.htmlhttp://www.yl.is.s.u-tokyo.ac.jp/pub/abcl-info/abcl-implementations.texthttp://www.yl.is.s.u-tokyo.ac.jp/pub/
>
> Recently I made ABCL/R2 to work in OpenMCL. Somehow.
Do you plan to post the code?