Reia -- a Ruby fork?


#1

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.

#2

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-dynamic-language-on-erlang-vm.html

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.


#3

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-dynamic-language-on-erlang-vm.html

                                                 trans.


thanks,
-pate

Don’t judge those who choose to sin differently than you do


http://eldersjournal.blogspot.com


#4

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/


#5

2009/3/17 Jörg W Mittag
<removed_email_address@domain.invalidremoved_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.


#6

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


#7

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


#8

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


#9

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