AltME groups: search

Announcing latest INCLUDE changes:

* the complete file now available through rebol.org using the

http://www.rebol.org/view-script.r?script=ladislav-include.r


link. Note, however, that I use the %include.r script name here (should 
not be a problem, though).

* addition of the STANDARD-HEADER variable to INCLUDE-CTX
* script header processing added
* doc update

Doc and I created a bridge between Red and R3:

This solves the problem that it has turned out that hardly anyone 
wants to write R3 extensions in C. Extensions written in Red are 
also much easier to manage, because you can cross-compile them, instead 
of having to set up a development environment on each target platform

It's not completely tested yet. The do-string call into R3 doesn't 
seem to work. We don't know yet whether this is a bug in Red/System 
or a bug in R3

RED FUNDING DRIVE, MATCHING FUNDS CHALLENGE:  to help ensure that 
Doc can continue to work on Red without disruption, I'll match funds 
donated to him by November 1, 2012, up to a total of $1000.

I wrote a tutorial that makes use of Chris Ross-Gill's Etsy.r module: 
 http://re-bol.com/etsy_api_tutorial.htmlThe focus of this one 
is all about helping the Etsy API developer team, but by necessity, 
it teaches all the REBOL basics, along with all the absolute beginner 
concepts.  I'm hoping the Etsy guys will write a blog post about 
it and help drive some more traffic toward REBOL :)

We just finished to setup a public Cofluence wiki test server, where 
TreeMapper models are rendered in HTML-5. Take a look here:


http://s1.saphirion.com:8001/display/TREEM/Treemapper+Demonstration+on+Conluence


That's a model that's done with the R3 based editor and published 
out of the editor directly into a wiki page. The next demo version 
will include the server information so you can test it on your own.

needs to be checked out in the subdirectory "common" for other bindings 
to find it. I use a parent directory Red:

The guys at Etsy added Chris's library and my tutorial to their developer 
pages.  https://www.etsy.com/developers/documentation/resources/developer_resources
 I really think there's a marketing opportunity for REBOL, doing 
these sorts of tutorials for other web APIs

REBOL publishing libraries and tutorials like this for other popular 
web APIs.  Get a bunch of big web sites linking to REBOL sites, and 
their developer communities all taking a look at REBOL, and there 
will be curiosity and added traffic.

I've started using a Fossil repository to sync and archive test binaries. 
In case anyone wants to run them:

I just update the http://www.rebol.org/view-script.r?script=advanced-r3d.r
   R3D demo, may you test the models on your PCs and give me a feedback 
if it's all good? With off models I turned off backface culling and 
it can be hard for some pc... maybe...

I've added a build script to the above testing repository, to build 
all my Red examples in one go

To get a clue which binding/library an example program uses, look 
in build.r

http://en.wikibooks.org/wiki/REBOL_Programmingnow it's a good guide 
on Rebol: what do you think?

