World: r3wp

and are they discouraged to use GPL?

I don't know. MIT is public funded, so their products need to be 
usable to the public. That includes businesses.

I think they also make money off patents though.

yeah... any invention eventually needs to be leveraged... that's 
ok.    and most high-profile research is funded by companies nowadays... 
I'm pretty sure its like that in all universities in the US.

The big ones, yes. The others don't do a lot of research. There are 
exceptions though; my old professor contributed to Pizza, which led 
to generics in Java 6, and indirectly in C# 2.

Max, you sound like Japan anime with "most high-profile research 
is funded by companies nowadays".

To be fair, research has more of a chance to become high-profile 
with marketing. Companies can afford more marketing.

a lot of companies go to universities for some specific problems. 
 they fund a specific project form a team and a professor and team 
has work for 2-3 years.  sometimes it goes through the school, sometimes 
it almost like "renting" the professor for cheap.

Doc is there any reason the shift functions (<< >>) are not implemented?

Yes, multiplication or division by a power of 2 are generating shifts, 
so the feature is available, the << >> operators are now just syntactic 
sugar, that's why their implementation has been delayed.

They are also missing from the specification doc because I am not 
sure it is worth adding them anymore. What do you think?

Humm, looking at it a bit closer, it is not totally equivalent: the 
* and / operators will generate shifts only if the right argument 
is a literal integer. So: 
    a: 4
    123 * b
won't generate a shift.

So, I guess the conclusion would be: it is worth adding them. :-)

I'll consider adding these operators to the specifications after 
finishing my current debugging on ANY & ALL.

a: 4
    123 * b
should be:
    a: 4
    123 * a

Will  << and >> be needed in order to build the first version of 
Red?

shift funcs are useful f.e. for checksums, securtity funcs etc. I 
thought the shift funcs will be produced using shift machine codes 
(i e single operation). Is there some kind of optimalization for 
multiply/delete by pow of 2? Also consider not to implement overflow 
for << (true shifting)

Peter: strictly speaking, they are not needed because they can be 
emulated by math operations. However, on CPUs, the speed difference 
with true shifts is huge (one order of magnitude at least). I can't 
say yet how much shifts will be used in Red's runtime (mainly in 
memory manager) because in some cases, bitfield operators could be 
used instead.

I was wodering if you could perhaps live without them until the version 
of Red/System that will be built with Red.

wodering -> wondering

Speedwise, certainly. But as the Red/System code that will be written 
for Red's runtime will stay, syntactic improvements are worth considering 
now.

It is a matter of writing, e.g.:
    123 >> 16
instead of:
    123 / 65536

It is certainly more readable.

I'll  guess that  the next request will be for an unsigned integer.

BTW, Pavel is right about the overflow error checking (which is still 
pending for math ops in the current implementation), it is not required 
for shifts.

Doc it would be very helpful to publish (maybe as picture) workflow 
thru respective modules (files) because for non expert it is quite 
difficult to see what is going on each module.

You mean compilation workflow?

yes and maybe light enlightment of design (ie metacode is created 
by compiler or linker?)

metacode? If you mean the native code generation, it is done by the 
compiler.

I'll see if I can make a short description on how it is organized.

and what linker cares about, glues together multiple compiled source 
files?

Compiled source files are glued together by the compiler itself. 
The linker currently simply generates the right binary from compiled 
code, global data and external libs imports. The linker will be later 
extended to be able als to statically link external libraries.

als => also

so emitter is only helper?

Emitter module purpose is to isolate as much as possible target-specific 
code from the compiler. So, it provides target-independent helper 
functions to the compiler and for target-specific code, it loads 
one from  %targets/ folder.

thx for description

The emitter module API is used by the compiler only when it can provide 
an added value, else the compiler taps directly in the target-specific 
code through a target-independant API. In other words, a new target 
module needs to implement all the current target API (all the emit-* 
functions in %IA.r) to be able to work with the compiler.

Doc - do you think we can get Red to the following page, or is it 
too preliminary?

http://en.wikipedia.org/wiki/List_of_programming_languages

somewhat premature .. it's not in use yet

I agree.

Probably too early.

Direct link to Red/System specifications draft changed, it is now 
available from: http://static.red-lang.org/red-system-specs.html

I just visited the Haiku OS website, and I can see, that it was accepted 
for the Google summer of code 2011. Maybe once Red becomes an alpha, 
we could apply too? Let's say for 2012 :-)

Google Summer of Code is a global program that offers student developers 
stipends to write code for various open source software projects
  I wouldn't qualify for the "student developer" part.

No, you would qualify for the mentor part. So you'd have to find 
students willing to write open source Red code, and then you have 
to mentor them

It's very hard to get into SoC, beginning with the rush to register, 
and if you don't have the organisation to conduct the mentoring, 
or your project is too eccentric for students to get into quickly, 
it's fairly pointless

It's also questionable if the students will go on to maintain their 
code. The biggest advantage if you do get in is simply the marketing, 
because people suddenly think you're associated with Google

(and google also gets to notice you a little)

Yeah, so they can steal your ideas... I figure the cost is well worth 
it to them

Kaj: thanks for the insights.

Questions about the declarations.  

1-  why are you using this syntax for *all* declarations? : 
word: [datatype value] 

ex:
my-val: [integer! 20]

woudn't just this do ?:
my-val: integer! 20

I find its a hell of a lot easier to read,


and when you add type detection, its back to 

my-val: 20   


meaning that the integer! word really is just a typecast operation 
here.