AltME groups: search

One thing worries me. AltME hasn't change much in the last two years. 
I haven't add anything beyond its basic functionality, however two 
major bugs have persited during this time:
- Recycle bug
- Losing postings

IIRC Doc did not planned to be 100% compatible either. IIRC he wanted 
to introduce two layers to networking. It comes from his experience 
when working with networking (Uniserve etc.). I think that redesign 
is the right time for language to correct/improve some of concepts. 
I expect REBOL 3.0 to go that route. 2.0 was rewrite too.

and you can always use your old 2.x SDK to improve on your apps .... 
having time to redesign for new branch (3.0)

Basics ops benchmark, measured using Ladislav time-blk tools, results 
in seconds:

;REBOL
;getword  0.08612
;setword  0.2006635
;funccall  0.194279125
;make-object  1.750536

;ORCA
;getword  0.072630
;setword  0.133684
;funccall  0.177569
;make-object  0.917472

I'll have to try to carve out a bunch of time. I've never compiled 
anything on my Z. Sounds like fun though.

We can't let you in right now


The limit of people who can chat in this account has been reached. 
As people come and go slots may open up.

You can try again at any time.

It's not webcentric, as Reichart is at pains to explain so often. 
:)  but that's what we get to look at most of the time at the moment.

I rather spend time coding Orca than coding tools. IRC is fine for 
chatting.

I just don't see the use of being compatible. I actually see it like 
a wast of time. 100% compatibility means importing the gotchas, the 
bugs, and the problems in certain designs. Like the port system.

All good points, and I respected your points from the start.  The 
other side is true as well, and not actually in conflict with your 
goals, just your time, which is what is most valuable.

R2 is not dead. I am still using it ! It will be very useful for 
some time to come. It will take a long while for R3 to stabilise 
to the point at which R2 is now.

Actually, that's another issue:  Do we make a separate fork for R3, 
(considering it may not stabilise for some time.) ?

thanks - i think this is a really good idea, should of happened a 
long time ago

I'll start doing some things on the project site in the future, but 
I've got a lot of other stuff going on, so it will take some time 
until I get to it

I think not, not for a long time ...

This eats memory and startup and teardown time

so once we have the host and Carl realized that he'd waste less time 
giving us a bit more control, there is a chance for a bit more core->host 
migration still.

Nice!

Boron

)> t: now loop 10000000 [a: div mul sub add 11 2 3 4 5] print ["time:" 
sub now t]
time: 0:00:04.797

R2

>> t: now/precise loop 10000000 [a: divide multiply subtract add 
11 2 3 4 5] print ["time:" difference  now/precise t]
time: 0:00:07.594

R3

>> t: now/precise loop 10000000 [a: divide multiply subtract add 
11 2 3 4 5] print ["time:" difference  now/precise t]
time: 0:00:07.563

I'm sure there would be an an enormous learning curve for me, but 
I'm really tempted to spend some time digging into this source...

I want to try to compile ORCA for Windows too - I tried briefly once 
in the past, but ran into problems and didn't have time to play with 
it.

Kaj, thanks for noting that standard input example - it is new.  
In June, Boron's user manual version was 0.1.2 and the windows release 
was 0.1.4.  It's really encouraging to see work accomplished :)  
I donated a small amount back in June to Karl using the paypal link 
- if he's motivated by money to do more work, I'd support that without 
reservation.  I don't have much time right now to explore much, but 
I'd love to see a continuing active open source alternative.

I guess you're correct;  Red/System is not generally good enough 
to wrap "any and all" C libraries yet.


What is most important to me about Red/System at this time is that 
it needs to be good enough to allow Red to be developed. I believe 
the addition of partial float support to Red/System was not absolutely 
essential for the development of Red though I'm sure it will help. 


There are lots of other improvements that could and will eventually 
be made to Red/System but they don't seem as important as work on 
Red ... at least to me.

What your binding still does differently than the C code is that 
the C code loads the functions dynamically, while Red #import embeds 
loader symbols in the executable format. I think GetProcAddress is 
the standard Windows function to load symbols manually at run time

I think I understand what you think, but I got lost in translation 
:-) I will have to think about it few times and try to do some experiments.Thank 
for putting some time into the topic ...

If they're not in the list, that would explain why they don't work, 
because the manual loading is needed to pull them in at run time

