World: r3wp

Objets language are a mess because of that.
We all know why we real programmer prefer C and hate C++ ;-)

ok - so what needs to be done to get us utypes? :-)

And you can screen function calls for security (we do this a lot 
in the mezzanines). It is much more difficult to screen assignment 
statements with other side effects.

And what do you think of modules like properties for objects? I mean 
e.g. export property? I think that complicate the case further probably 
does not make sense?

Modules are higher end, and I can replace the code if I had to (and 
have more than once). We don't need export-like properties for objects, 
we can easily just use modules for that, even modules constructed 
at runtime. The main advantage to objects over modules is that they 
are fast and simple.

Most of the module-like stuff we used to do with objects can be done 
with modules instead. We should be conservative about what goes in 
an object spec.

You'd be surprised at how easy it is to add a keyword to make module! 
syntax. Having done it once, doing it again was mostly copy-paste 
of the first keyword's code, and figuring out the interactions and 
priorities. And the code is (intentionally) small and simple.

Can someone tell me the current state of R3?  I'm a bit confused 
as I don't keep up with the news enough.  Can we do graphics yet? 
 What are we looking at from a performance perspective, etc..?

R3 Core is quite usable, but it still heavily depends on your needs 
(some areas are rougher than others). Basic graphics (draw) work 
on Win32 for hostkit builds. Performance on a script level was comparable 
to R2 (sometimes R3 a bit slower) for my uses, last time I did some 
measurements.

In many cases R3 is a lot faster. The whole balance of optimizations 
was shifted.

R3-optimized code is often faster than the equivalent R2-optimized 
code, and it looks nicer too most of the time, both due to native 
changes that make nicer-looking code more efficient.

BrianH, Ladislav, still have not understood why automatic delegation 
is so bad and not used in REBOL. From time to time this discussion 
arises again and again. Seems people are used to constructors and 
destructors and want them in rebol too.

Automatic delegation: sorry, that is not a question for me. I never 
told automatic delegation was bad.

What is bad, though, is writing a code sample in a question, obtaining 
a translation in Rebol working the same way, and saying: "Your code 
doesn't reflect the same intent as my js code..." - it is enough 
that he obtained a working translation of his code, if his "intent" 
was different, he should have written the code in accordance with 
it, this is exactly how it should *not* be done.

As far as automatic delegation is concerned: I am not missing it, 
but, certainly, your mileage may vary.

The fact is, that I can live without it, being able to implement 
a similar system in Rebol when needed (did not need it yet, though), 
so there is nothing I could miss.

...people are used to constructors and destructors

 - that has nothing in common with automatic delegation, though, at 
 least I feel it that way

Well, we were only wandering, discussing about how things could be 
done. There were no complaints in such.

In fact, there is complain. My whish is to read a statement from 
Carl to undestand which advantages he sees and the phylosophic choices 
made for REBOL.

*there is NO complain

Regarding the: "...why automatic delegation is ... not used in REBOL." 
- that looks as a question I could answer, though. Reasons (as I 
see them):


* the present system of independent objects is safer (no need to 
worry about somebody changing the prototype used to define your object)

* the present system of independent objects is simpler (no need to 
worry about such things as multiple inheritance)

There may be other factors as the ease to implement such a feature, 
or the speed of the interpreter, etc.

Ladislav, I have another question: why there are no SET/GET accessors 
in REBOL objects ?

SET works with objects in R3 (if that is what your question was about)

Similarly for GET

(may be handy)

How ? Could you make an example ?

>> o: make object! [a: 11 b: 12]
== make object! [
    a: 11
    b: 12
]

>> p: make object! [a: b: none]
== make object! [
    a: none
    b: none
]

>> set p get o
== [11 12]

>> p
== make object! [
    a: 11
    b: 12
]

(It was not the question, I guess)

In fact, it was not the question.

I mean as GET the automatic function called by an object  to return 
its value..

using the path notation ?

(back the topic)

There was a lenghty discussion in OTHER LANGUGES from 3rd of MAY 
of this year.
It led to http://www.rebol.net/wiki/Objects_enhancements

