AltME groups: search

RPC means that you call a function on the other side, and you get 
back a result

or you don't, if you call it in async mode ... but maybe Maarten 
already implemented more than only RPC then ...

messaging does not imply a procedure call, even though in practice 
you will be doing that

Chord in itself is an algorithm, we call it a protocol because it 
involves more nodes talking to each other

but you can call me #{8AFE} for short.  My friend call me "8"

Perhaps in time we'll see a *real* IOS based on a P2P stack on top 
of REBservices. Didn't you call that IOS-NG ;-)

Well, I wonder what has less overhead.. reading a 23kb protocol with 
each call, or taking the time to do a tcp call?

are you waiting for responses before you call it again?

IMO View OS wrapper should be strenghtened in general. It would not 
hurt to properly detect two monitors or TV output, if possible. I 
can see that MANY apps get it incorrectly, e.g. they simply call 
center-screen or such a function, and half of the dialog box is on 
one string, the other half is on second one :-)

How is the world lookup working in detail in AltME. I'm asking, because 
I have a problem at work, where they run behind a firewall, and they 
use a ip-range from the outside into the firewall.


My guess is, that the AltME client ask the World Name server, where 
a certain world is located, and the server respond with a IP-number. 
So when a world is created, the world name is stored at the name 
server together with the IP number. And the IP number is read in 
the messages sent over the network. So for me to tell the network 
manager at work, what ports for what IP numbers to open in the firewall, 
I could call a site like
http://www.myip.dk/

with a browser from the server, where the AltME world is created. 
And this should be the IP number, for which the ports (5400-5409) 
should be open for incoming trafic.

Is this correct?

That is one example Gregg.  But even in regards manual controls.


As best as I can tell the only system I perceive as working is a 
benevolent human dictator or benevolent fascist group (moderators). 
  And most people won't even notice them, a few people will notice 
them and appreciate them, and a very small group of people will dispraise 
them and it could become violent if pulled into the real world.  
And that models the whole thing for me : )


In this world (unrelated to AltME), we have mostly taken the position 
that we can work most things out, or push/pull people into other 
group.  It is not 100%, but as I'm fond of saying, nothing is.


I little patience, tolerance, ignoring, what ever you want to call 
it, goes a long way everywhere...

Beer pressure does work.... that is how I ask contractors to do things. 
 I call them over, and as I ask them to make changes, I pull out 
the ice from the bag, pull all the beer out of the boxes, and put 
it all in the cooler.  But the time I'm done talking it is all set 
up, and by the time they are done working, the beer is ice cold!


Graham, yes, great idea.  This is a model we have used in game rooms. 
 


It would be interesting in this context to see how people help each 
other.  I suspect it "might" be a zero sum game.  There are people 
that regardless of the facts simply help the underdog.    It is why 
so many hard criminals attract women from the outside.  


I have not seen anything like this though in Qtask.  I think the 
fact that you upload your picture makes you a little more "accountable", 
and that a moderator can kick you out.  Slashdot's system works pretty 
well, it might be fun to play with that more too.

Graham, not a joke, simply a process.  To call it a joke implies 
forethought

Reichart - and as for abbhorent behaviour. Interesting thing is, 
that ppl I work with, are never facing anything abhorrent. Some ppl 
(is it US specific?) are not used to "pressure" or how to call it. 
E.g. we are here in CZ used to look into one's eyes, ask private 
questions, whereas I believe in US it would not be appropriate, because 
you enter someone's "private zone". When few of us from CZ were at 
yoga training camp, we asked them some questions, and they felt offended, 
that we don't have right to ask for anything which could be regarded 
being a private matter. It took some time for them to understand 
it. One manager which taught me once told me - you can be harsh, 
you can fight - but don't fight ppl, fight arguments. And when I 
said that I regard something a blatant lie, it has nothing to do 
with you personally ...

This is no longer my call.

actually, its easy to figure out if rebol really has a 50 connection 
limit, just open a listener port and call a one line connection rebol 
script more than 50 times.

We need to create VID3 equivalent, call it SideWave, and we have 
killer app for REBOL :-)