Rebol [Purpose: {make wikibook entry}
Author: "Max Vessi"
version: 1.0.0
]
my?: func [
    "Prints information about words and values."
    'word [any-type!]

    /local value args item type-name refmode types attrs rtype temp
][       
    temp:  copy ""
    if all [word? :word not value? :word] [word: mold :word]

    if any [string? :word all [word? :word datatype? get :word]] [
        types: dump-obj/match system/words :word
        sort types
        if not empty? types [
            print ["Found these words:" newline types]
            exit
        ]
        print ["No information on" word "(word has no value)"]
        exit
    ]
    type-name: func [value] [
        value: mold type? :value
        clear back tail value
        join either find "aeiou" first value ["an "] ["a "] value
    ]
    if not any [word? :word path? :word] [
        append temp reduce [mold :word "is" type-name :word]
        exit
    ]

    value: either path? :word [first reduce reduce [word]] [get :word]
    if not any-function? :value [

        append temp reduce [uppercase mold word "is" type-name :value "of 
        value: "]

        append temp either object? value [ reduce ["^/" dump-obj value] ] 
        [mold :value]
        exit
    ]
    args: third :value
    append temp  "= USAGE: = ^/ "

    if not op? :value [append temp reduce [ uppercase mold word " "] 
    ]
    while [not tail? args] [
        item: first args
        if :item = /local [break]

        if any [all [any-word? :item not set-word? :item] refinement? :item] 
        [
            append temp reduce [append mold :item " "]

            if op? :value [append temp reduce [append uppercase mold word " "]
	    value: none]
        ]
        args: next args
    ]
    append temp  "^/" 
    args: head args
    value: get word
    append temp "^/= DESCRIPTION: = ^/"
    either string? pick args 1 [
        append temp reduce [first args]
        args: next args
    ] [
        append temp "^/''(undocumented)''^/"
    ]

    append temp reduce [ "^/^/"uppercase mold word " is " type-name :value 
    " value."]
    if block? pick args 1 [
        attrs: first args
        args: next args
    ]
    if tail? args [exit]
    while [not tail? args] [
        item: first args
        args: next args
        if :item = /local [break]
        either not refinement? :item [

            all [set-word? :item :item = to-set-word 'return block? first args 
            rtype: first args]
            if none? refmode [
		append temp "^/= ARGUMENTS: =^/"
                refmode: 'args
            ]
        ] [
            if refmode <> 'refs [
                append temp "^/= REFINEMENTS: =^/"
                refmode: 'refs
            ]
        ]
        either refinement? :item [	   	  
            append temp reduce ["*'''" mold item "'''"]

            if string? pick args 1 [append temp reduce [" -- " first args] 
	    args: next args]
            append temp "^/"
        ] [
            if all [any-word? :item not set-word? :item] [
                if refmode = 'refs [append temp "*"]
                append temp reduce ["*'''" :item "''' -- "]

                types: if block? pick args 1 [args: next args first back args]

                if string? pick args 1 [append temp reduce [first args ""] 
		args: next args]
                if not types [types: 'any]
                append temp rejoin [" (Type: " types ")"]
                append temp "^/"
            ]
        ]
    ]
    if rtype [append temp reduce ["^/RETURNS:^/^-" rtype]]
    if attrs [
        append temp "^/= (SPECIAL ATTRIBUTES) =^/"
        while [not tail? attrs] [
            value: first attrs
            attrs: next attrs
            if any-word? value [
                append temp reduce  ["*'''" value "'''"]
                if string? pick attrs 1 [
                    append temp reduce [" -- " first attrs]
                    attrs: next attrs
                ]
                append temp "^/"
            ]
        ]
    ]
    editor temp
    exit
]

I have put a script similar to the chess script on rebol org. It 
is a script to determine all possible moves in the international 
10x10 checkers game (dammen). It needs some improvement in how to 
represent the moves themselves, but the basics work. I'll post a 
board and simple board evaluating script soon. 
http://www.rebol.org/view-script.r?script=dam1.r

(I need also to find out how exactly to make a package from all needed 
files)

MaxV: I see you wrote: "ALIVE? is a logic of value: true" - I think 
that this needs a more thorough explanation, though.

I'm particularly interested in results for MSDOS/RedSystem/read-web-page 
and play-SDL-WAV. I haven't been able to use cURL to read a web page 
yet, and playing sample.wav appears in the Windows 7 mixer, but I 
haven't had audible sound yet

I just finished the full Rebol disctionary on: http://en.wikibooks.org/wiki/REBOL_Programming/Dictionary
there you can find also the source of the functions. 

It's a public wiki, you can add examples, correct bugs, add topics: 
you are welcome!

it has a lot more than just the function's prototype and source.

it includes related,  examples and some usage text.

Excellent Max - well done - that is a really cool demo for beginners 
or those curious

After the mirror game and the chessboard interface, the Red compiler 
script and various cgi scripts and showing all how radio buttons 
work in VID, I can now introduce to you the application to play checkers 
(10x10 international, in dutch dammen). Not bad for a REBOL newbie 
right? Wait a moment with all of your nominations please, because:

There is a tiny issue left with the moving of the pieces when playing 
against the computer but it is minor compared to all other issues 
I have already fixed ;-)


You can download the zip file with the program here http://arnoldvanhofwegen.com/stuff/damscripts.zip