All in all, if it's possible to load the functions manually, it should 
also be possible to import them at load time with the regular #import 
method. So something else may be wrong in the binding

The Red/System situation is certainly not worse: it's the other way 
around. You can program manual loading with just a few well defined 
functions, the same that R2 and World use. But normally, you use 
automatic loading by the operating system, which is the standard 
and most efficient way to do it, and which R2 and World can't use 
because they execute bindings at run time

Haha. So you advicate a sShort time progress with Eternal

Sorry. So you advocate a short time progress with Eternal regress 
and pain of recompiling included files and unavailability of metaprogramming 
possibility? No-preprocessor languages can easily be analysed metaprogrammatically 
and transformed, and preprocessor languages cannot (almost).

It does :-) It does not print newline by default, although it will 
be 90% time of requested feature. Just because the compatibility 
to C, Doc introduced print-line, which will be equivalent to ??. 
So 90% of your time your code is going to be ridden with print-line 
or ??, becaue we don't like 'prin ...

I.e. after each #define and after it the #include, we would need 
to recompile the included file. That's enourmous lossage of time 
and resources.

Pekr: (short answer) Red/System (and Red) generate executable binaries 
while R2/R3, while World and all other interpreted languages just 
run code in an interpreter or VM. This is a big difference, because 
Red can use the OS to load libraries at "load-time" instead of having 
to write code to do it (as all others interpreted languages require). 
This is also faster than loading manually. Red/System doesn't have 
yet a x-platform extension for adding "run-time" library loading 
support, just because we don't need it at all for now, but it can 
be added easily, by wrapping libFFI for example, or implementing 
it purely in Red/System.

OK, so if I understand it correctly, Red/System loads the library 
at an executable load time, whereas load/library does so dynamically 
in the app run-time. Stil - I wonder, if we could get a handle to 
such a library? I mean, syntactically #import is just like preprocessor 
construct - you can't assign it to any variable. Not sure it would 
be usefull, to be able to retrieve a handle to such wrapped library 
plus handles (entry points) to wrapped function calls?

Evgeniy: (short answer)


1) IIRC, there's no recompilation of included files in Red/System, 
the only overhead is parsing the preprocessor directives and reducing 
them. I agree that the whole compilation process would be significantly 
faster without a preprocessor, but that's another topic.


2) Preprocessor is a handy addition for compiled languages, that's 
why it was introduced in Red/System, not because it was a planned 
feature, but just because we _needed_ it for going further. The distinctive 
# prefix is used to make it clear both for users and the compiler 
that these parts are reduced at "compile-time" instead of "run-time" 
and avoid confusing both users and the compiler. For example, from 
your examples, the compiler has no way to distinguish a "compile-time" 
IF from a "run-time" IF, unless you make it a lot slower by doing 
static analysis and complex inference (the cost would be huge compared 
to the preprocessor). Also, this might also introduce a lot of new 
restrictions in the language semantics, which is not desirable.


3) IMPORT is better than INCLUDE: you might have missed it, but we 
can't yet generate libraries, so importing Red/System code now is 
not an option.

Pekr: you've mixed up completly "load-time" and "run-time" library 
loading. You don't need a library handle at "load-time" (unless you 
want to hack something in the OS). Also, you don't need any of your 
code above, just the #import declaration with the right function 
names (finding the right names seems to be the most complex part 
in the case of the library with the weird API you're using)

As for compilation time. I don't know guys, but Red/System compiles 
REALLY fast. I do remember my dos times, where compiling took 30 
secs. Where's the problem? It's not imo about the compilation speed, 
at least for me - it is about the process of building app vs dynamic 
prototyping using interpreter. I don't like much the compile/build/run 
process, but I expect something like R2 console for prototyping appear 
in distant future for Red ....

Compilation time: absolute speed is not the issue currently, we're 
talking about relative speed of the preprocessing compared to whole 
compilation time.

It is a pity that my first attempt has some such problems. Just don't 
loose the time with it, if you have more important stuff to do. Kaj 
tried to do his best here, ditto Andreas.

I've seen that before during development, but it had been fixed for 
quite some time. It must be generated during cleanup

I'll search deeper tomorrow, sleep time now. I'll postpone the 0.2.4 
release until I get a clearer view on this issue.

which could be problem in a big source.
...prevent passing...
 catch in compile time would be nice for sure.

I don't have time to check it now more deeply... maybe in the evening.

I got that error too. I thought it is related to my weak attempts 
to wrap my led library (which still can be the case), as I saw the 
error for the first time yesterday ...

The runtime errors that I got were correct - in the sense that the 
compiler and run-time acted correctly.

http://en.allexperts.com/q/C-1040/time-milliseconds-Windows.htm

But stupid Windows measures wall-clock time instead of processor 
time

Syllable Server, AMD Athlon XP 1800+ (256 KB L2 cache)
				CPU Time		Relative
C (GCC -O3)			.14			1
C (GCC 4.4.3 i686)		.24			2
Red/System			.26			2
Ruby 1.8.7.248 (i486)	29			200
Boron (i486)			31			200
REBOL 3 2.100.111.4.4	41			300
ORCA (i486)			50			350
REBOL 2 2.7.7		55			400
World				10:27:00 *		> 260,000
*: Aborted after this time.

We should make a new Google Hangout session tomorrow at 19:00 CEST. 
Guests are welcome to ask questions about Red & Topaz. I am waiting 
for Gabriele to confirm the meeting date/time.

Chat closed now. We were four peoples online this time (even 5 during 
a minute with Reichart coming to say hello).

I was out of time to prepare some Red/System demos to show, maybe 
next time.

James: I can schedule around almost any time as long as I know in 
advance.


Henrik: yes, however, knowing which times / days of week are best 
for most people would help. :)

