World: r3wp

Hmm, it seems that while (basic) compile/at with functions works 
fine, it doesn't work for blocks:
w> x: 1
== 1
w> do [x]
== 1
w> do compile/at c: [y] context [y: 99]
== [y]
w> compiled? c
== true
== 1

Yeah, many things are not finished in an alpha release.

Ok, understood.

Ey, DISASM unfortunately seems to stop at the first RETURN insn encountered 
instead of disassembling the complete bytecode :)

(Seems it indeed does, but it doesn't hurt much. Nested RETURNs are 
in different compiled blocks anway, so ...)

Code is compiled in two ways.


1) Code is being compiled to the VM, when it's being run. So if I 
define and run this function:

w> f: does [return 1 return 2]
w> f
== 1

only the first RETURN statement is being compiled.


2) If I instead compiled the functions, both statements are being 
compiled, e.g.:

w> compile :f


will compile both RETURN statements, but this has no impact, when 
running the function (of cource), and DISASM just stops, when it 
sees a RETURN.

Functions can also be in a parthly compiled state:

w> f: func [v][if v [return 42] print "Hello!"]
w> f true
== 42
w> disasm :f

...	(just part of the function is seen ending with an END_EXECUTE)
w> f false
Hello!
w> disasm :f
...	(the full function is seen ending with a RETURN)

*partly*

Q: Does binding work similarly to REBOL? I mean can World support 
current advanced REBOL block binding/building for generating code 
like Parse compilers or such oddities like this:
>> reduce [word word word]
== [1 2 3]


A: No, binding works differently in World. In World, each block is 
bound (points to a context).

btw - if World is supposed to be about dialect, I would rename it 
to simply a Word :-) You acronym still would make sense ....

Rename World to Word? You must be kiddin'! :) Gives some unwanted 
association.

Terry would explain to you, that in the beginning, there was a God, 
and right after him, there was a Word - the first dialect of our 
cosmos :-)

I don't understand the "unwanted association", but never mind - it 
is just me, that "World" has some obstacles when I tried to pronounce 
or write it, simply the letter "l" :-)

Try Google "Word".

Try Google "World" :-) Anyway - that's not important, it just came 
to my mind ...

Can you comment on what World is doing when fed incorrect arguments? 
In these two cases below, both R2 and R3 throw an error....
       w> 1-jan-2011 xor 1-jan-2012
       == false
       w> 1-jan-2011 and 1-jan-2012
       == true

It relates to the true/false value of different values. Using IF, 
only logic false and none will fail the IF. All other values will 
fulfill the IF. I have brought this idea to AND, OR, XOR etc. So 
because you can write:

w> if 1-jan-2011 [true]
== true

you can also write

w> 1-jan-2011 and 1-jan-2012
== true

Okay.....Yet is is confusing that bad args are caught in some cases 
but not in others:
       w> 1-jan-2012 xor 555
       == false
       w> 1-jan-2012 xor 5x5
       Valid pair: 5x5
       ** Error: xor is missing one or more arguments
       ** Near: 1-jan-2012 xor 5x5

That's because pair! isn't implemented. It's just prepared for in 
the lexer, and that's why you see the text "Valid pair: 5x5". Only 
the datatypes listed in the cortex_alpha.pdf doc enters the World 
engine, and pair! isn't among them ... yet.

In other words, the pair! is ignored at this time.

Maybe I should tell a bit, how I work, to make it easier for you 
to understand, what you've got for now. I do much of assembly line 
programming, because it reduces the time of development. So when 
I wrote the lexer, I didn't just implement e.g. numbers, because 
arithmetics would be the first functionality, I would finish. I implemented 
all 40-50 datatypes, I wanted in World, in the lexer at the same 
time. So the lexer is prepared for more datatypes, than what actually 
works for now, and you will just see "Valid <something>" from the 
lexer, when it recognizes such a type.

Like:

w> 1x2 [bob-:-server-:-com]
Valid pair: 1x2
Valid email: [bob-:-server-:-com]


Btw. date! and time! isn't well implemented for now, and I'll put 
that in the next update to README.

(Actually the lexer might just recognize around 30 datatypes, because 
some types need to be created with MAKE.)

Why does world open a listening socket at port 8080?

World seems to be fussy about which directory it is launched from


Is there a way to figure out, what directory a command launches from, 
which will work across platforms? I could check argv[0] in main(int 
argc, char **argv) , but that wouldn't work, if world is put in a 
bin, which is part of $PATH.

sqlab, it does by defaul?

*default

Sorry. it opened a listening socket at port 0.

What do you do to see that on your system? What os?

At first start on Win XP. I got a warning from the firewall.
After I checked with process explorer

Ok, under Windows, I found, I had to initialize the networking, so 
that's done at startup. (This isn't necessary under OS X and Linux.) 
You can see the code being executed in the function init_net () in 
the file src/host/win32/network.c. If you think, it should be done 
otherwise, let me know.

The file is found at
https://github.com/Geomol/World
if that wasn't clear.

Does R3 (or R2) also cause your firewall to give a warning?

Topic: Routines

I suggest expanding the make routine! spec to the following:

	routine-name: make routine! [
		"routine description"
		[special attributes]
		library
		"routine-name"
		[
			argument1 [arg1-world-type] arg1-type
			"argument description"
			argument2 [arg2-world-type] arg2-type
			"argument description"
			...
		]
		return-type return-world-type
	]


, where the following fields are optional: Routine description (string!), 
Special attributes (block!), Argument name (word!) and Argument description 
(string!).


Then good documentation can be made with HELP. Argument names are 
not really needed, as routines are compiled code in a library, but 
names can make the docs easier to understand.

seems to be fine... what about the return-world-type as optional?

And then it should try to guess it from the return-type?

yes

Ok, makes sense.

and maybe to make same order like for args.

Actually I had it like that at first, but I found the reverse order 
to be easier to understand. (It can be just me.) Because then I read 
a simple routine spec as: routine is in library, named "routine-name", 
take argument with world type arg1-world-type, which is converted 
to arg1-type, returns return-type, which is converted to return-world-type. 
The sequence makes good sense to me.

And [arg1-world-type] is in a block, so I can allow more than one 
type in the future.

(if typechecking is preferred)

If routine takes no arguments, the argument block could even be optional. 
Today an empty block is needed.

I do not remember clear, if all versions of R2 or R3 gave warnings 
at first start, but now they are in my exception list. And at least 
once I got suspicious of R2 too, as it initialized / loaded libraries 
not needed.


The curious thing is, that now I do not get a warning at start of 
world again. And I did not allow it, but choosed "ask again".

I guess you will get it once you type TEST end enter.

right

Is there a way to figure out, what directory a command launches from, 
which will work across platforms?

Yes and no. There are platform-specific ways. This gist of it:

- Linux: readlink("/proc/self/exe")
- OSX: _NSGetExecutablePath
- Win32: GetModuleFileNameW

(We recently discussed this issue in relation to R3 as well.)

Topic: system/version/platform

To check for which platform, World is running on, system/version/platform 
can today be:

	"Mac OS X"
	"Linux"
	"Win32"


Is that suitable? Are there better suggestions? Is there a standard 
for this?