World: r4wp

Kaj in !RebolBot: "I think that only works in Red, refinements starting 
with a number :-)"


Refinements that start with a number work in R2 and R3 as well. Path 
elements aren't refinements though, they're regular words or other 
values. If you find any basic data syntax differences between Red 
and R3 in datatypes that they have in common, report them: they're 
either a bug in R3 or in Red, or possibly in both.

I meant path elements. Of course, when they're used in a function 
call, refinements are written as paths

I didn't test it, but not all differences between Red and R3 are 
bugs

Did a quick profile of play-sdl-wav.exe sample.wav into dependancy 
walker and ran it and can hear the sample play.  It doesnt' play 
however when invoked directly from the command line.

Interesting. So it plays unmodified from a profiler?

A timing issue would explain how it could be a soft bug, that actually 
works in the WINE Windows implementation

I confirm Paul's findings, if I drag'n drop %sample.wav on %play-sdl-wav.exe, 
I can hear the music on Win7.

Nice, we're making progress. So still not direct from the command 
line?

No sound output, but the wav seems to be played til the end.

I made a Windows application to easily compile .red / .reds files.

You can download it from http://www.moldibi.com/download/RedCompiler.zip
See the help file.

Yes, even though drag and drop should be the same as starting with 
a command line parameter

It is not a standalone compiler, just a wrapper, so it needs to be 
in the master folder to run. But it makes a bit easier testing red/reds 
scripts.

Nice

I didn't test it, but not all differences between Red and R3 are 
bugs

 - where they are in comparable datatypes, they are. Syntax compatibility 
 in the the compatible datatypes is a necessary feature. If they aren't 
 compatible, it's a bug. The only question is whether it's a Red bug 
 or a R3 bug. It could be either.

Well. if they're not syntax compatible, they're not compatible datatypes 
:-)

If they have the same name and server the same role, they are.

For non-comparable datatypes it's not a bug, of course. And semantic 
differences may not be bugs either.

For instance, if Red doesn't have a money! type then not supporting 
the syntax of a money! type is not a bug.

Nope. 10h is a Red syntax for an integer! but REBOL considers it 
invalid

Maybe that's a bug in Rebol.

Maybe they're both wrong.

If you stretch the definition to conform to your argument, then yes, 
you can make anything fit

But syntax incompatibility for the same datatypes is a bug. The only 
question is which language needs to change to make it compatible. 
I am not going to constrain Red to match what R3 can do now when 
R3 can change too. They are related languages. Arbitrary incompatibilities 
that aren't related to the differences in semantic models are bugs. 
Of course this is all keeping in mind that LOAD is just a function, 
but that doesn't make arbitrary incompatibilities a good idea. They 
are in the same syntax family. If it's a good idea to do for Red, 
it's a good idea to do for R3 as well. And if it's not a good idea 
to do for R3, then it is likely also not a good idea to do for Red 
for the same reasons. And maybe there is a better idea for both.

Semantic incompatibility is another issue. Those are more likely 
to be OK.

Hex notation is not arbitrary

So the bug is in R3.

It is likely that there will be whole datatypes that are appropriate 
in one and not the other, but I expect many of those to eventually 
cross-propagate in a lot of cases because their system models aren't 
really that different, just their implementation models. Certainly 
I would expect datatypes with literal non-constriction syntax to 
cross-propagate eventually, and those are the only ones where syntax 
compatibility would be something we would even consider to be an 
important factor.

If you define anything Red does that R3 can't do as a bug, that's 
fine with me :-)

The main principle of the Rebol family way is data syntax compatibility. 
Everything above the data syntax is just a dialect. Even construction 
syntax is a dialect.

Tell that to Boron and World

Incompatibility is the whole point to Boron and World, and that is 
why they will eventually fail. I want to make Red and Rebol succeed. 
They have the best chance to succeed by cooperating. No merger necessary, 
just cooperation.

I don't think that can be said of World

If you define anything Red does that R3 can't do as a bug, that's 
fine with me :-)

 - only when the reason that Red does it is sound. I've noticed that 
 sometimes it isn't (don't worry, it's rare). On those occasions, 
 I'll report Red bugs :)

I think that it can, but the reasons for that are not relevant here. 
If you like I'll discuss them with you privately.

No need, I'd like to get on with my work

Cool.

BrianH: I agree that we should avoid arbitrary syntax incompatibilities. 
For achieving that, the best way is first to have a complete formal 
description of the target syntax that we all agree on, then only 
we'll be able to flag deviations from that model as bugs. 


IIRC Chris has started working on such formal description, how complete 
is it?

Looks like we need to find some simple but efficient online collaboration 
tool to better keep track and organize all the common sub-tasks between 
R3 and Red that keep poping up these days.

I have that bookmarked, but haven't yet looked it over thoroughly. 
I noticed that the last time I tried to determine R3 syntax the effort 
generated a lot of bug tickets. The same would likely happen once 
I get a chance to go over Red syntax, and they may end up being a 
lot of the same bugs. Some syntax issues are an inevitible result 
of being in the same syntactic family, and not realy arbitrary when 
you consider the balance of the entire syntax.

For instance, there is at least one bug report for R3 related to 
increasing the number of delimiters that should be rejected because 
implementing it would drastically reduce the readability of code 
written in any Rebol family language. If Red implemented that proposal 
it would be a bad thing for Red as well for the same reasons.

And I was the one who filed the bug report :(

Boron may fail because people just don't seem to be interested in 
it and World already failed because it's closed soirce.

I don't think World failed, actually. I think it succeeded at what 
he needed it to succeed at. He just didn't need adoption by other 
people.

As Geomol doesn't list World in used tools for his iOS projects I 
guess it failed.

Sounds like Brian means Boron

Doc, the Brackets editor is using Trello for the online task tracking/collaboration. 
Looks pretty cool and doesn't cost.
https://trello.com/board/brackets/4f90a6d98f77505d7940ce88

World's value slot size is 256 bits, which only makes sense for big 
data, not for mobile platforms like iOS. Its semantic model is basically 
that of R3 (plus all of the changes that he had requested R3 make 
that were rejected), and that semantic model is not really compatible 
with the iOS App Store review process. So I'm not surprised to see 
him not use World for iOS - its target market is completely different.

Kaj, are you sure? "He just didn't need adoption by other people." 
sounds like closed source nature of World, not Boron's GPL.

He released documentation, not the actual interpreter. He needed 
advice, not adoption.

Boron is meant to be used by a lot of people, hence the copyleft 
license and actually being released.