Gabriele, yes, however my theory is that if you pick a time (one 
that is friendly to people on both sides of the planet), people will 
eventually start showing up, if you are consistently using that date.

if time is ok for me count me in.

i'll check back in a bit in case someone else is around. in any case, 
it was a great talk. i guess we can repeat this next month or so 
- my afternoon seems to be the best time. too bad Peter didn't get 
to meet everyone else. :)

Looks like I'll have to stay up until 3:30 in the morning next time 
:-)

Peter, you may try to convince the others to show up earlier instead. 
;)


Endo: it was very informal, so it's hard to write a written summary 
or anything like that... though, Hangouts with extra has a note thing, 
next time we can try to use that. In any case, if you have a preferred 
date / time for next month, we can try to be there.

Janko, there are two cases here:

1) debugging the interpreter itself

2) debugging your own code (for eg. a web app written in Topaz)


I think that (2) is what interests you - in that case, you use the 
interpreter during development, so it's just the same as debugging 
in REBOL (well, I hope to provide a few more tools, but even without 
debugging REBOL code is not that difficult most of the time). Think 
of compilation as an optimization step, that you do only for production 
deployment etc. and only for some parts of your code (the parts where 
performance is important).

Not yet, there's no point at this time. But, there's no reason why 
it could not work. It should also be not that difficult to get it 
to work with Appcelerator Titanium.

It appears to be standard (it's the one in IE, so if you have IE9 
it is as standard as V8). However, it doesn't seem to have one of 
the objects or functions that Topaz's bootstrap depends on. Some 
time I'll try to do a proper port. In the meanwhile, Node just requires 
installing a package on Windows (at least as of the last couple months), 
so any Cygwin-related criticism can be ignored now :)

Hmm, reading some docs - there' s so many nice things about the R3, 
pity it is not open-sourced, or that Carl can't devote more time 
to its development ...

1.5 more Qs: how long has this been in the making in general & how 
much time have you spent programming it?

Q: Will this language be an open or closed source project?


A: Long answer: The plan is to fully open source it at some point, 
when version 1 is ready. Host depending sources are open in the alpha 
release, and it may make sense to open source more and more along 
the way, like sources for the different datatypes. The IT world is 
constantly changing. My nephew just went to the Devoxx Java conference 
in Belgium. Everybody had portable Mac computers. That was very different 
just a few years ago. Who knows, what devices we'll use in 5 years? 
I like to bring my software with me to new platforms. To be able 
to support new platforms faster, open source is a good thing. But 
some things needs to be fulfilled, before I'll open source it all.

1. This isn't a hobby project. I've invested a lot of time and work 
in this project, and I need to find a way to get something back from 
all that. One option is to have a good manual ready for developers 
to buy, open source it to get a lot of developers interested, and 
make a profit that way. There may be other ways (like someone or 
some company paying me to open source or make projects in World).

2. I need to know more about the consequences of open sourcing it, 
so I can avoid any nasty surprises. Knowing more from other similar 
projects could help. I need to figure out a proper license.