Program is started with do %damb.r and you can play after setting 
the color the computer has to play with on the panel you get when 
you click the top-left button. You can look under the hood and see 
the values the program gives the legal moves. You can put your own 
positions on the board and continue from that point.
Enjoy!

I updated my Fossil introduction for Syllable 0.6.7 and modified 
the example to be specifically for the Red test binaries, so it can 
now be used as a guide for getting the Red test programs:

My game, Stunt Ace, has been released to iOS (iPhone, which also 
works on iPad).


Stunt Ace is a retro type game. REBOL was used in the development 
process to make a prototype and for the level editor. I also used 
the REBOL DRAW dialect to create the logo, icon and presentation 
graphics.


Stunt Ace can be found on Apple's App Store. The Android version 
can be found on Google Play.

Homepage: http://niclasen.name/stuntace.html

Stunt Ace was made using:
- Deluxe Paint on an Amiga
- GIMP
- Waldorf Pulse analogue synthesizer
- TimewARP 2600 analogue soft synth
- Roland A-90 keyboard
- A Mac
- A PC
- REBOL
- In-house software

Have fun!

I've uploaded new script:

https://github.com/Oldes/rs/blob/master/projects-rswf/pack-assets/latest/pack-assets.r
which I'm using with this one:

https://github.com/Oldes/rs/blob/master/projects-rswf/form-timeline/latest/form-timeline.r

to pack assets (bitmaps and animations) for prototype of Adobe AIR 
framework I'm working on which can be seen here:

https://github.com/Oldes/Starling-timeline-example(as a Flashdevelop 
project)

ech.. f..ing altme links..
I've uploaded new script:

https://github.com/Oldes/rs/blob/master/projects-rswf/pack-assets/latest/pack-assets.r

which I'm using with this one:

https://github.com/Oldes/rs/blob/master/projects-rswf/form-timeline/latest/form-timeline.r


to pack assets (bitmaps and animations) for prototype of Adobe AIR 
framework I'm working on which can be seen here:

https://github.com/Oldes/Starling-timeline-example(as a Flashdevelop 
project)

Today I have put version 1.0.0 of the 10x10 checkers (damspel) out. 
The script on rebol.org points to the download location on my website 
(because it is a package of scripts more than a single script)
You can find it on http://arnoldvanhofwegen.com/stuff/damgame.zip

I'm offering another matching funds drive to help keep Doc working 
on Red.  I'll match funds donated to him by December 25, 2012, up 
to a total of $1000.  If you're interested in Red, please help Doc 
focus his efforts on the project.

I released a camera app for iPhone today.


The DRAW dialect of REBOL was used for all interface graphics. Also 
the presentation graphics was made using DRAW (except the actual 
photos, which were taken using the app). See:
http://niclasen.name/gcam.html


I like the results of the iPhone 4S and iPhone 5 smartphone images. 
It's hard to see, they're made with DRAW and not just photos.


GCam is waiting for review at Apple and will be available on the 
App Store typically within a week from now.

made good progress over the holiday, powered by turkey sandwiches 
from France.


Prep of C source nearly done. See, not just a dump and run. Sure, 
a few problems came up, but I'm not going to hold up the release 
for them. You can decide.


Grabbed latest git source and built it for this dev box (which did 
not support 1.8 version as bin.)


Once released, I've got a number of notes to write up. Like how to 
quickly port R3. Takes about 5 mins if you know what you're doing. 
Got it up on ARM & MIPS Linux.


Also, I have some goals in mind. Android and iphone, that kind of 
thing. Getting graphics and sound back up. GUI and tinyGUI. A micro-R3 
for smallish embedded systems.

There's a lot you can help with. Delegation, right?

Created a new project at http://github.com/SteeveGit/R3-CODE-EDITOR

For now, only the vertical scrolling is worth testing (still random 
crashes).
For windows users with the saphirion's R3 version found at
http://www.saphirion.com/development/downloads-2/
(pick the first .zip)

Gregg Irwin has rewritten the redcompiler.r script on rebol.org and 
I now added a help screen, a check for a red.r compilerscript in 
the selected directory, support for Red source only compilation, 
the option --red-only Doc recently added. 

