Forum: Ruby Reia -- a Ruby fork?

Announcement (2017-05-07): www.ruby-forum.com is now read-only since I unfortunately do not have the time to support and maintain the forum any more. Please see rubyonrails.org/community and ruby-lang.org/en/community for other Rails- und Ruby-related community platforms.
Thomas S. (Guest)
on 2009-03-17 18:39
(Received via mailing list)
Has anyone played around with Reia?

  http://github.com/tarcieri/reia/tree/master

The syntax looks so close to Ruby's in most cases, it looks more like
a Ruby fork built on the Erlang VM.

                                                      trans.
pat eyler (Guest)
on 2009-03-17 18:44
(Received via mailing list)
On Tue, Mar 17, 2009 at 10:34 AM, Trans <removed_email_address@domain.invalid> 
wrote:
> Has anyone played around with Reia?
>
>  http://github.com/tarcieri/reia/tree/master
>
> The syntax looks so close to Ruby's in most cases, it looks more like
> a Ruby fork built on the Erlang VM.

It's a ruby-like language, but not really a fork.  You
can read an interview with the developer here:

http://on-ruby.blogspot.com/2009/03/reia-new-dynam...


>
>                                                      trans.
>
>



--
thanks,
-pate
-------------------------
 Don't judge those who choose to sin differently than you do

http://on-ruby.blogspot.com
http://eldersjournal.blogspot.com
Tony A. (Guest)
on 2009-03-17 19:51
(Received via mailing list)
On Tue, Mar 17, 2009 at 10:41 AM, pat eyler 
<removed_email_address@domain.invalid> wrote:

>
>
> http://on-ruby.blogspot.com/2009/03/reia-new-dynam...
>

Hi, I'm the developer.

Yes, this is correct.  Reia is its own language and is not a fork of
Ruby.
The syntax is heavily inspired by Ruby, however past the cosmetic level
things get very, very different.

Reia runs on the Erlang VM and attempts to use the object system itself
as
the concurrency mechanism.  All objects in Reia execute concurrently and
synchronize with messaging.
Jörg W Mittag (Guest)
on 2009-03-17 21:35
(Received via mailing list)
Trans wrote:
> Has anyone played around with Reia?
>
>   http://github.com/tarcieri/reia/tree/master
>
> The syntax looks so close to Ruby's in most cases, it looks more like
> a Ruby fork built on the Erlang VM.

The syntax is Ruby-like, but the execution model seems very close to
Smalltalk-71.

In fact, the whole *point* of Reia is *not* to be a Ruby fork: Tony
wrote the Revactor library for Ruby, but realized that the actor model
and Ruby's object model don't mesh well. That's why he wrote Reia in
the first place.

jwm
Jörg W Mittag (Guest)
on 2009-03-17 21:36
(Received via mailing list)
Tony A. wrote:
> Reia runs on the Erlang VM and attempts to use the object system itself as
> the concurrency mechanism.  All objects in Reia execute concurrently and
> synchronize with messaging.

Talk about coming full circle ...

In Smalltalk-71, Alan Kay experimented with having each object running
in its own process and communicating with asynchronous message
sends[1]. There is an older quote from Alan Kay, where he says that
one thing he very much regrets, is not emphasizing the message sending
aspect of object-orientation enough. And just recently, he said that
not running objects in parallel, was one of the biggest mistakes of
Smalltalk, and indeed, that's what his new system (STEPS Toward the
Reinvention of Programming[2], at the Viewpoints Research
Institute[3]) does.

In one of his talks, he demonstrated a nice text layout algorithm,
where every single letter is just a simple object, with insect-like
behavior and just two instincts: follow your predecessor and go as
high as possible, which leads to results comparable in quality to
LaTeX, but in only 6 lines of code.