3. Even if I keep the sources simple and clean, I would like to clean 
up even more, before it can be open sourced.

A: Short answer: Currently it's partly open source.

Q: What is the main target?

A: The World prompt is a very powerful tool. Being what is known 
as "network transparent" helps in the era of the Internet. Server 
scripting and client scripting are obvious uses. The ability to easily 
make dialects makes it possible to wrap the language around the problem 
instead of trying to change the problem to fit the language. Interfacing 
with other technologies ... see "Introduction" on http://world-lang.org
in a few days.

Q: Is it closer to R2, R3, RED, Topaz architecture?

A: World run its code within a custom made virtual machine (VM). 
Compiling in World compiles World sources to this VM. This happen 
when source code is run or if explicitly compiled. REBOL is always 
interpreted (AFAIK), so that's different. I'm far from an expert 
in Red and Topaz, but as I understand it, Topaz is compiled/translated 
to JavaScript. So the JavaScript engine can be seen as the VM in 
World. And Red is compiled to native code, so that's different too. 
As I see it, all these languages work differently and can complement 
each other. (Help me here, if I'm wrong in any of this.)

Q: What was the main motivation, aka - why yet another language?

A: After I've learned REBOL, I find it frustrating to program in 
most (all) other languages. The difference is like when humans moved 
from carving words in stones to using a printing press a la Gutenberg. 
Then I found, I couldn't complete projects like my Canvas RPaint 
program on all major platforms (Win32, OS X and Linux), I couldn't 
run my code on new portable devices, and I needed better performance 
with scientific applications. With my background in graphics, music 
and science, I expect the language to develop into those areas.


Q: If (you) don't have any other target, why don't you work on Red? 
Or fork a project from Red?

A: I started initial work on World in late March 2009. The first 
post in the Red group here in AltME is from 27-Feb-2011. At that 
time, World was more than 7'000 lines of C.

Q: Does World compile into bytecodes (a la java) or machine languages?

A: Into bytecodes for the virtual machine. Each VM instruction is 
32 bytes (256 bits) including data and register pointers.

Q: Can you do operators with more or less than 2 arguments?

A: Not yet. I've considered post-fix operators (1 argument), and 
it shouldn't be too hard to implement. To motivate me, I would like 
to figure out some really good examples. With more arguments, I can 
only think of the ternary operator ("THE ternary operator"). I'm 
not sure, World needs that.

Q: Is range! a series! type?

A: No, range! is a component datatype. It has two components just 
like pair!.

Q: What platforms are supported?

A: For now Mac OS X (64 bit), Linux (32 bit) and Windows (Win32). 
The code is very portable. It took me a few hours to port to Linux 
from OS X and just a few days to Windows.

Q: What platforms do you plan to support in the future?

A: It would be cool to see World on all thinkable platforms. I personally 
don't have time to support all. World is not a hobby project, and 
I'm open for business opportunities to support other platforms. The 
host depending code is open source. I mainly think 64-bit.


Q: I'm a little sorry to see the R2-style port model instead of the 
R3 style. Are all ports direct at least?

A: Yes, ports are direct (no buffering). The ports and networking 
are some of the most recent implemented. More work is needed in this 
area. I would like to keep it simple and fast, yet flexible so we're 
all happy.


Q: What in the world is going on with the World Programming Language? 
This looks like something that must have been under wraps for a long 
time. What's getting released?

A: I didn't speak up about this, until I was sure, there were no 
show-stoppers. The open alpha of World/Cortex is being released as 
executables for Mac OS X, Linux and Windows (Win32), as are the platform 
dependent sources and initial documentation. World implement 74 natives 
and more than 40 datatypes. The Cortex extension (cortex.w) implement 
100 or so mezzanine functions and some definitions. The REBOL extension 
(or REBOL dialect in rebol.w) implement close to 50 mezzanine functions 
(not all functionality) and some definitions.

Q: Did you do some speed benchmark? (R3 vs R2 vc World) ?
A: Yes:

(All tests under OS X using R2 v. 2.7.7.2.5 and R3 v. 2.100.111.2.5)

- A mandelbrot routine (heavy calculations using complex! arithmetic) 
is 6-7 times faster in World than code doing the same without complex! 
in R2 and 11-12 times faster than R3. If using same code, it's 2.5 
times faster in World than R2 and 4.2 times faster than R3.
- A simple WHILE loop like:
n: 1000000 while [0 < n: n - 1] []

is 1.8 times faster in World than in R2 and 2.8 times faster than 
in R3.

- I tested networking in two ways. One sending one byte back and 
forth between client and server task 100'000 times using PICK to 
get it, and another sending 1k bytes back and forth 10'000 times 
using COPY/PART to get it from the port. Both were around 3 times 
faster in World than in R2. (I didn't test this in R3.)

- I tested calling "clock" and "tanh" routines in the libc library. 
I called those routines 1'000'000 times in a loop and subtracted 
the time of the same loop without calling. Calling "clock" is 2.4 
times faster in World than in R2. Calling "tanh" (with argument 1.0) 
is 5.9 times faster in World than in R2. (I didn't test this in R3.)


(Some functions are mezzanines in World, which are natives in REBOL, 
so they'll in most cases be slower in World.)

Q: We already know that your physics background influenced the new 
complex numbers datatype. Should we expect further progress of this 
kind (physics/science)?

A: After pointing this language out to a couple of friends from university, 
I was quickly asked to give scientific examples, like making a Lorentz 
attractor. There will come examples like that. Also I have some contacts 
at the Niels Bohr Institute (Copenhagen University), that I would 
like to show the language to and see, if we can create some projects.


Q: How long has this been in the making in general & how much time 
have you spent programming it?

A: I started R&D late March 2009. In March 2010, I had >7'000 lines 
of C. Then I took almost a year break from World and started up again 
Spring 2011. I have used much time on it this year (2011). So I've 
used 1-2 years effectively, I guess.


Q: Is there a way loading and interfacing pure object files, how 
about callbacks?

A: I don't have much experience in this area. Two of the closed alpha 
testers have looked at interfacing with sqlite3, which uses callbacks 
for some stuff. I would say, it doesn't work 100% yet, but it's being 
worked on. I need to see examples of loading and interfacing with 
pure object files to judge, how much of such functionality should 
be in World.


Q: Wouldn't it be useful to treat the kwatz! type same way as binary! 
so you don't need to always convert it? I mean, all functions that 
are able to take binary! arg should be able to use the kwatz! as 
well...or do you think are there any problems regarding that?

A: I've thought of that and came to the decision, that KWATZ! should 
be treated with some care. Are we always sure, we want to treat that 
data as binary? I need more experience using KWATZ! to judge that. 
Conversion could be fast, if the AS function was introduced, which 
should just change the type without copying.


Q: Is there a call-in interface available, meaning I can embed World 
in other programs?

A: Not yet. Internally I do call World functions from C (to parse 
URLs) by pushing arguments on the VM stack and call the execute_vm() 
C function. I imagine an interface much like in Lua (lua_call), but 
a little more work is needed, before we're there. This is an alpha 
release, so things will change/be added, before we move to beta release.


Q: Regarding your thesis I guess you have something like an integrated 
db or a special datatype for permanent storage too.. ?
A: Too early! :)

Q: What subset of REBOL2 will run without change in World?

A: Uh, ah, hard to tell at this point. When I need new functionality 
in World (because I want to run some of my R2 scripts), I consider, 
if it should be part of World/Cortex or if the new functions should 
go into the REBOL expansion/dialect (%rebol.w). I want World/Cortex 
to be small and compact. The idea with %rebol.w is, that much of 
R2 code could run, after this script has run.


Q: Are there datatype and function comparisons between World and 
REBOL2?

A: No, I haven't documented that ... yet. Maybe someone else wanna 
document that!? But there are differences, like the REBOL decimal!, 
which in World is called real!. And then %rebol.w just include the 
line:
decimal!: :real!
, so REBOL scripts using that will run.


Q: How many people were working on this World? :) Is it just a single 
man project?
A: Yes, just me.

Q: Will there be a GUI?

A: I would really need a GUI for my own work at some point. I have 
ideas, but nothing set in stone yet. And I want World to be open, 
so different GUIs should be possible, also the native GUIs in the 
different OS.


Q: Are you rich enough to buy Rebol Technologies and employ Carl? 
:-)
A: [KWATZ!]

When we tried something similar to the LOAD/on-kwatz trick in R3 
(named LOAD/on-error there) it turned out to slow down LOAD so much 
that it made it unusable - something about switching back and forth 
between native and interpreter execution schemes. The alternative 
of having a kwatz! type returned had the effect of changing a load-time 
check for syntax errors in the source code into a runtime check for 
invalid values, but only if you are expecting such things and testing 
for them explicitly. Under normal circumstances a kwatz-accepting 
loader would often result in code that would run slightly wrong but 
not trigger an error to help you figure out why. This is why you 
should make sure that your regular code loader triggers errors by 
default when it encounters unexpected syntax. An option to be more 
forgiving would be helpful when loading dialects that explicitly 
support particular kinds of extended syntax - and thus are expecting 
kwatz! - or for loading user data for analysis.

REBOL on the other side, interpret the REBOL source all the time, 
like every time the same function is called. In World, the function 
is compiled to VM code, the first time, it's called, after that the 
compiled code is just run (unless the source is compiled again).

single level Mark and Sweep GC?  or did you put a bit of time into 
making it a bit more powerful (multi-zone, multi-level, multi-threaded, 
etc.) ?

:) Look at the bottom of the %cortex.w file. You'll see the test 
function and the m function. I just include them for now, because 
I call those two scripts all the time.