You can still find the new script here http://www.rebol.org/view-script.r?script=redcompiler.r

A kind reminder to subscribe to the Red mailing list at https://groups.google.com/forum/?hl=en&fromgroups#!forum/red-lang
is you haven't done so already.

Here's a 6502 CPU emulator written in Red/System:

It was enabled by the function pointer casting in Red 0.3.0 and the 
new functionality of the preprocessor. It proves that such a low 
level and performance critical thing can be done with Red

I haven't tested it much yet, because I haven't emulated a machine 
around it yet

However, I rewrote it from a fairly complete Atari XL/XE emulator 
that I did in C a long time ago. The new code is a third shorter, 
mostly due to abundant use of preprocessor macros, which are less 
horrible in Red/System than in C

My full Atari emulator ran full speed on a Pentium 75 or a 100 MHz 
486. I roughly expect this one to run half as fast, so as a full 
emulator I'd expect it to need a Pentium 150. As another guesstimate, 
it should need half a Raspberry Pi

Let me announce first achievement of bringing R3 to Android OS based 
devices. I know many of you were waiting for this so long so here 
is the first test version to download:

http://development.saphirion.com/experimental/R3droid.apk


Note this is just first raw port showing the interpreter is working. 
The console input is missing at the moment, but will be probably 
among first things to add so you can have your beloved /Core on your 
mobile/tablet.


If you would like to speed up this developement, donate, sponsor 
or make a bounty for features please crosscheck with Robert/Saphition(he'll 
write more info here as well)

To start off, I'm offering a matching donation up to $500, to Saphirion, 
for this work.  (Moving to Android group...)

I tested R3droid.apk on a Huawei M865C, and it works :)

http://development.saphirion.com


I have reworked the whole site. You can download the latest R3 releases 
with graphics engine for windows for now. Further our latest R3-GUI 
release is available too.


The site contains a bounty shop as well, if you want to support / 
donate to some of our efforts. All things we will work on are listed.

Stay tuned, more to come over the next weeks.

Updated our R3 version. Changes:


- no longer links libstdc++ dynamically but statically. You get an 
error that libstdc++-6.dll is missing from your computer.

- changed startup procedure to support correct stdio redirection 
in console mode (used if you start R3 with a command line argument, 
else GUI mode)

I've got a question about using MakeDoc/MakeDoc Pro vs Markdown/MultiMarkdown. 
Are there significant advantages with MakeDoc that outweigh going 
with Markdown which seems to be the defacto standard for lightweight 
markup? I guess when MakeDoc first came out it was pretty unique, 
but if you were to need this kind of tool today wouldn't it make 
sense to use something with wider adoption?

My 6502 emulator in Red/System now takes the name of a ROM file as 
a command line parameter. It can load any ROM that's a multiple of 
2 KB in size:

I've tried several operating system ROMs. They seem to work, although 
it's still hard to judge without a real machine emulated around the 
CPU

I've added a Fibonacci example to my benchmarks in Red with the main 
function written as a routine!:

I feel small and humble in the shadow of Doc's Xmas present, but 
for what it's worth, here's a very preliminary Red binding with SQLite:

Only simple functions work so far. I've added a Red version of do-sql 
to the test programs that just prints the SQLite version. See above. 
They're in */Red/do-sql

As you can see there are a number of primitive constructs in the 
Red binding. I'll report issues as I go

Released R3 ODBC host extension to https://github.com/gurzgri/r3.git
(branch odbc). 

It's a fairly complete, Windows only extension in the spirit of the 
R2 ODBC api.

I made a version of the Red interpreter console for other platforms 
than Windows. It runs on systems that have the ReadLine library. 
It uses both the libreadline and libhistory libraries, so it provides 
command line editing and history recall