Giuseppe, part of the reason that there are no set accessors (what 
I called "properties" above) in REBOL is that there are no classes 
either, so such accessors would need to be defined on a per-object 
basis. This makes them quite a lot less useful. The other part of 
your question is that we *do* have get accessors: We use the same 
syntax for variable getting as we do for function calls, so you can 
just assign a function to a word and it will act like a get accessor. 
You only need real get accessors in a language that puts parens around 
arguments or in some other way distinguishes function calls. However, 
let's for the moment assume that you mean get-word accessors, functions 
that will still be called even if you use the GET function, a get-word 
or get-path to access the value.


But one of the main reasons is to avoid hidden unexpected overhead 
and security issues. Assignment is fast in REBOL, because it does 
basically the same thing every time (with some variation in set-path 
assignment). If we had properties, that would add overhead to every 
single assignment statement whether to a property or not just because 
we would have to check for that every time. In languages with native 
properties their compiler makes this determination and generates 
the underlying function calls. With REBOL that overhead is at runtime 
because we don't have a compiler. We could compile our own dialects 
to make set-word accessors - Gregg's COLLECT, or R2/Forward's APPLY 
or MAP-EACH do this - but it is slower.


The security issue is that at the moment assignment and get-word 
access is safe. Set-path assignment and get-path access is at least 
safe with the built-in datatypes. Accessor assignment is not safe: 
it can have side effects or unexpected overhead. If we had accessors 
then you could not safely use words that you got from unknown locations. 
We wouldn't even be able to screen for functions, which a lot of 
the mezzanine code does now. Combined with get-word arguments and 
that means that there would be no way to avoid code injection exploits, 
and thus no way to make even a secure subset of REBOL. 


Now with path syntax the behavior is (apparently) type-specific, 
so with the appropriate datatypes we can do accessor functions; .NET 
object wrappers would benefit from this, for instance. But that requires 
utypes, because there is no point to making built-in types have that 
behavior. Then for security we could just disallow utypes from a 
function that might otherwise be exploitable.

Ok Brian, I have understood.

Somethimes I think that we should add this clarifications to DOCBASE 
for further referencing.

I suppose Utype will be address sometime in the future.

It's planned, but not likely to be in 3.0 afaict.

There is a placeholder type and a lot of the constraints it will 
have are known already because we already figured it out (no literal 
syntax, for instance).

Brian its not a problem. My main concert for REBOL3.0 is about documentation.

Many discussion regarding R3GUI and REBOL3 Core happen here and they 
ar not reflected elsewhere.

We need a skilled person (surely it is not me) that mirrors everything 
to the main documentation.

However I would like a lot to wrap .NET objects and use them.

Is it possible to open UDP port under R3?

-_-;

Carl has forgotten...

An idea of NTP scheme, but servers comunicates only on 123 UDP port. 
overview of time services:

Daytime:  Ascii response,  Graham and Ladislav has written a scheme/tool 
already  port 13

Time: most simple possible server listening on port  37 answer 32bit 
unsigned number of second from 1-1-1900/0:00 (calculation of human 
readable date is not so trivial because of leaping seconds inserted 
to UTC with no rule at all, an Earth is dancing a Jive in fact)

HTTP: use inserted Date-time from any header returned from server 
port 80

SNTP: more precise protocol (contains also fraction of second in 
reply) subprotocol of NTP on UDP port 37

NTP: most precise available to compare more time servers, and calculate 
with computed transport delay and phase shift from evaluated couple 
of handshaking packets.  UDP port 37

The latter two use minimally 12  32bit binary packets for request 
and response, symmetric or asymetric cryptography possible (honestly 
I've no clue why this).

I've got a reply from NTP server via SNTP packet (RFC 2030) almost 
all nulls in client packet (in Rebol 2 UDP port, because it is not 
clear how to do it in R3)

BTW Steeve there is UDP definitions in header files of Host kit, 
so I think UDP should be possible somehow, but TCP scheme is hard 
coded (ie not available to play with other variants)

Say I have a huge file, there are some grabage bytes in its tail. 
How can I truncate it? Remove doesn't work on the file port.

Try CLEAR instead of REMOVE.

Thanks ChristianE. It works.

BTW the file couldn't be truncated from R3 I think (no func option 
available for this) but similarly as udp truncation is mentioned 
in c sources of host kit.