M. Edward (Ed) Borasky wrote:
Anyhow, CSP is "old hat" -- this year's "silver bullet" is the
PI-Calculus, a close relative of Hoare's CSP and a direct descendant of
Milner's CCS. I like the PI-Calculus just as much as I liked CSP, Occam,
Concurrent Pascal, CCS, Linda/Rinda and all the other theoretical
computer science approaches. In my own field, performance engineering, I
like the CCS derivative, Jane Hillston's PEPA. But what are the guys
with the big bags of nickels buying?
You should take a look at Occam-PI
(http://www.cs.kent.ac.uk/projects/ofa/kroc/\) which is a marriage of
PI-Calculus and OCCAM...
Ram
Ron M wrote:
Daniel Martin wrote:
> "M. Edward (Ed) Borasky" <znmeb@cesmail.net> writes:
>> Strangely enough, I don't recall ever seeing a *real* programming
>> language, to be distinguished from academic ones, that ever handled
>> parallelism in a manner other than as calls to run-time
>> libraries. Ruby already has that.
>
> Erlang doesn't count? True, I don't know of anyone using it besides
> Erikson...
A couple other notable projects built with Erlang are
-snip-
The Erlang user conferences and workshops might give a better idea of
what Erlang is being used for
http://www.erlang.se/euc/index.shtml
http://www.erlang.se/workshop/index.shtml
Erlang in Banking and Financial Switching
http://www.erlang.se/euc/03/
Erlang's sort of a strange one. Obviously, it can't be called
academic, and the programming model is entirely based on concurrency,
but at the same time, it doesn't support native threading. I've always
thought that is a strange choice. They have really fast user-space
threading, but it will never use multiple processors unless you're
running multiple Erlang VMs, and then you have to explicitly start your
thread on the VM of your choice, from what I understand.
I read somewhere about Erlang that the next release of the VM will
support using OS threads for pooling Erlang processes transparently.
I can't recall though when the referred statement was written -- it's
possible that it was written long before and that "next release" has
came to reality since then.
Still, I love
the language. I wish ruby allowed overloading of the ! operator, just
so I could implement a ruby thread wrapper that could accept messages
with Erlang syntax 
Well, in Erlang it's a principle that processes may communicate _only_
via the messaging interface. It's achieved by the (almost) pure
functional semantics. Data is never modified in-place, always copied. A
function (in particular one ran in a process) can see only the values
which were passed to it as arguments (by value).
[Disclaimer: AFAICS, IANAEH]
I wonder how would you enforce this strong separation in ruby... maybe
_why-s shiny Sandbox could be made use of?
Regards,
Csaba
···
On 2006-07-20, tsuraan@tsuraan.net <tsuraan@tsuraan.net> wrote:
AFAICS slave.rb's operation is based on fork(2).
So a slave based code is not using a language feature but an OS feature;
it tells nothing (or very little) about the expressive power of the
language. And it neither performs well as a concurrency implementation.
Regards,
Csaba
···
On 2006-07-21, ara.t.howard@noaa.gov <ara.t.howard@noaa.gov> wrote:
require 'slave'
Pit Capitain wrote:
Yukihiro Matsumoto schrieb:
>Matz, you can find it online from
>
> http://www.computer.org/portal/site/computer/
Thank you, unfortunately I have to buy the article for $19.00, which
seems too expensive for a single article.
Wierd. I didn't have to pay for it. I've seen that Srinivas has already sent you the URL of the article.
Yeah it's really weird. If you go to the main page, the article is there
available for free. But if you go to past issues > May 2006 you can only
read the summary with an option to buy the article as a pdf. Talk about
consistency...
Daniel
I'm glad you mentioned Occam. I was going to suggest a look at the link;
http://groups.google.com/group/comp.sys.transputer/browse_thread/thread/761899fe564cd4d8/cd5214b7f1cf2425?lnk=st&q=&rnum=4#cd5214b7f1cf2425
This is a little old. I'm glad that the hot bed of Occam programming (Kent) is still working with it.
Besides it's explicit parallelism, Occam's other claim to fame is its basis in Formal Methods. Many years ago, silicon chip designs were 'derived' from Occam program descriptions. When INMOS was bought by EMI and then absorbed into STM, the idea of deriving silicon went silent. My hypothesis was that STM was using Occam ++ internally as its silver bullet design methodology. Complex chips need to work with a minimum of tweeks in the manufacturing process.
rmeenaks@olf.com wrote:
···
M. Edward (Ed) Borasky wrote:
Anyhow, CSP is "old hat" -- this year's "silver bullet" is the
PI-Calculus, a close relative of Hoare's CSP and a direct descendant of
Milner's CCS. I like the PI-Calculus just as much as I liked CSP, Occam,
Concurrent Pascal, CCS, Linda/Rinda and all the other theoretical
computer science approaches. In my own field, performance engineering, I
like the CCS derivative, Jane Hillston's PEPA. But what are the guys
with the big bags of nickels buying?
You should take a look at Occam-PI
(http://www.cs.kent.ac.uk/projects/ofa/kroc/\) which is a marriage of
PI-Calculus and OCCAM...
Ram
rmeenaks@olf.com wrote:
You should take a look at Occam-PI
(http://www.cs.kent.ac.uk/projects/ofa/kroc/\) which is a marriage of
PI-Calculus and OCCAM...
Yes, I should take a look at that. Although ... CSP (Occam/Hoare) and CCS (Milner) cover pretty much the same ground, and the PI-Calculus is a direct descendant of CCS. I'm wondering what CSP can do that the PI-Calculus can't.
···
Ram
Well, in Erlang it's a principle that processes may communicate _only_
via the messaging interface. It's achieved by the (almost) pure
functional semantics. Data is never modified in-place, always copied. A
function (in particular one ran in a process) can see only the values
which were passed to it as arguments (by value).
How (almost) pure functional? I haven't used Erlang much, but it seems to be totally pure-functional from what I can tell. They do use looping threads to keep state, so side-effects are possible that way, but is there a way to override defined variables?
[Disclaimer: AFAICS, IANAEH]
I wonder how would you enforce this strong separation in ruby... maybe
_why-s shiny Sandbox could be made use of?
For the places where Erlang is supposed to be used, I suppose that the extreme separation they use is a really good idea, but I'd love to just have the syntax available in Ruby. I tend to design a lot of my programs as processes sending each other messages right now (mind polluted by erlang, I guess), and just being able to have some nice syntax for that in ruby would make me quite happy.
--jay
true all. nevetheless it's an alternative to threads.
regards.
-a
···
On Sat, 22 Jul 2006, Csaba Henk wrote:
On 2006-07-21, ara.t.howard@noaa.gov <ara.t.howard@noaa.gov> wrote:
require 'slave'
AFAICS slave.rb's operation is based on fork(2).
So a slave based code is not using a language feature but an OS feature;
it tells nothing (or very little) about the expressive power of the
language. And it neither performs well as a concurrency implementation.
--
suffering increases your inner strength. also, the wishing for suffering
makes the suffering disappear.
- h.h. the 14th dali lama
Well, in Erlang it's a principle that processes may communicate _only_
via the messaging interface. It's achieved by the (almost) pure
functional semantics. Data is never modified in-place, always copied. A
function (in particular one ran in a process) can see only the values
which were passed to it as arguments (by value).
How (almost) pure functional? I haven't used Erlang much, but it seems
to be totally pure-functional from what I can tell. They do use
looping threads to keep state, so side-effects are possible that way,
but is there a way to override defined variables?
* As I heard, you are not prohibited to play dirty tricks with the
few globally accessible data structure like the process table
(although doing that is not considered to be good style).
* IIRC message passing is considered a side effect generating call. I could
imagine a concurrency semantics where it's not a side effect; I don't
see how Erlang's semantics relates to that.
* The big beast: I/O. A purely functional language must somehow encode
I/O as environment (world state) passing, like Haskell does it with
monads and Clean with unique types.
Erlang doesn't want to sink into such abstractions, it just does I/O
as usual.
I wonder how would you enforce this strong separation in ruby... maybe
_why-s shiny Sandbox could be made use of?
For the places where Erlang is supposed to be used, I suppose that the
extreme separation they use is a really good idea, but I'd love to just
have the syntax available in Ruby. I tend to design a lot of my
programs as processes sending each other messages right now (mind
polluted by erlang, I guess), and just being able to have some nice
syntax for that in ruby would make me quite happy.
I don't see into your mind, but maybe what's there is closer to the
idea of coroutines than to CSP style models.
Regards,
Csaba
···
On 2006-07-21, tsuraan@tsuraan.net <tsuraan@tsuraan.net> wrote: