AltME groups: search

Point 3 is important for me and many others. If the project is open 
sourced I will be ready to donate. No waste of money donating to 
a private held company.

Geomol: do you plan to make money selling the language ?

Don't you think that if REBOL was open sourced many developers would 
have inproved it in Carls absence?

Yes, myself included. I'm not absent. I will not let the World project 
ends (or leave at the state) as the R2 or R3 project. Then I would 
better open source it.

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.

do you plan to make money selling the language?

No, that's not in my plan, but who knows, maybe someone wanna pay 
me to open source it or use it in certain projects. I plan to keep 
the language free (no payment to use it), but make money on areas 
connected to the language.

:)


About open source, read my answer in the Q&A. It has to make business 
sense to open source. It doesn't atm.

Exactly how does your plan differ from R3 business plan?

As I don't know the full R3 plan, I don't know the answer to that 
question.

to the known aspects of the R3 business plan :)

When I started "Countdown: 10" 2 weeks ago, the C sources were close 
to 23'000 lines. Atm. World is 24'372 lines and growing. The project 
is moving forward fast.

Geomol: don't make the mistakes of CARL. 

You strongly need developers and adoption from the open source community. 
We are now in the right momentum. Please belive me: you have more 
adavantages than disvantages and you won't loose the contro of your 
baby.

don't make the mistakes of CARL.
Trust me, I won't.

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

Well, good luck but as in the tech news .. HP paid $1.2bn for WebOS 
and are now open sourcing it

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.

I am sure I won't convice you about open sourcing it showing only 
advantages but I am curious: which are the disvantages you see in 
open sourcing the Language ?

I have my hands full now, and I make really good progress. When we're 
around version 1 (or if I don't make more progress), it would make 
much more sense to think about open source. And as I've said, it 
may also make really good sense to open source parts along the way. 
I have considered library.c and library.h, which holds the C code 
for library! and routine!. That almost makes sense now. When I've 
implemented error! correctly (working on it), it really makes sense. 
You have only been able to run World for 5 days. Patience! :)

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.

So haft are open. Do you have a general view, how things are going 
with the different languages?

It's actually a lot like Linux. Every distro has something you need, 
but none of them has everything you need. If I want to build the 
Russian Syllable website, I can only use R3. If I need system integration 
and speed, I can only use Red. If I need to write web apps, only 
Topaz targets that. If I need open source, I can only use half of 
them. If I need dynamic binding, I can only use the interpreters. 
If I need infix operators, I can't use Boron, although I could use 
its predecessor. Etcetera ad nauseum

I feel, trying to do everything has high possibility of failure. 
But being able to integrate with everything could be the way to be 
able to do everything.

I feel not trying to do everything equals failure from the start. 
A language is supposed to cover everything

This is the main reason REBOL has slided for a decade

But still, I strongly believe in the value of "general purpose language", 
though I wouldn't go as far as saying that one is supposed to cover 
"everything".

Andreas, I've thought some more about the need for a compile state 
reset. Have you?

:) I see it as:


I have compiled function, I would like to change -> I make changes 
-> I want the new version to run


With compile reset, that can be cone at any point between first run 
and second. Doing it with COMPILE, it needs to be done right before 
2nd run. But isn't that good enough? Or can we come up with situations, 
where it isn't?

Well, just remember the example we had.

If I, as a writer of some code-modifying helper function want to 
also provide the behaviour of INSERT, I can't.

Doing it with compile, the recompilation is forced to happen right 
after the modification.

If we had a compile reset, we could postpone the recompilation until 
the next evaluation.

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

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.

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

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.)

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? :)

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

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?

another issue
the current  world_win exits after  errors

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.

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.

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.

- Added datatype, struct!
- Ctrl-A at the prompt toggle auto-brackets
- Ctrl-D at the prompt quits World
- Fixed networking like: open tcp://8080

In the above example, libc is defined as:

libc: load/library %/usr/lib/libc.dylib

Hi, I am interested into building an maintaining documentation for 
those programming languages based on REBOL.
It would be nice to have a DOCBASE for them.
What I search is:
- Someone ABLE to SETUP the Linux and the Wiki Software
- Someone which would share with me the cost of hosting.
Do you like the idea ?
Write me at [giuseppe-:-chillemi-:-eu]

I was able to load MagickWand under Linux, and it seems to work with 
uint32 datatypes to hold the handle (a C pointer). But it doens't 
work so well when using the handle! datatype for that. It would be 
nice, if it worked, I guess. It's probably some type casting problem.

actually, any library which returns a string could use a handle! 
as a return value instead.    the handle could be used to store the 
reference to the string as-is and give it to another routine which 
requires a string on input.

For minimum install, just pick one of the world_* files and cortex.w

yes ROTATE is handy to have native when you need it.   its the kind 
of function which will be much slower to build manually than having 
it native (or hand optimised by the language author ;-)

if you open and connect and the peer closes, this happens too

About copying from a port, I get a zero, if the port is closed, but 
just under OS X and Linux. Windows version seems to hang in that 
situation. Networking code is open source, and you're welcome to 
suggest changes. I consider using a lib for networking instead of 
coding it all by hand.

at the moment i am just in holiday and have only limited access and 
not the infrastructure i am used too. maybe when i am back, i will 
have a look at the code.

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?

As I understand localtime is not thread safe, the thread safe version 
locatime_r requires the address of a tm structure as an argument. 
(Though it returns the pointer to that same structure if the call 
is succesful.


In general, isn't it a better option for strucutures to be allocated 
in World rather than the called function?

Yes, it's probably a better idea to use routines, where you can allocate 
the structure in World, and handle the routine a pointer to it. But 
some routines does the other thing. In the case of localtime, it's 
a static buffer. Some routines in some libraries dynamic allocate 
memory, that the user can deallocate again with other routines. (Oldes 
pointed me to such a case in ImageMagick.)


If World should support calling such routines and be able to operate 
on the result, we need something like my suggestion, I think.

In the ImageMagick/MagickWand example, it was a string, and it's 
possible to get the string from a handle in World with:

	to string! handle

I thought of something similar with structs.

The to approach seems neat syntactically but is there a danger it 
would be slow with large data structures?

I don't think so, as it's a simple memcpy. The C code looks like 
this:

	if (rb->type == STRUCT_T) {
		if (rc->type == HANDLE_T) {
			Struct *U = (Struct *) rb->value.rc;

   memcpy (U->u, (char *) ((Handle *) rc->value.rc)->pointer, U->size);
		} else
			invalid_argument (W, rc);
	} else
		invalid_argument (W, rb);

The alternative (as I see it) is to not be able to access such structures.

Routines able to operate on structures, you define in World and give 
a pointer to to the routine, doesn't need this memcpy, and it'll 
work today.

To avoid the memcpy, the AS function could be used to redefine a 
handle to a struct. Like:

	as tm handle


, but then handle is redefined as a struct, and it now points to 
a mem area, the routine made. So this can't be deallocated by World, 
and the memory management has to deal with that situation. Not good 
in my view.

I found a way under OS X using AppleScript to launch World scripts 
from the Finder by dobble-click, and to start World the same way, 
if anybody is interested. It may be useful for REBOL and other languages 
as well. The method makes a world.app. Speak up, if you need it.

You should also be able to see the usage with any other option not 
recognizes, like: world -h
Maybe the -? is the problem?

I'm not sure about allowing typecasting from handle!.  it sort of 
defeats the purpose of an opaque pointer handler IMHO.   the better 
alternative would be to allow the routine to define what struct pointer 
type it returns directly.

The argv(0) method doesn't work in some circumstances on Windows. 
R3 has been running into some problems because of that.

http://issue.cc/r3/1892shows some circumstances that will trigger 
the problem, so it's a good model for building tests.

The argv method was fast to implement and works in my cases, so I 
went with that for now. It maybe will need to be replaced by something 
else. Putting cortex.w (and user.w later) into an install dir like 
Library/Application Support/world/ could be a way under OSX, and 
something similar on other platforms.

Thanks, Gregg. Some thoughts...


I create World, because I need the tool. So when I have the functionality 
planned, I've reached one of my goals, because I then have the tool, 
I need for my own future developments. For World to become a success 
for others to use also, it needs to be better in crucial ways than 
the tools, others use today. Therefore I also focus on making World 
slim (not bloated), stable and bug-free, very well defined, easily 
integratable and with good performance. There still is work to do 
in all these areas.

I have World calling COBOL code.  It'll be nice to get a full on 
64 bit core though.  Much mucking about with 32 bit libraries, compiling 
COBOL in a VBox etc.

Getting close to automating the Dictionary wiki pages as well.


Adding to the old topic of openeness.  OpenCOBOL is open source, 
but very few people fork it.  Roger is the principal developer, and 
we wait for his releases ... but we get to see the compiler, build 
it on our platforms.   John, I don't want to see World core open 
so I can change it, I'd like to see it open so I can read it, build 
to suit, learn things.  So, if it's not asking too much, put the 
core code up in a read-only repo and ignore the forks while you develop?

Lastly; fun and looking forward.

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.

And so he wants support for free. :-)

Joke appart, I feel bad because we saw many projects failed because 
of the same reason.

A language implementation itself without real businnes application 
will get you nothing but some fame.
And so he wants support for free. :-)

I don't ask for your support.


I bring World to the awareness of you guys, because you might benefit 
some a REBOL like language in the current situation with REBOL. I 
could just have continued keeping my mouth shut and made the tool, 
I need, without others knowing about it.

I feel bad because we saw many projects failed because of the same 
reason.


Don't feel bad! A month ago, you didn't know about World. Now you 
do, and now you have an extra option. Where is no reason to feel 
bad.


Afaik projects like Boron are open source, and you may put it in 
the category of "failed projects". So open source doesn't equal success.

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).

And it's the very reason Boron  failed

It is published under the LGPL.

Ok  people, look at the red light :)
Flashhhhhhh !!!!

Pekr, sorry I don't comment on all you say. But look e.g. at a product 
like WebOS, which was mentioned here in this AltME world not long 
ago. It was developed to the current state as close source. Just 
recently HP announced it to go open source. I judge it to be an ok 
success for the people behind it, even if it was developed as close 
source. Open source doesn't equal success. And close source also 
doesn't equal success. But they may be related.

Geomol: "man-years of work open-sourced for free? And this in a situation, 
where I get nothing from doing so?"


You could get _a lot_ from doing so. Increased participation in general, 
with all the positive effects that can encompass. But whether you 
consider that worth the trade-offs necessary to reap those benefits 
is obviously your choice.

A lot of us would like Rebol and its derivatives to  be successful 
because success brings validation, and more importantly brings new 
people and development to Rebol.  We've all seen the closed source 
model fail, and specifically we have seen people leave Rebol or refuse 
to learn Rebol on this account.  Orca and Boron are not relevant 
because there was never a critical mass of people aware of it, and 
the GPL license put commercial developers here off.  Partial open 
source models like R3 would suggest that this model is also not attractive 
enough with a lack of investors to keep Carl working on the project. 
 Perhaps you do have some wonderful business plan that is going to 
work against all odds but the majority of us are not so optimistic. 
  We don't wish to see history keep repeating itself and so we are 
advising you to change your plan.   Think King Canute!

- Shakes head at all the foolishness spouted here -

He means that Boron is LGPL, rather than GPL. You still get (an extended 
large subset of) the restrictions.

Yes, and the distinction warrants some shouting after half a decade 
of Boron and ORCA development

I have some free-lance work to do these days, but will continue work 
on World too.


The next thing for World is finishing the memory handling, so contexts 
are freed completely (problems with functions and blocks within contexts 
today). I'll check cyclic references too. After that, it's the rest 
of the datatypes, functions and better networking.

In src/host/network.c line 86 and src/host/win32/network.c line 84. 
I break out of the while loop, if recv returns zero in case of closed 
socket.

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.

Any news here? Wondering why the momentum is mostly gone für world.