however, in a trace a call to a slow function will count the same 
as a call to a fast function.

I believe they call the minimum value that floating point values 
can differ before they register as different: Epsilon.

Hmm.. there seem to be a few other LAUNCH issues in the Rambo database. 
I guess it's not as important as it used to be, now we have CALL.

Hmm, so is it worth posting a ticket (given that CALL is for free 
?) I suppose we still need LAUNCH for some of those options...

I guess I should post a ticket asking for clarification of LAUNCH 
options, especially argument handling.

Well, the advantage to launch is that it knows where to find the 
REBOL executable, so you don't need to hard-code that in your scripts. 
That is enough of an advantage to me over call to make this worth 
complaining about.

so, is launch just a short hand form of call ?

On windows platforms, you'll get the infamous DOS window flashing 
when executing an external CGI ! It's just a matter of 1 flag to 
correctly set in 'call C source code, if you're really annoyed by 
that, ask RT to fix it asap (for 2.7.6 that would be good)! ;-) I 
may reimplement completely call command in REBOL, but it would be 
a big waste of time and energy...it should be a 10 minutes fix for 
RT. Addind a time limit to 'call would be a good thing too, it would 
also avoid me the reimplementation of 'call to add such feature....
 - DocKimbel

Anx chance of getting above fixed? Should we rambo it?

I figured the author of the app would either be here, or be Carl 
(in which case I hope he'll eventually see the ticket, or he'll get 
a phone call from those guys).

they call the same underlying math libs

how can a call rebol from a PHP page ?

The explanation might be, that it should be possible to get the function 
without evaluating it. You can do that with PICK or FIRST:
f: pick bl 1
f: first bl

Now if bl/1 worked the same way, you always had to add DO to get 
it evaluated. So my guess is, Carl desided, that wouldn't be too 
smart, and I agree. It's the same with objects. To call a method 
(a function) within an object, you just write:
o/some-func

No DO is needed in front of that. So using path notation to get to 
a function within a block or an object will evaluate the function.

Rebol []

comment [
	; example usage:
	kernel: load/library %kernel32.dll

 routine-call kernel "MulDiv" [int] [3 [integer!] 2 [integer!] 1 [integer!]] 
 ; == 6
]

routine-call: func [
	library [library!]
	routine-name [string!]
	return-spec [block!]
	arguments [block!] 

 /typed {Arguments is block structure is: [argument-value [datatype] 
 ...]}
	/local routine spec call argument type typed-rule
] [
	spec: make block! length? arguments
	call: make block! (length? arguments) / 2 + 1
	insert call [return routine]
	typed-rule: copy []
	if typed [typed-rule: [set type skip]]
	parse reduce arguments [
		any [
			set argument skip
			typed-rule
			(
				insert/only tail spec 'argument
				insert/only tail spec either typed [
					type
				][
					reduce [type?/word get/any 'argument]
				]
				insert/only tail call get/any 'argument
			)
		]
	]
	insert tail spec [return:]
	insert/only tail spec return-spec
	routine: make routine! spec library routine-name
	do call
]

use [libc zero-char as-rebol-string malloc][
	libc: load/library %/usr/lib/libc.dylib ; osx variable

	zero-char: #"^@"

	as-rebol-string: func [
		[catch]
		s [string!] 
		/local pos
	][

  unless pos: find s zero-char [throw make error! "s is not a c-string"]
		s: head remove/part pos tail s
		replace/all s "\n" newline
		replace/all s "\t" tab
	]
	
	malloc: func [
        size [integer!] "size in bytes"
    ][
        head insert/dup copy {} zero-char size
    ]

	sprintf: func [
		spec {block structure is: [format values ...]}
		/local s
	][
		s: malloc 4096
		insert/only head spec 's
		routine-call libc "sprintf" [int] spec
		as-rebol-string s
	]
	
	printf: func [
		spec {block structure is: [format values ...]}
	][
		print sprintf spec
	]
]

The work above was mostly ladislave on the call-routine and the rest 
is mine. I will probably post it to rebol.org after a few changes 
and additions to make it work in all platforms. Maybe Carl will like 
to include it by default in rebol.

can I prevent the black shell window appearance? I try to call/console 
"ping 10.0.0.10", but the black window always appears ...

ah, it is call/console "cmd /C ping 10.0.0.10"

Maybe the amount of work will be too big compared with the number 
of bugs and misbehaviour, we might find. REBOL is rather stable, 
as it is. And: 1) we have RAMBO and 2) the power-users already know 
most of the misbehaviour (, if you can call it that).