It is quite a long time I last used it to get R3 sources ;-)

nooo too much work for me. :)


Well, for now I would not have time enough to deal with lots of bug 
reports. At a later time, when I'm mostly done coding on it, and 
have removed all the bugs, I already know about, and added missing 
features, bug reports are very welcome. But simple tests, like you 
see in the test/ dir is a good idea. I can handle a couple of falsed 
tests at a time now. So maybe that's a way.


What do you guys think is a good way? What way will get to the goal 
knowing I'm booked with things to do already.

And the defining rules for routines will most likely change, so don't 
use a lot of time making routines, unless you're ready to change 
your code later.

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.

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.

My first experience with LLVM.


I tried to compile World with llvm-g++ under OS X. When compiling 
with gcc, I normally use -O2 option. I compared performance with 
the Mandelbrot test. Between compilations, I deleted all .o files 
and executable, so new compile started from scratch.

Compiling with llvm-g++:

With -O2 option, file size grow to 105% and execution time extend 
to 105% (slower).

With -O3 option, file size grow to 106% and execution time is the 
same.

With -O4 option (also Link Time Optimization), file size extend to 
122% and execution time grow to 107% (slower).


Then I tried to compile with gcc and -O3 option. Now file size grow 
to 105% and execution time shortened to 85% (faster).

