World: r3wp

May be using either Github issues or wiki

Nenad uses Github issues for bug and feature request tracking for 
Red though perhaps the wiki would be better for a List of REBOL incompatabilities?

(Which I can't spell !!!)

I'll create a wiki.

Can you see the wiki: https://github.com/Geomol/World/wiki
Can you add to it/edit page?

Yes, I can

Cool! As I add features, functions, refinements, that wiki has to 
be kept up to date to be really useful. I don't have time to do it 
all myself.

You should add link to the world page into the readme file.

done

Peter, the directory launch problem, you see, is because it can't 
find and run cortex.w . I'll fix this. You can run it manually though 
with: do %<directory>/cortex.w

Thanks, John

the automatic closing of open brackets may be handy when typing, 
but it gets in the way copying from the clipboard

Maybe if it could be turned off?

Pekr: "why it is so "big", as it mostly compares to /Core? :-)"


world's linux binary is already smaller than rebol/core 2.7.8 for 
linux. (not that it matters, though :)

re bug tracker: i think we can just use github's issue tracker [1] 
to _record_ issues we find, for now. so just so that there's a single 
place to collect them.

[1] https://github.com/Geomol/World/issues

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.