it checks by os-call, not filename.

It's faster to check for final slash than to use DIR?, which, as 
Volker pointed out, makes an OS call.

>> print read dns://www.google.ca
72.14.207.104
>> fp: open/new/lines %google.txt
>> call/console/output "tracert 72.14.207.104" fp
== 0
>> close fp
>> data: read/lines %google.txt

== ["close fp" "close fp" "close fp" "close fp" "close fp" "close 
fp" "close fp" "close fp" "close fp" "close fp" "
close fp" "close...

I have also tried using /wait...
	call/console/wait/output "tracert 72.14.207.104" fp
with the essentially the same result.

use this 
call/console/output "tracert 72.14.207.104" fp: ""

probe fp

call/console/output "tracert 72.14.207.104" f %google.txt

sorry, it's wrong above.
Should be;
call/console/output "tracert 72.14.207.104"  %google.txt

just call/output "tracert www.google.ca" out: ""

should also be noted that other  langs i.e. perl exibit the same 
behavior on windows do it is apt to be an OS call that decides two 
decimal places is wau too heady for its users

why should be difference call different to simple usage of minus 
op?

I manually call a recycle at the end of each iteration. so 300MB 
is what is needed to have 100000 nodes in memory without any GC.

I actually think that your best bet here is to pass the context you 
will be saving to the saving function as a parameter, like your original 
example  storage/save-record context-to-save  or if you really want 
to delegate you can assign the function as a member of context-to-save 
and call it like  context-to-save/save-record context-to-save , but 
then you are changing the context you are saving wih saving overhead. 
REBOL does direct delegation by default, rather than mixin delegation 
like Delphi, because REBOL doesn't pass the object reference as a 
hidden parameter like object-oriented languages do. Rebinding your 
function body every time would be time-consuming and either non-recursion-safe 
(bind) or consume a lot of memory (bind/copy) - just passing the 
context as a parameter would be quicker.

james, no C syntax. I'm making a REBOL version of the OpenGL API 
with REBOL syntax. Users will be able to use normal REBOL and call 
OpenGL functions (with REBOL syntax).

Yes, it should be possible to call my OpenGL functions from an engine 
like that. That's the sort of things, I'm going to use this for. 
Only thing is, that the OpenGL window is inside a C execute, so you 
can't put REBOL controls (view stuff) in there. But you can then 
just have 2 windows.

>> do %printf.r
>> printf ["%d" .02 ]
** Access Error: Cannot open sprintf
** Where: routine-call
** Near: routine: make routine! spec library

Graham, there are two good reasons for that: Security and portability. 
Some platforms have one environment, some have per-process, some 
have global and per-user (like Windows) - which environment do you 
want to set? As for security, if you set any variable other than 
per-process it can affect the behavior of other programs, an ability 
that should be restricted in a sandboxed environment.


You should check out command line apps that you can call to set the 
various environments on your platform. If the REBOL process doesn't 
have call because of security restrictions, it shouldn't be able 
to set environment variables anyways.

run is available in ios. Somewhere i read in windows one can type 
a filename in shell, like text.txt, and windows launches the accosiated 
application. If that works, maybe with 'call too?

Or do you mean the REBOL process' environment that is inherited by 
the subprocesses started by CALL (assuming that CALL internally passes 
along the current environment to its subprocesses)? Or do you mean 
the environment of the parent process?


Every started process is passed an environment, usually a copy of 
the parent environment (sometimes with some modifications). On Windows 
(NT kernel, not 9x), the initial environment is a combination of 
variables associated with the system (or machine), the user and volatile 
values, in that order. The initial values of these variables are 
constructed from data in the registry. Once these variables are constructed 
and compiled into an environment, this environment is passed to a 
process. Changes to the environment of that process (with getenv 
and setenv) don't affect the environment of the parent processes, 
and certainly don't affect the global values.


To change the initial environment variables, you need to change them 
in their original registry entries. You can either do that directly 
or through using external applications. Keep in mind that changes 
to these initial values won't affect your current environment, or 
those of any running processes, as those environments are already 
set and can only be changed internally.

Using a path like that is not safe if you want to pop a function. 
It will call the function. To avoid that use either FIRST or PICK 
my-list 1

Strictly I would call wake-event buggy. But then popup-faces are 
usually not that complex. So its a 80/20, the complex faces are easier 
with words, the simple popups a bit  restricted.

I know of a way, but I wouldn't call it quick - override the engage 
func. for a field and take advantage of the 'parent-face var in the 
object... I'll start a quick example if you want to see it

Type "desktop" to start desktop.
WARNING: CALL function enabled in this version.
To see most recent beta changes, type: changes?
>> fun: func [/local i ][print i for i 1 10 1 [] print i ]
>> fun fun
none
none
none
none
>> stat
** Script Error: stat has no value
** Near: stat
>> stats
== 3769230
>> recycle
>> stats
== 2937954
>>

To call him for server performance during the holidays. That's dedication, 
isn't it?

No, that's why we call it Syllable Server

This year we made a big split. I created a Linux distro based on 
my build system for Syllable. We call it Syllable Server, and Syllable 
proper is now called Syllable Desktop

The new REBOL 2 Core is included, so the bug in CALL on Linux is 
fixed

#!/sbin/rebol  -qw
Rebol [
 file: %update.r

 purpose: {Update the system clock based upon the nist.gov time server}
 author: {Graham Chiu}
 date: 15-Apr-2007
]

get-nist-correction: func [/local nist-time cpu-time mjd hms] [
 nist-time: read daytime://time-a.nist.gov
 cpu-time: now

 parse/all nist-time [skip copy mjd 5 skip 2 thru " " copy hms 8 skip]
 nist-time: 17/Nov/1858 + to integer! mjd
 nist-time/time: to time! hms
 nist-correction: difference nist-time cpu-time
]

forever [
 if error? set/any 'err try [
 print [ "Current time was: " now ]
 current-time: now + get-nist-correction
 print [ "New time is: " current-time ]

 s: rejoin [ "date -s " {"} current-time/month "/" current-time/day 
 "/" current-time/year " " current-time/time {"} ]
 probe s
 call s 
 ][ probe mold disarm err ]
 wait 00:02:00 ;; wait 2 mins
]

Well, if you call a table of hundred lines a BBS :-)

Running on the same CPU architecture with the same machine instructions 
is also just that. Those machine instructions call system functions, 
so you need to provide those on the target system

should call it Que Sera server :)

call "uname -a"

The most annoying thing about the default configuration is that drag 
and drop works between some apps, but not others. Then it crashes 
the desktop. ROX will detect that and nicely restart, but you can't 
call it stable

The footprint is 10 megs. Without X, it's only 6 megs. They call 
that one MicroCore.

It's v. 0.9.0, and I didn't call it v. 1.0.0, because it needs some 
more testing, I think. It's GPL license.

Those 4 lines do this: load the assembler, load the emulator, call 
the asssembler with a 6502 asm program returning 64kb ram, and finally 
run the program.

This is just one single test using only a few of the available instructions. 
To have a better view, more tests are needed. I made a similar loop 
in C, compiled it with gcc, and it runs around 6 times faster than 
the pure rebcode version. Initially I won't call rebcode slow, but 
not blasting fast either.

example of a control function where it would be useful: control functions 
usually have to ignore non-local returns (rethrow them or whatever 
we call the behaviour), because they are meant for different purposes. 
If we want/need to use return in a control function, we have to use 
a specific (local) return to discern it from non-local returns

MAybe some hinting in the control-func? How about a 'catch which 
knows its function-name? and throw/to res 'func-name? Would still 
be short. Although if he have
 a -> b -> c 
and c return to a, 'b must call in that way too.

Well. Lisp has only maybe two control mechanisms, one is tail-recursion, 
and the second call-with-current-cotinuation (kind of goto but with 
the context stack maitain). You can build any other control mechanisme 
from loops to preemptive-threading with this two constructs.

Looks like it could be useful Henrik. I might call the refinement 
/part, to match other funcs. For the case of splitting a series into 
equal-sized pieces, or a fixed number of pieces, here's what I use:

I need the opposite too, and call them 'enblock and 'deblock.

(call it active icons :)

Gabriele - what will happen to ports? Carl mentioned e.g. mySQL will 
move away from kernel - will there be any other "component" (call 
it whatever) interface to "plug-in" functionality to rebol?

if gurus are silent, not blogging, then we have to help ourselves 
somehow - this one is from ML, someone communicated with Carl :-)