Has anyone had similar experience with LLVM?

I tried compile with clang. More results, first with gcc, then clang:

gcc -O2 option
size: 346136
time: 0:00:00.681560

clang -O2 option
size: 349976
time: 0:00:00.736821

clang -O3 option
size: 354072
time: 0:00:00.643053

clang -O4 option
size: 382888
time: 0:00:00.734845

gcc -O3 option
size: 362304
time: 0:00:00.579858


It seems, gcc beat LLVM and clang here on performance, if I use -O3 
option.

Correct. World is not designed to cope with such cases, where words 
changes from functions taking arguments to passive non-function values, 
or if number of arguments changes to a function. To change the behaviour 
of the c block, a compile is needed. So question is, if that compile 
should be executed by a COMPILE call, or if the compile state of 
the block could be reset, and in this case, it would be compiled, 
the next time, it was executed with DO.

More about routines.

The next release of World will introduce the handle! datatype. It's 
used to hold pointers, which are normally handled by structs and 
integers in R2.

If we take the sqlite3_open routine as an example:
http://www.sqlite.org/c3ref/open.html


The routine takes a pointer to a pointer as its 2nd argument, and 
this is the db handle updated by the routine. The handle is again 
used in sqlite3_close:
http://www.sqlite.org/c3ref/close.html


, but this time, it's the handle itself as the argument, not its 
address.


In World, using routines should be as easy as possible, and the consequence 
is, the definition of the routine gets some complexity. World uses 
libffi as the underlying motor to carry out the calls. libffi defines 
15 datatypes, where World uses 14 of them (not longdouble). Beside 
"pointer", I will introduce "pointer-adr", and routines like sqlite3_open 
can use that. Then the address of the handle will be given as an 
argument. Routines like sqlite3_close should just use "pointer", 
and World will internally typecast the handle to an integer (32- 
or 64-bit depending on version), and give that to the routine.

Geomol, I am reconnectin to the Rebol3 world after a long time of 
absence.

You are the project LEADER and you are the creator of this wonderful 
project. You have a VISION, a destination.

