World: r3wp

About instructions being 256 bit, half can be used to hold constants 
of the types:

- complex! : 2 double
- range! : 2 64-bit int (also pair! in the future)
- tuple! : 14 bytes + length (could be 15 bytes)
- date! : 128-bit in all


The rest is used for opcode, type of constant and a register offset. 
I put a 32-bit filler in, when going from 32- to 64-bit to reach 
a 64-bit boundary. So it should be possible to go down to 192-bit 
instructions without loosing functionality. To reach 128-bit instructions, 
the above constants needs to be spread over two instructions, which 
will hit performance. But it's important to notice, there is room 
for improvements here.


It hasn't been important for me to uptimize in this area yet, so 
that's why it is like this for now, but that time will come.

On the other hand, on a 64-bit system with 64-bit pointers, compiler 
optimisation of code such as:

	0 GET_TVALUE	0		10031dff0
	0 GET_TVALUE	1		100150fa0
	0 ADD			0		0		1
	0 SET_TVALUE	10016f6f0	0


will require 192 bit just for the 3 pointers, which will mean 256-bit 
instructions (with opcode), if the code can be optimized into 1 instruction. 
Optimizing four 128 bit inst into one 256 bit inst will halve the 
memory required. I haven't dug enough into optimisation in World 
to say, if it's possible.

The above VM asm is produced by code such as:
	a: b + c

World should accept REBOL [] as header to run R2, R3 scripts through 
it without editing these.


World can already run scripts without header, so it's possible to 
run REBOL scripts without editing them by first defining REBOL as:

	REBOL: none

or something similar.

You can write this and it will work in R2 and R3, because the stuff 
before the header will be ignored:

world []
rebol: none
rebol []

I wish you luck with World. It may be a bit difficult for me to use 
it though, because of the ASCII strings. Any language that isn't 
built from scratch with Unicode strings, instead having them retrofitted 
later when the inevitible need to support users outside the the English-speaking 
world, will have a great deal of problems. Python 3 is just the latest 
example of the problems with not having a well-thought-through Unicode 
string model. One of the best parts of R3 is how well we handled 
the Unicode transition.

I even have difficulty using R2 now because of how it can't really 
support nvarchar columns accessed through ODBC, a daily problem for 
me.

Any language that can do aliasing between the string and binary types, 
rather than requiring conversion, won't work.

Fortunately, it's not too late to fix this in World :)

My view is, implementing unicode everywhere will add to unnecesssary 
complexity. Each such level of complexity is a sure step to downfall. 
My first rule of development is simplicity, then performance, then 
low footprint, then maybe features.


Words in World can hold 7-bit ASCII. Chars and strings can hold 8-bit 
characters. That's the level of simplicity, I aim at.


I will have to deal with unicode, of course, and I'll do that, when 
World is a bit more mature. There could be a unicode! datatype.

A word about license, since that has been brought up in different 
groups. The current license for World is simple:


Alpha release. For testing only. Use at your own risk. Do not distribute.


There is a LICENSE function to show that. World is currently an alpha 
version for testing. When World moves to beta stage, I have to figure 
out a proper license. (I think, that's in the Q&A too.)

New release at https://github.com/Geomol/World

- Added /reset to COMPILE
- Implemented error system. Error system include:
	system/standard/error
	system/standard/errors
	system/state/last-error
	Better error reporting
- Added sys-utils/print-last-error

Uploaded new version with quick fix, in case someone downloaded latest 
release.

New blog "One week of open alpha" at http://world-lang.org

There is a lot of interest from people from France in REBOL-like 
languages, it seems. The month stats for world-lang.org shows most 
visitor from France, closely followed by Denmark and United States. 
Then Germany, Switzerland, UK, Czech Rep., Japan, Canada and Malaysia.


I should say, that I informed my SAS friend from France about this, 
so he could have spread the word too.

And 5 visitors from Brazil today. The Lua guys maybe? :)

Just tell when you want to be noted on OSNews, there might be some 
more significant traffic :-)

John;  I want in.  Do you need assistance writing docs?  Please. 
 :)


See http://my.opera.com/btiffin/blog/2011/12/09/rave-post-world-programming-language

That's cool, Brian! :)

A note about KWATZ!, you suggest it to be text!, but it's not quite. 
It sure can be e.g. UTF-8 data:


(Setting my Terminal program to character encoding Unicode (UTF-8) 
and trying to load 3 ASCII letters, 3 danish letters and 3 greek 
letters)