Just a thought, but I sent an email to Carl asking if REBOL 3.0 would
have an embeddable component to it. His reply was:



 Thank you for your message...

Yes. We call that embedded REBOL, 
 and that method will be supported by
our REBOL 3.0 product.

-REBOL 
 Support

the repeat version, as this is what I would expect and call intuitive 
... the word 'i gets bound to the block and is always being reset 
- so an infinite loop 


so 'for seams to not care or at least keeps the state of 'i for it's 
own purposes - how should a user know this, even though some assignment 
like this might flag in most cases a programming error (and in the 
other case in a for loop one can't manipulate the state of 'i explicitely)

Jaime, I think my second version of conjoin performs much better 
with non-empty input blocks. :)  I don't see how my inlined code 
can be slower than your function call overhead, except for very short 
input data.

Right, otherwise you are adding a comparison nd a path decode to 
every conjoin/reduce call.

APPLY would take refinements as positional arguments. That meant 
you would need to match the order of refinements in the declaration 
of the function you are calling, and that your function call would 
break if the function changed the order of its arguments - fragile. 
For some reason APPLY was slow too, and would crash REBOL if run 
too many times in a rebcode function.

function call would break if the function changed the order of its 
arguments - fragile
 I am afraid, that it is hard to find a less fragile spec, though