Back in time, when CARL was developing REBOL3 he created a roadmap 
explaining us what would be the structure of the language, its modules 
and how they cooperate.

This inspired suggestions from the community, changes in the roadmap 
but more preciosuly it created expectation, commitment and willingnes 
to cooperate.

As you may know I am the creator of the REBOL2 DocBase section.

I have asked for long time the upgrade of the software to a later 
version which supports multiple languages.

Personally I have a great private project in mind and a skilled developer 
for it.

The project is blocked because he want to make money now and someone 
who finances the project.

I told him that First of all we must show a concept application. 
This will sell the application itself and we start fundraising.

Until something usable won't be ready I will not be able to sell 
the idea. He refuses this view and we are blocked.


As you are writing a programming language you are in a worst scenarion 
than us.

You need to have a commercial class programming language ready for 
the mass to sell it and this is not the case.

Commercial Class mean: IDE, Solution for interfacing SQL Databases, 
Solutions for communicating, Solutions for interfacing to other projects.

This is too much for one man to accomplish. You need to live, you 
need money and World is your Hobby project (Isn't it ?)


Open sourcing and delegating is the solution for creating a mature 
project: you seth the path, the specifications, the rules, the others 
will help.


I won't give a Penny and Time to REBOL Tech. because its source is 
closed and this model is wasting my precious life waiting for Carl 
to resurrect.

Open Sourcing solves this problem. Don't you think that if REBOL 
was open sourced many developers would have inproved it in Carls 
absence ? Do you think that someone, like an university will donate 
money to a private held project ? I don't think so.


When we (you) will have a mature project and you will be able to 
show to the world the advantages of your solutions money will come.

Think of SQL lite. There is a consortium behind it. Other open source 
solutions have the same consortiums behind them.


There are many ways to raise money: You can produce vertical solutions 
for your baby.You can give consulency to companies and other institutions, 
you can create products with World. These are few that comes into 
my mind.

I repeat: I am ready to cooperate once you will chose an open source 
 licence. I am ready to give money and TIME. Carl didn't seem to 
apreciate. Hope you will.

You list of 5 things:


1) Not sure, I wanna do that. It takes time away from me finishing 
version 1.
2) I have set the goals for ver. 1.
3) No (see Q&A)

4) "Ask for cooperation" - World would need schemes for the different 
protocols. I will welcome others work in that area. Me (and most 
likely others too) would like to see World on more platforms than 
the current 3. Host kit is open source. I will welcome ports to other 
platforms. (That's what I can think of for now, but I'll keep it 
in mind.)

5) It's faster for me to write the documentation than building a 
comm/doc infrastructure. I'll write the World 'bible'. Work has started, 
and I'll use more time on it, when version 1 is a bit closer.

Personal I discourage you from closing the part/all of the source. 

Having learnt from REBOL Tech., the language itself will not sell 
and closing the source closes the opportunity of cooperation.

An open source give you a boost into the develpment and believe me: 
you stongly need cooperation.
However I am not GOD and I cannot force you into making anything.

I could only share my opinions and give you time to thing on them.

Lets the time talk for this. I prey for you.

I just thought of another way to help. Make a list of REBOL functions 
missing. There are many missing from %rebol.w

And there already is a wiki started with differences from REBOL at:
https://github.com/Geomol/World/wiki/Differences-from-REBOL

I don't have time to write it. But everybody can write in that wiki.

Now, go try World out. And remember to have fun!

I second Giuseppe.

I will not invest any time or money in a new closed source project.
Not anymore.

Geomol, do you really think you can follow the same model than Carl 
with better results ?

You should aknowledge the fact than nobody win money just because 
they designed or a created a new programming language.
I was possible back in 90's but not anymore.

Disadvantages: me loosing focus and loosing time, when having to 
answer all kinds of questions and approve new developments. The horror 
of World being fragmented to 100 versions, where none of them are 
compatible. You wouldn't like that! I make sure, that doesn't happen.


You need surplus of time and resources to open source things like 
this, if you wanna be sure, it doesn't run off rails. Look at how 
many ways, you can do any single thing in Linux. It's way too fragmented 
in most areas.

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.

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.

There seem to be a problem with routines returning a handle. A library 
like MagickWand (part of ImageMagick) works this way. I'm not able 
to test it with MagickWand, as I'm not able to load that library 
for different reasons, and I don't wanna use too much time on it.