Smalltalk-71 was what inspired Carl Hewitt to invent the Actor Model.
Now – he basically believed that the ideas of Smalltalk-71 were good,
but the model was *much* too complex. Now, Ruby, a very faithful
implementation of the Smalltalk object model, and Erlang, a very
faithful implementation of the Actor Model, combine and produce Reia,
an object-oriented parallel actor language, in which the concepts of
process == actor == object have been unified, just like in
Smalltalk-71.

jwm

[1] In fact, that's where the whole confusing terminology of "sending
      messages" instead of "calling methods" comes from. Nowadays, it
      doesn't make sense, of course: since method calls in Smalltalk
      or Ruby *aren't* asynchronous, they are just method calls, not
      message sends.
[2] <http://VPRI.Org/pdf/tr2007008_steps.pdf>
[3] <http://VPRI.Org/>
Tony A. (Guest)
on 2009-03-18 01:28
(Received via mailing list)
2009/3/17 Jörg W Mittag
<removed_email_address@domain.invalid<removed_email_address@domain.invalid>
>

> sends[1]. There is an older quote from Alan Kay, where he says that
> one thing he very much regrets, is not emphasizing the message sending
> aspect of object-orientation enough. And just recently, he said that
> not running objects in parallel, was one of the biggest mistakes of
> Smalltalk, and indeed, that's what his new system (STEPS Toward the
> Reinvention of Programming[2], at the Viewpoints Research
> Institute[3]) does.
>

Interesting.  I've enjoyed Alan Kay's remarks on the matter,
particularly
this one:

> "I thought of objects being like biological cells and/or individual
> computers on a network, only able to communicate with messages (so messaging
> came at the very beginning -- it took a while to see how to do messaging in
> a programming language efficiently enough to be useful)."
> — *Alan Kay*
>
*
*...however I was completely unaware he was working on a concurrent
object
system as well.

That's some excellent background info, thanks!


> Smalltalk-71 was what inspired Carl Hewitt to invent the Actor Model.
> Now – he basically believed that the ideas of Smalltalk-71 were good,
> but the model was *much* too complex. Now, Ruby, a very faithful
> implementation of the Smalltalk object model, and Erlang, a very
> faithful implementation of the Actor Model, combine and produce Reia,
> an object-oriented parallel actor language, in which the concepts of
> process == actor == object have been unified, just like in
> Smalltalk-71.
>

That's the goal, although keep in mind process and objects are not fully
unified in Reia.  Objects are processes which talk a common protocol,
but
you're still free to write fully asynchronous processes just as you
would in
Erlang.  Objects can still receive raw messages sent using Erlang's
actor
protocol and can also send them, so using the two in conjunction isn't
particularly difficult.  Asynchronous alternatives are also provided for
all
parts of method dispatch, so objects too can be used asynchronously.
Sean O. (Guest)
on 2009-03-18 05:03
(Received via mailing list)
reia is the first language since I first came across ruby that made my
heart skip a beat.

I have one request - more examples.

best regards,
Sean
Louis-Philippe (Guest)
on 2009-03-18 17:47
(Received via mailing list)
seeing the mailing thread not turn into a flame war when talking about
an
other language, shows how this Reia newborn could have a future growing
close to Ruby.  I wouldn't mind if Tony kept posting his development
over
here.

L-P

2009/3/17 Sean O'Halpin <removed_email_address@domain.invalid>
Michal S. (Guest)
on 2009-03-18 22:10
(Received via mailing list)
Hello

2009/3/17 Tony A. <removed_email_address@domain.invalid>:
>
> Hi, I'm the developer.
>
> Yes, this is correct.  Reia is its own language and is not a fork of Ruby.
> The syntax is heavily inspired by Ruby, however past the cosmetic level
> things get very, very different.
>
> Reia runs on the Erlang VM and attempts to use the object system itself as
> the concurrency mechanism.  All objects in Reia execute concurrently and
> synchronize with messaging.


Is it possible to install outside of the Erlang lib directory (ie as
non-root)?

Thanks

Michal
This topic is locked and can not be replied to.