(My remark was going into a different direction, but I have withdrawn 
it as I don't think this would help the discussion.)

Ladislav, most of what Andreas and Maxim are saying here is true, 
but it doesn't matter. Reading comprehension requires reading the 
whole thing. The relevant part you missed is:

    or we could get a FAQ entry declaring that the functions built into 
    R3 are "part of the interpreter" rather than "library code", despite 
    R3's actual system model.


I am actually an expert on R3's system model as it relates to dynamic 
linking of code, and how code is bundled, since I wrote most of the 
code that does that. The mezzanine code is dynamically loaded and 
linked in the startup code, and is statically linked as data into 
r3.exe, so as far as copyright is concerned it is linked two ways. 
At least in the laws of the country of origin of REBOL, the code 
vs. data distinction is irrelevant to whether the code/data is covered 
by copyright, or the GPL, which only relaxes copyright. All that 
matters is that the mezzanine data is statically linked into the 
program. For that matter, it's not even bundled as a resource, so 
it's really hard to make the "mere aggregation" argument even if 
they weren't explicitly in the same program. Embedded extensions 
and embedded REBOL code are both statically linked into the program, 
and are both dynamically linked at runtime.


Nonetheless, that system model doesn't have to matter. A published, 
official FAQ entry (or even a blog post) can be used as evidence 
in a trial, so a FAQ entry that clearly states that all bundled native 
and mezzanine code is "part of the interpreter" would be sufficient 
to make it so our scripts whouldn't be affected by R3's GPL at runtime. 
Without such a FAQ entry it could be plausibly argued in court that 
your code is dynamically linked to GPL'd code, which would then extend 
GPL requirements to your code. With the FAQ entry, it's unambiguous.

I would prefer a licensing model that has that FAQ above, saying 
that the built-in functions are "part of the interpreter", but to 
also have all R3 mezzanine code covered by the MIT license rather 
than the GPL. GPL'd code, even if you're allowed to link to it, is 
still unsafe to read for a lot of people, since it can be (and has 
successfully been) argued in court that similar code that you write 
later can be considered a derived work. One of the best ways to learn 
REBOL is the SOURCE and HELP functions, so MIT source and help strings 
would make SOURCE at least safe to use. SOURCE doesn't show native 
source, so that's fine (though with the source on Github you might 
be able to make a native source function using BROWSE).

if you have to think this much when deciding to use a tool or not, 
I would guess many (most?) would probably pass. Too many nuances 
and interpretations...

'or we could get a FAQ entry declaring that the functions built into 
R3 are "part of the interpreter" rather than "library code"' - that 
is where I do agree with you, except for the fact that we do have 
such an indication:


1) the functions *are physically/* part of the interpreter, they 
are "linked into it" (I would say "statically", since the interpreter 
does not need to look for them "elsewhere in the system", they are 
"inside")

2) the functions are a part of the interpreter, the interpreter documentation 
specifically mentions the functionality of the interpreter (the documentation 
mentions that the "ordinary version" of the interpreter "understands" 
FUNC, DO, PARSE, whatnot...)

If you choose to use GPL'd mezzanines in your program, you must release 
your program in a GPL-compatible way.

 - you can do whatever you want, I think I explained what I can do

Moreover, Carl could explicitly allow encapping when the restrictions 
he already stated somewhere are fulfilled. Essentially, the restrictions 
are that the encapped program shall not be a derived version of the 
interpreter.

(i.e. a program that interprets REBOL code entered by the user, etc.)

The `double j = 1.0. + 1.0` example is another bad one, sorry. It 
won't result in GCC runtime code being statically linked into the 
binary generated from a user program. But I will let that discussion 
rest, as it won't lead us anywhere.

Again, how a GPL library is linked to _the interpreter_ is irrelevant 
for deciding wether it encumbers a _user program_. If your _user 
program_ dynamically links to that library, the user program is affected 
by the GPL. It is irrelevant wether that library was statically or 
dynamically linked to the _interpreter_.

The argument that we (paraphrasing) "have the source to the mezzanines" 
already is of course a very practical one. However, it only works 
as long as those mezzanines don't experience GPL-only changes.

In the official statements that refer to the versions of R3 that 
have the current system model (approx. the last dozen versions), 
the functions included with R3 are referred to as the "Runtime Library". 
The other online docs haven't been updated to reflect the current 
system model, and most of them haven't even been updated for R3 yet, 
still referring to their R2 behavior. There are indications either 
way, enough to drive a trial through. We need an unambiguous published 
statement to be sure we won't be sued for using R3, or that at least 
such suits will fail.

Andreas, there is apparently a difference between code/data that 
is considered to be part of the interpreter and code/data that is 
considered to be part of the runtime library, according to this FAQ: 
http://www.gnu.org/licenses/gpl-faq.html#IfInterpreterIsGPL

Ladislav is stating that being statically linked makes it part of 
the interpreter, though there are counter-examples of statically 
linked runtime libraries in other programming languages that legally 
infect the code they run. It is considered bad form though, so you 
don't see it often. It's an ambiguous situation, so a statement resolving 
the ambiguity would be helpful here.

Agreed, though it doesn't matter whether the library is interpreted 
either. You can statically link a native library to the interpreter 
for use by interpreted or native code, and it can legally affect 
the code that is using it. The only way around it is to declare that 
code to be part of the interpreter rather than part of the runtime 
library, which can only be done with permission of the rights-holder 
of that code.

Given that this is not how REBOL actually works, declaring it to 
be a monolithic interpreter would be more of a legal declaration 
to not sue. Such a declaration would also affect REBOL script code 
that dynamically loads extensions, not just REBOL code.

Right, it has changed quite a lot since it has become Thom's personal 
blog...

this was a fresh VM - nothing else installed

when you create the disk, there's an option to pre-allocate it - 
I chose that (the size had was a 1 GB disk). Not sure if that would 
make a difference as to how small it would compress

Skydrive needs a Live ID to download a publicly shared file? That's 
hilarious. I should buy Dropbox shares (if I had the money). :-)

I can try again with a disk that is not pre-allocated

Qtask also needs cookies to get into a public file listing

Waited a minute, watched ads, says download will take 61 minutes, 
answered captcha, got popup ads, chose downloading, get same popup 
ad over and over, no download

I was just wondering how I can get a popup. Firefox is supposed to 
block them, but they put them under the download button

what I see when I click there is a countdown timer

give me a place to upload to and I'll stick it there - you can then 
figure out what you want to do

I got no popups after the countdown - there was a captcha and then 
a button to download

i think i have a qemu/kvm image from back when syllable desktop 0.6.7 
was released. if that's of any use, i can dig it up.

Thanks, but a QEmu image is less problematic for me to produce, because 
we have it in Syllable

ok. just had a quick look, the qemu-generated .vmdk i have is 441MB 
uncompressed, and 79MB after 7z -mx=9.

That's better than expected. Maybe indeed a new 7-Zip version

No idea, sorry. I was just wondering why I created the image as a 
.vmdk, but well -- at least that seems to compress quite well.

hard to see why there's such a difference then

here's a link on google drive - supposedly anyone with the link can 
access with no login

Yeah, but this is a big file, and it's going to be downloaded many 
times

The hosting is not the point, though. I can host files, but if it's 
an official Syllable release, I should have done all the quality 
control and it should be in all the usual places, such as SourceForge. 
If it's a contribution, the hosting should also be contributed to 
make that clear, and I can just link to it

up to you - if you need it to idemnify yourself, go ahead - personally, 
I don't need to see a credit with the link

Not for indemnification, just for credit. It's a volunteer project, 
after all

Syllable versions have been downloaded several ten thousand times 
per version. If a version is current for a long time, the VM image 
could be downloaded twenty thousand times, for example

sure, if it's that many individual downloads per version, that's 
quite a good number

So it's a bit of a mystery. The forum indeed doesn't reflect it, 
but there also other reasons for that. It's been hard to register 
there for years, because we've had to block most common mail domains 
due to spam

From many places, I think. We have a decade of publications all over 
the web

I wonder if it can be hosted on glacier .. then it would only take 
a few days to download :)

R3 has been included in Syllable Desktop for a year and a half. Syllable 
Server ships with R2 and a collection of REBOL frameworks

Yes, I wanted to do that even before EC2 opened up, to get a business 
model going. But regardless of their promises, after all these years 
they still don't support their payment system outside the US

All you need is a US bank account

but that is difficult to obtain if you're not a citizen

And that will get you all the trouble of running a US company