I will agree that varargs is not the most needed for me the two that 
rank above the rest is that all functions are closures, second tail 
call optimization, and finally continuations.

I like your idea about GET. Your idea about APPLY sounds nice in 
theory, but in practice it would add a block allocation to almost 
every call of what should be a low-level, efficient native function.

Your idea about APPLY sounds nice in theory, but in practice it would 
add a block allocation to almost every call of what should be a low-level, 
efficient native function.

 - I am not sure I understand what you have in mind - do you mean 
 you didn't like APPLY :f GET [...] ?

APPLY usage discussion continuing


It is interesting, that BrianH thinks, that almost every call of 
APPLY will obtain a block of variables needing to be examined.

My envisioned usage is, that APPLY obtains a block of values sent 
e.g. from the Internet, where it does not make sense to sent a block 
of variables unless the variables are meant to be the arguments.

As for triggering errors, I would prefer that argument type mismatches 
to APPLY would generate the exact same errors that a direct call 
to the function would generate - that way you wouldn't have to document 
2 sets of errors.

Izkata: you cannot call it "by reference", since you are actually 
passing the value you are manipulating - the word, not a reference 
to it

Okay, what then if INC/DEC are introduced in the language in a way, 
so they work more like we're used to with e.g. NEGATE, but at the 
same time allow, that variables can be changed? We have to use call-by-word 
(the REBOL way of call-by-reference) to have the variables changed. 
Like this:

>> a: 4
>> inc a
== 5
>> a
== 4
>> inc 'a
== 5
>> a
== 5


So INC has to check, if it's called with a word, and then get it's 
value before adding one, and in the end do a set-word. We could have 
the same with NEGATE and other functions (actions) of the same kind:

>> negate a
== -5
>> a
== 5
>> negate 'a
== -5
>> a
== -5

Does that make sense? And is it REBOLish?