So I'm after another library, that has a routine, which returns a 
handle, so I can test. A library easily to get for OS X, Linux and 
Windows would be nice. Any suggestions?

Suggestion:


Some routines return a pointer to a structure, like LOCALTIME (from 
LIBC). The structure is struct tm and consists of 11 fields.


In World, we can define LOCALTIME to return a pointer to a handle!, 
but how should we get to all the data fields?


I suggest, TO should be used to copy data from a handle to a structure, 
like:

tm: struct [
	sint sec
	sint min
	sint hour
	sint mday
	...
] none

h: localtime time	; time is some variable holding seconds
to tm h	; This will copy the data (pointed to by h) to tm

Comments? Concerns?

Another try to close the topic on openness: So you expect to get 
man-years of work open-sourced for free? And this in a situation, 
where I get nothing from doing so? Please, be serious! World is not 
a hobby-project for me. I have invested a lot of time and money in 
this.

I have my hands full, and the World project do very good progress 
right now. I see no business benefit from making World open source 
at this point in time.

Case closed. :)

Geomol - it is just that you depreciate psychological factors. Ppl, 
especially with previous experience with RT, are very carefull here. 
In the end, you might just wonder, why noone is interested in such 
a model anymore. And in the end, it is just end result, which matters. 
You either get some community surrounding World, or you might wonder, 
why while your product is excellent, noone really cares anymore. 
Or - you might end up finding some nice niche e.g. embedded market, 
having lots of customers, etc. There is many possibilities, how your 
decision might influence something.


What I really don't understand is one thing - you sound too protective. 
You have full right to sound that way. But what escapes my mind is 
- "when I get nothing from doing so?".  And what do you get from 
actually not doing so? Also - do you expect any harm, caused to the 
business side of your project, by eventually open-sourcing?


As for me - I am used to commercial and licensed products. I just 
wanted to point out, that in the end, your attitude, might be contraproductive. 
If you keep product developed, ppl might feel safe, but ppl might 
also be carefull with their contribution to the project, because 
such kind of REBOL related project already failed big time. Not your 
falt, that's for sure, but the negative assumption is in the air 
nonentheless.

Have you thought of some "escrow" type arrangement to give people 
the confidence that World will not just disappear at some time in 
the future?


It doesn't have to be a full commercial arrangement but perhaps you 
could give a copy of the source to somebody that you trust with instructions 
on what circumstances it would be released (and how it should be 
released).

Under OS X, I get an empty binary, which is expected behaviour. Under 
WinXP, the process hangs here. The OS X and Linux version of World 
use standard BSD networking, the Windows version use MS networking, 
where an init is needed. You're welcome to suggest changes to the 
host specific sources. At this stage, I won't use a lot of time on 
Windows specific sources, as I don't use that platform very much.


I consider using cURL for networking, as that could give a lot of 
features fast. If I find, it adds too much to the overall size of 
World, it could be cut along the way by moving features from cURL 
to World sources.

I admit that I haven't made time to dig into World, but there is 
already a *lot* there from what I have seen. Personally, I am very 
interested. I am also very interested in leveraging community efforts 
in support of all the REBOL-like languages that are available.

Then reality check:


This group was started 2 months ago. It's easy to go through it and 
look for my blue and yellow releases and notes. That's a lot of progress 
in 2 months. If you see it otherwise, then you're blind. The C sources 
of World has grown a lot in those two months, and it's quality work 
with few errors considering the amount.


You will most likely see the progress of World come in waves. I had 
worked intensely on it more than full time since before summer. Yes, 
more than full time (more than 8 hours a day, also week-ends), so 
that's a lot of man hours. The last month, I've done paid freelance 
work too. At the same time, for World I'm researching better networking 
(cURL), getting lib calls to work under Windows 64 using libffi and 
finishing the memory model, so circular references are coped with 
correctly. Why didn't I say so? Because I like to announce things, 
when it's done, instead of giving false hopes, but now I made an 
exception.


1) I'm not going to give my work away for free at this time. That's 
because I see no benefit in doing so.

2) World will not come in a situation like REBOL, with lots of errors 
for a long time and still closed source. If I wasn't able to continue 
work on World (to fix errors, make further progress or whatever), 
and if people relied on work already done, then I would open source 
it. As this isn't the current situation with World, this is no argument 
to open source it.


If you don't like my model, move on. Negative rants here are not 
productive.