World: r3wp

steeve are you being ironic?

There are ways to make private data with object in R2 aswell, using 
BIND, if I remember.

yes you can bind code to two different objects, its quite easy in 
fact.

but you can't bind properties of one object into another one

define properties

no inheritance either

you can have a function in one object which executes code from anothe 
object using its own values.

attributes/vars of objects

What I meant is:

o: context [
	a++: show-a: none
	use [a] [
		a: 0
		a++: does [a: a + 1]
		show-a: does [a]
	]
]


Whis way a is hidden, and you have two methods, one to add 1 to a, 
and one to show a.

I prefer that

context [
	a: 0
	set 'o context [
		a++: does [a: a +1]
		show-a: does [a]	
	] 
]

Nice one!

i use it all the time

And I use that a lot myself too.

Almost all my programs start with:

REBOL [ ...]

context [
...

so, we don't need that private/public stuff

It is planned to get access controls for object! fields, but we don't 
know how yet (haven't decided).

REBOL 3 already has module encapsulation (as of last week).

Also in modules.. once there will be basic functionality (if I understood 
well)

We also have multiple inheritance (kind of):

>> o1: context [a: 1]
>> o2: context [b: 2]
>> o3: make make o1 o2 [c: 3]
>> o3/a
== 1
>> o3/b
== 2
>> o3/c
== 3


I can't remember, what else is in OO theory. But don't we have most?

its not dynamic inheritance

It's not. We do dynamic inheritance manually in REBOL. Our objects 
are object-oriented in a different way than class-based langs.

but having classes is MUCH faster. I mean exponentially.  as in liquid 
we are talking about 100 times on large datasets.

and with huge datasets it becomes wholly impossible to work with 
rebol's object system.

accessors would allow us to build ANY OOP theory within.

You optimize your code differently for prototype-based object-oriented 
languages than you do with class-based.

even hiding liquid's dataflow engine to make it completely invisible 
  :-)

you can't optimise the fact that rebol's static binding has to be. 
 this is both slow and memory intensive.

using classes in liquid I was able to go over 1 million nodes in 
a decent time frame, under 400MB.  using prototypes, I wasn't even 
able to allocate 100000 nodes.

and at 10000 nodes, IIRC it already takes like 10 minutes.

Accessors are one proposal for the upcoming object revamp. Class-based 
is unlikely, since we can emulate classes just as fast as any other 
non-compiled language.

10000 (concurrent) nodes in current liquid takes a few seconds to 
allocate  :-)

You don't have the R3 tricks.

then the liquid classes will be Even faster in R3?  ;-D

if they didn't crash it outright  :-(

Of course, but only if you get involved in the development discussion 
when we do the object revamp :)

is there a target on when that will happen?

No, we are working on modualrizing and codecs right now. I'll keep 
you in the loop :)

if someones give me a ping when the discussions will start, I'll 
be most happy to add my 2 cents.   I hate OOP, but I love to use 
objects.

and I think liquid is a great test bed of one of the most advanced 
object usage in R2 to date.

one of its strengths, is the fact that I can switch classes on the 
fly  :-)

I want accessors for other reasons (interoperability with other object 
systems).

I want accessors to provide virtualised internals.

The R3 GUI is class-based with dynamic inheritance (and switchable 
classes), so you can be sure that we will make that fast.

cool.

And modules use object! contexts, so we will be adding access controls 
to objects so modules can use them :)

that is cool  :-)

contextualise module methods based on state  :-)

btw, I'm really sorry if I'm not participating in the R3 GUI effort... 
I'm just elsewhere in the GUI world... what you guys are doing, I've 
done so many times, on too many platforms, for it to be still *fun*.


a lot of people don't get that I use (and occasionally abuse) rebol 
for my own long-term goals.  its just the fastest prototyper out 
there.  Now that GLASS has officially started, the (eventual) end 
goals for it are sort of beyond current desktop/window/button/menu 
 concepts of GUI, even if that is what I am starting with, cause 
I need the bricks before building the wall.

but when R3 gets a bit more stable, most of the work done in R2 will 
go over R3.  I'll only have to recode one or two core libs for all 
the rest to function.

Keep in mind that I am not really participating in the R3 GUI effort 
right now either - I've been working at a lower level. I write LOAD 
:)