Yes, side-effects can be confusing (often are). But INC is maybe 
a special case. Normally when we call a function with a word holding 
an integer, we don't expect the value of the word (our variable) 
to change.

>> a: 4
>> negate a

doesn't change a. So should "inc a" change a?

Ladislav, I prefer the latter, but that's because I'm used to REBOL 
evaluation semantics and like metaprogramming. If you are incrementing 
a word returned from a function, other than in the most common case 
of the IN function for path access already covered by the code, you 
have to put the call to the function in a paren for it to evaluate 
properly. The latter functions will at least always behave the way 
you would expect REBOL to behave - no magic evaluation, pass-by-name 
for side effects, etc.


I think the lit-word argument form is a little awkward for anything 
other than interactive use, like HELP and SOURCE.

I still think that these need to be native or they will be useless, 
even if they follow the semantics of the latter set of functions. 
There's no point to these functions unless they are more efficient 
than the code they would be replacing, and that code is just a couple 
evals, a native/action/operator call and an assign. Even native, 
you can't expect the functions to be less than half of the overhead 
of the phrase they'll be replacing.

Sorry, I just realized that was a confusing answer (to anyone other 
than Ladislav :). To clarify:


By call-by-name, I meant passing a word or path value to the function, 
rather than passing the value it refers to. If you have 'a formal 
arguments then call-by-name is implicit - if you have regular formal 
arguments then you must explicitly express call-by-name by writing 
the 'a as the actual argument, at the time of the call.


When I was talking about having to put function calls in parens, 
I meant any function calls or expressions that return the values 
that would then be passed to the INC/DEC function in their first 
argument. The first version of the functions, with the 'a argument, 
would need to put any word or path generating expression in parentheses 
for it to work properly. The second version of the functions would 
not require such a hack - you could use normal REBOL evaluation patterns.


One of the normal REBOL evaluation patterns is that call-by-name 
is explicit for all functions, except interactive functions used 
for documentation like HELP and SOURCE. This is why I prefer the 
latter functions above, the ones with normal formal arguments: Their 
behavior is more REBOL-like.

The speed of datatypes comes from the fixed action list. It allows 
the dispatch to be a simple retrieval from a fixed offset into a 
function table, no lookup required. It is not the same thing as general 
class-based methods, which in a language with dynamically typed variables 
would need to do a lookup to figure out where to find the method 
to call, same as with instance-based methods.

I look at this problem from two views.  wanting a forth style block 
editor and wanting to let a construction boss sit at home and edit 
his own data blocks.  The forth style CLI just needs strings...any 
string including something like  p [   putting an open bracket on 
a line by itself.  This can be done with string parsing and a dialect 
pass, but hey.  The other issue is a lot deeper.  I want the boss 
to type in $1,000,000 and not have to call me when load kakks and 
(when I'm not careful enough) breaking a script.

so an rsp script cannot call another rsp script within its links 
for images, for example?

might still be much faster than a db call.  but the real game-changing 
aspect of mod-remark is that a document in ram, will only render 
parts of itself which are changed, or which cannot be cached, so, 
unless you've actually changed a parameter, it knows that it hasn't 
changed and will not need to ask for the broker to give it back the 
value.  in fact, it wont even process that part of the page, only 
using the data in its local node cache directly.

the larger the func, the less hit, you can see that each function 
call is taking more time to initialise because of the return.

Doc asked "Third party tools can be used to tunnel SSL, like stunnel 
or nginx. About RSP, does Cheyenne's RSP miss some features required 
by Qtask?"

Maarten might be best to answer this.


BrianH wrote ""because they use PHP I'm guessing" - the promotional 
web site uses some PHP, but the main site is all REBOL."


I want to rephrase this, to help make it clear.  Qtask is written 
100% in REBOL.  We call this the "service".  The website on the other 
hand (which has nothign to do with the service), uses PHP, becuase 
there are many tools that the Webmaster wanted to use in PHP.

I sometimes use the following safe construct to avoid reloading some 
longer code on each RSP script call : 
<%
	if not value? 'my-object [
		my-object: context [

   ;--loaded on each new worker process only once, then available in 
   global context
			...
		]
	]
%>