w> load "abc ?????? ??????"
== [abc #{C3A6C3B8C3A5} #{CEB1CEB2CEB3}]


(Notice World isn't prepared to unicode yet, but can load it, as 
it can just be seen as bytes.)


But beside text, KWATZ! can also handle all other data, like escape 
codes or any binary format maybe combined with more understandable 
data, you wanna load.

On the word KWATZ!, someone found a couple of good links:

http://seedsforsanctuary.blogspot.com/2008/06/kwatz.html
http://www.livingworkshop.net/kwatz.html


I first heard the word in a dialogue between an AI and a poet in 
a very good book by Dan Simmons.
[KWATZ!]

About writing docs, I've started the dictionary.

See: https://github.com/Geomol/World/wiki

Also "Difference from REBOL" has almost nothing yet. I mostly code 
and not writing docs at this point.

re: automatic closing of brackets

sqlab, I added it to issues at
https://github.com/Geomol/World/issues
so it isn't forgotten.

maybe you can add an easy switch just by one key code to switch between 
 a line mode

ahh, yes, thanks

Maybe a control char?

Like ctrl-a

that's good

What if World is used through a telnet on a server? Ctrl-A is SOH 
(Start of Heading). Could that give problems?

sorry, I had to switch to an other pc,  where Altme is already well 
configured.
Good was meant for a control char.
Why not make the key, that changes the mode configurable?

Yes, an idea.

another issue
the current  world_win exits after  errors

Did you get cortex.w too?

seems to be my fault.(

Geomol; by text!  I was referring to the old junk! argument.  It's 
not really junk!, it's human text, encoded as humans see fit, gibberish 
or deep meaning symbolic.  Naming things is hard.  ;)   KWATZ! is 
ok...but I don't get the 'ahhh, that's optimal in meaning and depth' 
from it - and I lean Buddhist and did see the Zen references. But 
kwatz is still sinking in, if it's going to (and perhaps that is 
the best kind of deep meaning).

And if you don't mind, I may start poking around in your wiki as 
btiffin on GitHub.  Feel free to tear any writings apart.


I'll admit to having some deeply ingrained misunderstandings about 
REBOL, so those will likely slip right on over to World.    (I've 
got notes from Ladislav, Gabriele and a few others that pointed out 
these misunderstandings (and when documenting, misunderstandings 
are simply untruths and need to be treated that way)).  In particular, 
I still don't see clearly the 'value - premake - type - make (and) 
word' semantics of REBOL (at least in terms of trying to explain 
it)  I'm hoping your World engine code is let out so I get a chance 
to view my problem from a different angle and hopefully 'see the 
light'.


I'll add that if you want to send any snippets for markup in LaTeX, 
I'll sign up for grunt work too.

Ok, dug in a little.  But still reading back matter...

Regarding cortex.w - is that in the far-plan?  Mezzanines ship with 
the binary instead of in?  Should it be documented that way?

It's not really junk!, it's human text, encoded as humans see fit, 
gibberish or deep meaning symbolic.

Funny, when I first implemented KWATZ!, I called it gibberish!, but 
I found KWATZ! better suited and more interesting. And it kinda give 
you the same feeling, as when you see a computer go down with a "Guru 
Meditation". :)


And if you don't mind, I may start poking around in your wiki as 
btiffin on GitHub. Feel free to tear any writings apart.

The idea with the wiki is, that it's for everybody to edit, so it's 
not really "mine". And as I have very little time for documentation 
right now, I will only contribute a little. It may be needed to step 
in at some point and clear things up, make different pages consistent 
with each other etc., and that may be me, who does that, but it could 
be somebody else too. For the dictionary, it may be an idea to write 
a script, which does most of the documentation (I think, there's 
an old REBOL script for that lying around somewhere, which may be 
suited with some modification). system/words may be needed to do 
that properly, and that's not in World yet. I produce LaTeX output 
with my NicomDoc format, so I'm covered there with the documentation, 
I'll do (a proper manual).

Regarding cortex.w - is that in the far-plan?

Yes, the binary will be as basic as possible. I even consider removing 
definitions of natives from the binary, as it's possible to define 
them in cortex.w. Same could be done with datatypes with a little 
change to World. Then the binary could only define MAKE and DATATYPE! 
(and probably also SYSTEM), and the rest could be build from that. 
It's a good idea to split the doc up in a native section and a mezzanine 
section. And then there's rebol.w, which will make it possible to 
run even more REBOL scripts. There could be a dictionary for that 
too.

Btw. in World, natives are being called functions too (it's easier 
for the user to understand, I think). You can distinguish them with 
PICK, as the second item is an integer. Examples:

w> type? pick :add 2
== integer!			; so ADD is a native function
w> type? pick :loop 2
== block!			; so LOOP is a mezzanine function

If LOOP becomes a native, we can just move it in the dictionary. 
I try to create as few natives as possible to keep World simple, 
but my need for good performance too might lead to a few mezzanines 
becoming natives.

World is awesome John, I'm in.

+

Don't use the old R2-style reflectors, like that pick 2 in your example 
above. Any support at all for that kind of reflection makes it harder 
to secure code. Use the R3-style reflectors.

+1 Brian, though we can write mezz wrappers using the PICK interface. 
Is there a reason they need to be native?

The important thing is to *not* use PICK for this, to use a different 
function instead. If you use PICK, it will make it more difficult 
for PICK to be useful in secure code that should have limited or 
no access to the reflectors. It slows down PICK too. That is why 
R3 uses REFLECT instead.

I'm pretty sure, it doesn't slow down PICK, but I need to make test 
to be absolutely sure.

R3 uses mezz wrappers around REFLECT, so mezz wrappers aren't the 
problem. The problem is having it be possible to use PICK for reflection. 
Consider what would be invloved in turning off reflection but keeping 
PICK working for non-reflection uses.

Or we could consider a more practical situation directly related 
to World: If you can compile blocks, it would make sense to use the 
reflection facilities to get access to metadata about the compiled 
blocks (especially since that would be something that you might want 
to secure, or since functions would need similar reflectors), but 
PICK already has a defined meaning for blocks.