AltME groups: search

The only value for which this is not equivalent is 0, but that's 
an invalid index, anyway

So the correct version of Doc's solution is even shorter:

head-index?: 
func [s [series!] i [integer!]] [index? at s i]
 - wrong again

(what is interesting is the fact that when you rely on this, you 
get 
kicked in the butt" like Carl was)"


I respectfully disagree. :-) You are right in that my proposition 
doesn't exactly match the requirements, because the requirements 
imply a 0-based reference that I've missed. So, here's a corrected 
version that matches your requirements:


    head-index?: func [s [series!] i [integer!]][(index? skip s i) - 
    1]


I am probably too influenced by the way Carl designed R2, but I still 
think that a 1-based index system has value. (Let's save the 0-based 
vs 1-based debate for another day)

Another incorrect version:


head-index?: func [s [series!] i [integer!]][(index? skip s i) - 
1]

Re "influenced by Carl" - I think that it is good to strive for simplicity, 
however, indexing is not simple when index arithmetic does not work

To avoid having to use to-logic when using refinements to pick a 
value in a series. For example:

In REBOL:
    foo: func [/only][pick [1 2] only]
    foo

    ** Script Error: pick expected index argument of type: number logic 
    pair
    ** Near: pick [1 2] ref

In Red: it should return 2.

Forgot also to mention that PICK and POKE now accept logic! value 
as index.

Kaj, now that I've had a chance to do some work with Red/System, 
it's amazing to me how much work you've already done on adding features!


Here's something that I think would really help out a lot of us who 
want to make use of all your hard work.  Would it be hard to create 
http://red.esperconsultancy.nl/index.htmlwith a link to all the 
Red stuff you've done?  The only way I found what I needed to download 
was by searching through AltME for links, and had to manually enter 
in things like Red-common, Red-C-library, Red-cURL, Red-GTK, etc.

cycle: func ["Cycle a series through its index."
	'series [word!]
	/local s
][
	either tail? s: get series [
		set series  next head s
		first head s
	][
		set series  next s
		s/1
	]
]

; JS-like MAP. The order of args to the function is a bit odd, but 
is set

; up that way because we always want at least the value (if your 
func takes

; only one arg), the next most useful arg is the index, as you may 
display

; progress, and the series is there to give you complete control 
and match

; how JS does it. Now, should the series value be passed as the head 
of the
; series, or the current index, using AT?
map-js: func [

 "Evaluates a function for each value(s) in a series and returns the 
 results."
	series [series!]

 fn [function!] "Function to perform on each value; called with value, 
 index, and series args"
	/only "Insert block types as single values"
	/skip "Treat the series as fixed size records"
		size [integer!]
][
	collect [

  repeat i length? series [   ; use FORSKIP if we want to support /SKIP.
			keep/only fn series/:i :i :series ; :size ?
		]
	]
]
;res: map-js [1 2 3 a b c #d #e #f] :form
;res: map-js [1 2 3 a b c #d #e #f] func [v i] [reduce [i v]]
;res: map-js [1 2 3 a b c #d #e #f] func [v i s] [reduce [i v s]]
;res: map-js "Hello World!" func [v i s] [pick s i]

@arrayproposal: I really like the index to run from 1 to 10 and not 
from 0 to 9. I suspect this is because I happen to be a human-being 
not a computer. Maybe I could live with this different in Red (1 
- 10) and Red/System (0 - 9), because Red is higher level and Red/System 
being low level, but that might be confusing too.

Idiom I long time wanted - to [a | b] might be more expensive imo, 
as it will do incremental searches, evaluate the lower index and 
apply the rule. Whereas recursive [a | b | skip rule] will skip one 
positition at a time, trying to match rules .... or that is how I 
imagine the difference :-)

Thanks for the compliment Doc, not really sure what you mean exactly 
by making it more like Red/System and less C: use more descriptive 
names? I will take a closer look at some ed/System examples out there.

Thanks Kaj for finding those and for the tips, the size of MM makes 
it the same in effect in this case, but it has to be <= then. Program 
not crashing, I was lucky then! off-by-one errors? My index goes 
from 1 up, where in C it is from 0 up, I had to debug this to make 
sure elements were swapped in the same way as in the original program. 
That is also why I declare KKP and LLP to as to save from adding 
1 to KK and LL over and over again. 


Knuth's algorythm was the first one I found, and I knew already of 
its existence, so it made sense to use what you have. Sure my Red/System 
code is not optimised.


Going to work on it now and tomorrow, and later I take on the Twister. 
It is a good exercise!

The deobfuscating Knuth's random program project is progressing into 
its final stage. It turned out that with getting the results of the 
program the same only the first part of the puzzle got solved. To 
use it in real programs you use the provided ran_arr_next function. 
This involved some pointer aritmetic that is not 100%  supported 
by Red/System. I finally got the function to produce the same results 
as the C version. The downside is it is now quite a mess with pointer 
indeces and other variables, so a lot of cleaning up to do and/or 
rework only using the index on the array approach.

One bug need to mention:

After doing mod operation, I use the result as index to access the 
array,it's OK in C, but will cause strange behavior in Red/System. 
Because mod will produce 0 and Red/System use 1-base array.
n: c + state-half-size % state-size
Then I modified the code as below to solve this issue:
n: c - 1 + state-half-size % state-size + 1

[...] the next step in bringing Red/System to 0-based is having Red 
being 0-based as well?


No, it's not directly related. Implementing low-level algorithms 
that require working with index 0 is not the common usage of Red. 
Also, the +/-1 offset required in such case has no noticeable performance 
impact in a Red program while in Red/System, in a tight nested loop, 
the impact could be significant.


The most important part in considering a 0-based indexing system 
for Red/System is mainly helping the user and avoiding common programming 
errors (even I get caught by it from time to time, but it's probably 
due to my strong C background).

Bo, yes, that would be more efficient, because you can then index 
with 1

Remember that a c-string! is a pointer to a memory address. Much 
like a string! in REBOL is a reference to the storage of a series 
value that can be referenced by multiple string!s, each with their 
own index

(Although, it would be nice to have an index page...but not necessary.)

The central website is planned to become the index page. Until then, 
the index is in the download.r

Red/System: Could it be that if you 
#define MAX-SIZE 100
my-array: as int-ptr! allocate MAX-SIZE * size? integer!
then using  
my-array/MAX-SIZE 
gives a compilation error??
*** Compilation Error: undefined pointer index variable

I wrote an example of a browser for Internet sites written in Red. 
The source code is here:


http://red.esperconsultancy.nl/Red-GTK/doc/trunk/examples/GTK-browser.red


The usage model is like a web browser. You point it to network or 
local file links, in an address bar or as a command line parameter, 
and it displays them in the same content area in one window. A Red 
page can contain links that make the browser go to another page.


You can create and roll out Red sites just like websites. We are 
hosting the first Redsite here:

http://red.esperconsultancy.nl/index.red

I upgraded the Fossil server for the Red bindings to the new version 
1.25. There are some nice new features in it:

http://www.fossil-scm.org/download.html

They also have a new short introduction guide:


http://www.fossil-scm.org/index.html/doc/trunk/www/fiveminutes.wiki

I adapted four of the Red GTK examples to run in the Red browser. 
They are now pages on our Redsite, with links listed on the front 
page:

http://red.esperconsultancy.nl/index.red


You can view/run them without compiling or even installing them, 
from the above Red browser program.

I updated our Redsite for the latest Red features, specifically runtime 
function creation in the interpreter (which executes the Redpages):

http://red.esperconsultancy.nl/index.red

I added a simple IDE example to the list of apps:

http://red.esperconsultancy.nl/examples/IDE.red


It's a cross between the standalone GTK-IDE example and Try REBOL; 
basically Try Red written in Red itself. There are two main areas: 
one for editing your code and one for showing the result. Since it 
runs on your computer, unlike Try REBOL, it keeps state between execution 
of code snippets.


To browse the site and the apps you need the latest binary version 
of the GTK-browser. See above.

Now that */Red/GTK-browser in the test executables has been updated 
for the Red 0.3.2 release (and the features and fixes since then), 
I have updated our Redsite to match:

http://red.esperconsultancy.nl/index.red


All listed Redpages and apps work now, and several details have been 
smoothened out.

If you intend http://www.rebol.net/wiki/Main_Pageon  www.rebol.net 
is wrote to not use it, because is the "old" wiki. The new wiki should 
be http://www.rebol.com/r3/docs/index.htmlbut it's closed to new 
authors, and there isn't any new contributon for years.  

On the other side all rebol developers work on GitHub, so it''s all 
ready to use.

Pekr: the `hello` symbol exported to R3 is mapped to index 0 in RX_Call, 
so from there you can map it to `do-hello` or whatever Red function 
you want, no bug there.

http://www.fltk.org/doc-2.0/html/index.html

>> help copy
USAGE:
    COPY value /part range /deep


So, copy/part takes two parameters:  (1) the start index, and (2) 
the range


If you rewrite the copy/part like I did below, it is much easier 
to see how it is split up:

copy/part
	tail form idx	;parameter 1
	-1		;parameter 2

Neither INSERT nor APPEND modify the index attribute of their argument 
(the index attribute of series is immutable, in fact)

Having a series with index 1 (the head has this index), neither INSERT 
nor APPEND can change the index of the series. What they do is something 
else - they return a series with a different index.

To illustrate this further, let's consider a trivial example:

    a: 1
    b: 2

    add a b ; == 2


You can examine A and B now and see that the ADD function did not 
change A or B, but it returned 2 (another value). Similarly, INSERT 
does modify the argument series, but not its index, however it returns 
a series with a different index.

hmm, I just tried for i 1 str 1, and it screams ... but maybe if 
given the same type, a string for e.g., maybe it takes their index 
value?

you have more than one solution, the first is a simple serial SELECT 
on each table -> compare the output for equal.

of course this produce unnecessary DB overhead but I guess you won't 
feel any speed difference except you are

serving a whole city concurrently. another, better one is a JOIN 
or UNION.

SELECT table_name1.column_name(s), ...
FROM table_name1
LEFT JOIN table_name2
ON table_name1.column_name=table_name2.column_name


the JOIN direction (LEFT,RIGHT,INNER) for your reference table is 
important here. 

the resultset is a table containing BOTH columns. if both having 
a value -> match, if one is empty then you don't.


index both fields to accelerate the query and use something like 
the free SQLyog 
to test different queries to make debugging easier for you.


while you situation reminds me to myself, sitting infront of a monochrom 
asthon tate dot some decades ago

and asking what next?, you should 'bite' yourself now thru the rest. 
It won't help you on longterm if you don't.

The http://www.rebol.com/r3/docs/index.htmlwiki is not good, you 
can't register or edit.... :-(

MaxV: "The http://www.rebol.com/r3/docs/index.htmlwiki is not good, 
you can't register or edit.... :-( " - that is actually not true. 
You *can* register if you want, just say so in here.

>> write http://www.rebol.com/index.html[ HEAD ]
== [%/index.html 7407 none]

>> write http://www.rebol.com/index.html[ HEAD ]
make object! [
    name: none
    size: none
    date: none
    type: 'file
    response-line: "HTTP/1.1 200 OK"
    response-parsed: none
    headers: make object! [
        Content-Length: "7407"
        Transfer-Encoding: none
        Last-Modified: "Sat, 15 Dec 2012 07:02:21 GMT"
        Date: "Wed, 09 Jan 2013 09:24:53 GMT"
        Server: "Apache"
        Accept-Ranges: "bytes"
        Content-Type: "text/html"
        Via: "1.1 BC5-ACLD"
        Connection: "close"
    ]
]

Cool. So --assume-unchanged helps :)

git update-index --assume-unchanged make/makefile

I think that we have two conflicting values here:

* Do what I *say*, since you can't read my mind to know what I mean

* Trigger errors when you run into something almost definitely wrong 
as a favor to the developer


In the case of FOREACH, it triggers an error for an empty words block 
and doesn't allow none because that block is part of the control 
structure, not the data (which we do allow empty or none for). In 
the case of a block of only set-words, that also doesn't really advance, 
but at least you get a reference to the series so you could in theory 
be doing something (that you should probably use WHILE to do instead), 
so not triggering an error in that case is iffy, you could make an 
argument either way.


For FOR, the main factor for whether the loop would normally end 
(without BREAK or changing the index manually somehow) is whether 
the step > 0 if start < end, or step < 0 if start > end. So it's 
not whether it = 0.

Right. One thing we need to consider is whether we want changes to 
the index in the code block to affect the index of the loop, or whether 
we just want to do that with BREAK. There are advantages to either 
model. If manual changes to the index are ignored, it becomes safe 
to change in your code. If they aren't ignored, it becomes another 
way to affect the loop in your code.

While I think it's a bad idea to mess with the index, there are reasons 
to allow it. I think manual changes should be allowed, but discouraged.

So the question we're posing is whether we want the developer to 
be able to manually affect the FOR loop process from the inside (a 
feature, useful for advanced developers), or whether we want the 
loop process to be inviolate regardless of changes to the index in 
the code (another feature, useful for compilers that might want to 
unroll loops). Given that we don't have a compiler, that suggests 
that affecting it might be a useful feature, but Red compatibility 
and the overhead of checking the index value rather than just setting 
it based on an internal value in native code suggests that the latter 
might be better. There is no point in discouraging anything, since 
there is so much overhead to allowing it at all that we should only 
do so to provide a feature explicitly.

If you have the loop process inviolate then you can use a C value 
or even a raw value slot as an internal loop counter. If you want 
changes to the index in the code to persist, the loop would need 
to check that word after the loop cycle ends to determine its current 
value, then change that. That has overhead, like checking for and 
reacting to unset values, that just ignoring the word's value doesn't 
have. So if we want to allow it at all, it shouldn't be discouraged 
except as a potential gotcha, it should be considered a feature.

in languages like C  the for loop is the basic iterator and it should 
be completely open.   but in REBOL we do have a lot of purpose-built 
iterators, I think FOR shoudn't allow non advancing steps and should't 
allow the inner loop to affect index.   This would make FOR faster 
for its primary purpose.  


I don't see the point in trying to make every different iterator 
another interface to while/until

Do we have enough factors to make some tests and tickets for FOR? 
I'm not sure whether we came to an agreement about the changing index 
issue, so that might be worth an issue ticket (assuming this conversation 
will disappear because we're in AltME, not CureCode).

I can make the tickets later today - it just looks like two, one 
for step, one for index-changing.

Well, FOR isn't a general loop like in C, it's just an iterator. 
If we need a general loop we should add one, even though general 
loops are more expensive to use in interpreted languages than specific 
loops (which is why we have specific loops rather than one general 
loop). However, "I want to skip x values ahead" does sound like an 
argument for allowing index changes to affect the looping process, 
as a power-user feature.

Ticket for the FOR stepping behavior: http://issue.cc/r3/1993. The 
FOR index modification behavior will be a separate ticket, since 
while they'll likely need to be implemented at the same time, they 
need to be discussed separately.

PICK for series just means the index, or something that can be translated 
into an index like logic is.

'However, "I want to skip x values ahead" does sound like an argument 
for allowing index changes to affect the looping process, as a power-user 
feature.' - agreed, it may be convenient when the user needs such 
a feature

Ladislav, in answer to your first question about "We should allow 
one iteration when start = end, but trigger an error otherwise if 
we have a non-advancing step.", yes. That is the difference between 
the two models in that ticket. 0 bump should behave consistently, 
according to a model which makes sense.


In one of those models, the bump is given primacy over the start-vs-end 
factor, and judged *on its own* a bump of 0 is an error (since it 
doesn't make FOR advance in one or the other direction). So, that 
error should be triggered categorically before the range is even 
considered.


If, on the other hand, start-vs-end is given primacy, then we have 
3 valid answers to the direction argument: forwards, backwards, or 
once - the bump argument doesn't determine direction, it determines 
velocity in the direction already chosen. In the start=end case the 
bump is always ignored, so ignoring it for 0 makes sense. In the 
start<end or start>end cases, a bump of 0 is basically out of range 
because those cases are only defined  to move in the positive or 
negative direction, respectively. That means that start<end is only 
positive, and start>end is only negative.


Does that make the difference between the models clear? Of course, 
because you can BREAK, CONTINUE, or even set the index position in 
the code, that doesn't actually reduce our flexibility where we really 
want to do anything interesting. It just makes the basic model make 
sense.

OK, so the important question which you are glossing over by going 
on about termination tests is: Can any combination of start, end 
and bump result in an infinite loop without changing the index explicitly 
in the body block? Because that is what we need to make sure *never* 
happens.

for i 1 2 1 [i: 1]

That is changing the index in the body block. That is assumed to 
be intentional.

Once you get past the initial conditions then everything after that 
is affected by the direction, the bump and the code block. But we 
have to assume that start, end and bump could have come from the 
result of a possible erroneous calculation based on crappy data. 
The initial conditions guard against that. Ladislav, every code example 
you give that sets the index in the code block is considered intentional 
behavior. It is only start, end and bump that are considered possible 
out of the developer's control. If a developer passes an unknown 
code block to FOR then they deserve what they get.

every code example you give that sets the index in the code block 
is considered intentional behavior.

 - what behaviour? (I do know what shall happen having specified it, 
 but what shall happen according to your arbitrary rules and why?)

Um, no, because it doesn't handle the problem of making sure that 
accidental infinite loops aren't screened for. The termination condition 
that would be affected by bump=0 in your model could also be affected 
by index changes in the body. Everything in the body is considered 
intentional. So, you are lumping in presumed-intentional infinite 
looping with presumed-unintentional infinite looping. It's the same 
reason why FOREACH [] data body triggers an error, but FOREACH [a:] 
data body doesn't.

For instance, you might noting that FOR has a lit-word parameter 
for its index. That makes the word peovided considered intentional, 
because you have to do an extra step to not know which word was provided. 
And in general, people are presumed to know where they get their 
code blocks from.

In the constrained #1993 FOR, the constraint is a feature. It will 
protect you from infinite loops that you don't intend, regardless 
of what start, end and bump say. You would have to go out of your 
way to make an infinite loop, by setting the index in code that you 
wrote. That way, you know you can safely call FOR when you don't 
even know what start, end and bump are.

FOREVER is assumed to be a solicited-for infinite loop, because it's 
right there in the name. #864 is assumed to be whatever the developer 
says, because "General loop" is right there in the doc string. #1993-1994 
FOR has the *feature* of not *accidentally* being infinite for any 
value of start, end and bump, its constraint is a feature; of course 
it could be *intentionally* infinite by changing the index in the 
code block, but that just means that there is one parameter that 
the developer would have to be careful about, the body block, and 
since that is a general pattern throughout R3 they would be doing 
that anyway.

We can just arbitrarily declare that we want 0 velocity to be considered 
out of range, as a favor to the developer, and the velocity explanation 
gives us a good excuse to not trigger an error. FOREVER existing 
means that they have other options, and index setting means that 
they can do whatever they want if they really want to, so it's not 
actually a constraint if they don't want it to be.

Gress, for the start-vs-end-sets-direction bump-is-velocity model:

* start=end means no direction so just loop until the =end termination 
condition is met and ignore bump. If the index gets changed in the 
body block, let the =end termination condition handle it.

* start<end means positive direction, for values of "positive" that 
don't include 0, so bump <= 0 is out of range, meaning no loop. The 
termination condition *if we start looping* is >= end.

* start>end means negative direction, for values of "negative" that 
don't include 0, so bump >= 0 is out of range, meaning no loop. The 
termination condition *if we start looping* is >= start.


Positive and negative directions don't include 0 because if the developer 
wanted to do an infinite loop they would have used FOREVER or R3's 
#864 FOR general loop. R2 was aimed at newbies, and they need extra 
coddling.

* start=end means no direction so just loop until the =end termination 
condition is met and ignore bump. If the index gets changed in the 
body block, let the =end termination condition handle it.

 - that is not reasonable for BUMP = 0 (no consistent termination 
 condition can be defined for that), also, the termination condition 
 should be VALUE <> END in this case if you want to be consistent

Let's widen the discussion a bit. Spitting a string at a delimiter. 
Easy enough to define clear behavior if the series contains the delimiter, 
but what if it doesn't? Most split funcs return an array, splitting 
at each dlm. If no dlm, return the original series as the only element 
in that array. 


What if we always want to return two elements? e.g., we have a SPLIT-AT 
func that can split a series into two parts, given either an integer 
index or value to match. Let's also give it a /LAST refinement, so 
it can split at the last matching value found, like FIND/LAST works. 


Given that, what do you expect in the case where the dlm (e.g. "=") 
is not in the series?

    SPLIT-AT "abcdef" "="   == [? ?]
    SPLIT-AT/LAST "abcdef" "="    == [? ?]

The problem is, that while the R3-GUI is now more flexible by removing 
reactors, it is also more difficult to understand. I remember trying 
to understand the 'on-action issue in the past, now I briefly re-read 
the doc, and I still can't understand the design. I need following 
things to be cleared up for me, so that I can both use it, and possibly 
explain it to others:


1) If you look into Actors docs - http://development.saphirion.com/rebol/r3gui/actors/index.shtml#
, there is no mention of 'on-action actors. There are many actors 
listed, but not the 'on action one


2) The 'on-action actor is mentioned in the attached doc at the same 
URL, describing, why reactors were removed. So here is the definition 
of 'on-action: 

        a) "The ON-ACTION actor is useful if the style needs to call some 
        default action from multiple places (actors) in the style definition." 
        - understand the purpose, but why and when I would like to do such 
        thing? Any example easy to understand? Just one sentence maybe?

        b) "For example, the BUTTON style needs to call the default style 
        action from the ON-KEY actor and also from the ON-CLICK actor, so 
        it is better to call the ON-ACTION actor from the both code points 
        to avoid the necessity to override multiple style actors." - looking 
        at button or even clicker style definition, I can see no such stuff, 
        as 'on-key or 'on-click calling anything named 'on-action. That is 
        the part that is most confusing for me, and which did not help to 
        understand the 'on-action a little bit. Are we talking about the 
        'do-face here?


There is also a question, if better name could be found for 'on-action. 
Unless I can fully understand, what happens here, difficult to suggest. 
Now to make it clear - I am not judging architecture, just trying 
to get my head around the docs and button/style examples. And being 
average reboller - if I have difficulcy to understand it, the chances 
are, there is more ppl, which will strugle in that area?

Is the "index" field of REBGBO presently used?

http://www.linuxnetworks.de/doc/index.php/OpenDBX
http://sqlapi.com/
http://sqlrelay.sourceforge.net/about.html

This is a periodic posting of community links along with activity 
levels for discussion dedicated to Rebol and Rebol-like languages. 
The intent is to bring a dispersed community together by providing 
the current list of places where the community gathers along with 
reasonably accurate activity indicators for each place. This list 
will be posted in each location weekly or bi-weekly so that anyone 
dropping by will not have to look far in order to learn where else 
things are happening.


Currently the activity stats are gathered manually and postings are 
also not automated. This will hopefully change as the requisite scripts 
to scrape and post automatically are developed. This updated list 
will eventually be available at http://rebol.comas the site is cleaned 
up post Rebol open sourcing. 


# Chats

## R3 Chat

This is the primary forum for Rebol 3.0. It runs from any Rebol console 
in a text mode, but a GUI version is planned.
- Run R3, type chat and follow the instructions (all platforms.)

- Type "help" for more information or visit R3 DevBase Chat Forum 
(http://www.rebol.com/r3/devbase/index.html).

- To view public messages from any web browser go to RebDev mobile/phone 
interface (http://www.rebol.net/cgi-bin/rebdev-web.r).

- Problems? Please contact Rebol Technologies at (http://www.rebol.com/cgi-bin/feedback/post2.r).
Activity: 4 messages this month


## Rebol chat on Stack Overflow (http://chat.stackoverflow.com/rooms/291/rebol)

- Note that you will need a reputation of 20 in order to be able 
to post in the chat. 

- You can gain this minimal reputation (essentially a spam filter) 
by participating in the Stack Overflow group of sites. 
Activity: 380 messages this week


## AltME Worlds

A private instant messaging system where rebolers hang out 24/7. 
The current world dedicated to Rebol and Rebol-like language discussion 
is called REBOL4
- Get client at http://www.altme.com/download.html
- connect to the 'rebol-gate' world with user/pass, guest/guest
- request account on REBOL4 world in the REBOL4 request group

Web archives of public groups, first to last in the most active world, 
REBOL4, as well as the dormant world, REBOL3:
REBOL4 (http://www.rebol.org/aga-groups-index.r?world=r4wp)
Activity: 286 posts last 6 days
REBOL3 (http://www.rebol.org/aga-groups-index.r?world=r3wp)


# Forums

## Rebol Facebook group (http://www.facebook.com/groups/rebol)
A new special interest group for Facebook users.
Activity: 26 messages this month



## Rebol Google+ community (https://plus.google.com/communities/100845931109002755204)
Activity: 4 messages this month



## Rebol Google Group (https://groups.google.com/forum/?fromgroups#!forum/rebol)
Activity: 43 messages this month



## Synapse EHR Rebol Forum (http://synapse-ehr.com/community/forums/rebol.5)
A web-based forum for R2 and R3, provided by Synapse EHR
Activity: 13 messages this month



## RebelBB France (http://www.digicamsoft.com/cgi-bin/rebelBB.cgi)
A simple forum, written in Rebol, for French speakers.
Activity: 140 messages this month


## Nick's Rebol Forum (http://rebolforum.com/index.cgi)

A micro-forum (just a few lines of Rebol) hosted by Nick Antonaccio. 
(Note: the captcha question is first.)
Activity: 79 messages this month


# Q&A (Question & Answer)

## Stack Overflow questions on Rebol
http://stackoverflow.com/questions/tagged/rebol
Activity: 219 questions tagged
http://stackoverflow.com/questions/tagged/rebol3
Activity: 2 questions tagged

That was deliberate -- multiple searches may be clutter up the page.

On the other hand, they may not --- I've put them back, so you can 
compare:
http://www.rebol.org/cgi-bin/cgiwrap/rebol/index.r

I've got all these in my public cache:
proton.cl-ki.uni-osnabrueck.de/fuzzy-k-means.r
proton.cl-ki.uni-osnabrueck.de/html-viewer/html-viewer.r
proton.cl-ki.uni-osnabrueck.de/REBOL/fx5-menu.r
proton.cl-ki.uni-osnabrueck.de/REBOL/fx5-request-file.r
proton.cl-ki.uni-osnabrueck.de/REBOL/fx5-styles-test.r
proton.cl-ki.uni-osnabrueck.de/REBOL/fx5-styles.r
proton.cl-ki.uni-osnabrueck.de/REBOL/irc-client.r
proton.cl-ki.uni-osnabrueck.de/REBOL/morph.r
proton.cl-ki.uni-osnabrueck.de/REBOL/morph2.r
proton.cl-ki.uni-osnabrueck.de/REBOL/multi-click.r
proton.cl-ki.uni-osnabrueck.de/REBOL/rebsearch.r
proton.cl-ki.uni-osnabrueck.de/REBOL/regedit.r
proton.cl-ki.uni-osnabrueck.de/REBOL/rsearch.r
proton.cl-ki.uni-osnabrueck.de/REBOL/view-menu-test.r
proton.cl-ki.uni-osnabrueck.de/soft/function-test.r
proton.cl-ki.uni-osnabrueck.de/soft/fuzzy-pats.r
proton.cl-ki.uni-osnabrueck.de/soft/fuzzy-show.r
users.bigpond.net.au/datababies/Anton/rebol/links/index.r
www-lehre.inf.uos.de/~fsievert/rebol/newshow.r
www.sievertsen.de/index.r
www.sievertsen.de/REBOL/REBtroids.r
www.sievertsen.de/REBOL/REBtris/REBtris.r

Unfortunately, the library apparently doesn't have an index that 
would be condusive to such a search.  Oh well.  Wishful thinking...

Did you try the topic index -- it's intended to categorise what a 
thread is about rather than what words it contains:
http://www.rebol.org/cgi-bin/cgiwrap/rebol/ml-topic-index.r?i=p

Sunanda,  I didn't try that.  I had assumed that search would use 
that index as a key.  Is there a way to search the topic index other 
than by clicking on a letter in the alphebetical list and relying 
on the browser's find functionality?

<< Is there a way to search the topic index other than by clicking 
on a letter>>
In theory:

http://www.rebol.org/cgi-bin/cgiwrap/rebol/ml-topic-index.r?i=probe

takes you straight to the entry (if any) for 'probe.  But that looks 
broken right now....I'll look into it.


Other than that, no.  Only about 80% of the threads are indexed in 
the topic index. When we get closer to 100%. we'll enhance the existing 
search to take account of the topic index.....so results will include 
and be prioritised by the topic index. 

Well, you could try, in Google:
probe site:www.rebol.org inurl:topic

But that (as with any search anywhere) is dependent on Google having 
the page indexed.

As a result, it would be pretty tricky to index the archive.


The ideal would be for "useful threads" to be selected, tagged and 
archived. I can't see anybody being able to automate that at the 
moment.

http://thinstation.sourceforge.net/wiki/index.php/ThIndex

Damn Small Linux 2.0 released..  http://www.damnsmalllinux.org/index.html


Damn Small is small enough and smart enough to do the following things:


    * Boot from a business card CD as a live linux distribution (LiveCD)
    * Boot from a USB pen drive

    * Boot from within a host operating system (that's right, it can 
    run *inside* Windows)

    * Run very nicely from an IDE Compact Flash drive via a method we 
    call "frugal install"

    * Transform into a Debian OS with a traditional hard drive install
    * Run light enough to power a 486DX with 16MB of Ram

    * Run fully in RAM with as little as 128MB (you will be amazed at 
    how fast your computer can be!)

    * Modularly grow -- DSL is highly extendable without the need to 
    customize

Robert, you may find the right glibc rpm here: http://rpmfind.net/linux/RPM/index.html

Be sure to read about the different ones, so you get the right one.

You should be able to have more than one version of glibc installed 
at the same time (so everything will work). There are programs with 
GUIs in RedHat Linux to install rpms, or you can use the rpm command 
from the command line.

It's been a while, since I used Linux, and it can be a hazzle to 
update sometimes.

I'll have a look at the index pages.

we have looked at it and at the same time looked at phpsavant 
 http://phpsavant.com/yawiki/index.php?page=StartExample


for us, our key concerns is maintenance from the developer point 
of view. We want the team to stick to one language (or markup)... 
there will be times in a project, that you may not have the luxury 
of a designer...so the developer still end up working on the apps 
GUI (or look-n-feel).

You can see a brief overview of Remark (Maxim's site builder) here... 
http://www.rebol.it/~steel/retools/remark/index.html

just found out that Logitech does have a 'diNovo'  but the retail 
price is on the high side 

http://www.logitech.com/index.cfm/products/details/CA/EN,CRID=1,CONTENTID=7321

I've set up mediawiki at http://compkarori.com/rebolwiki/index.php/Main_Page
and will see how it goes.

Currently there's a sql error on updating or creating a page, but 
you can ignore that it seems as the page changes are made.

go here: http://www.macromedia.com/cfusion/entitlement/index.cfm?e=file_format
register and download

http://box.lebeda.ws/~hmm/rswf/index.php?example=145

hmm, should say 3, I forgot the second version of the color picker 
to upload, now it's here as well http://box.lebeda.ws/~hmm/rswf/index.php?example=148

and cannot use array[index] but must use pick array index

Yes, you're right. Up this point I was really looking at the wrong 
documentation so the Actionscript clue was helpful.


Here's an example. I haven't tried to translate it yet. It looks 
pretty straight forward. 

Movieclip.prototype.fade = function(speed) {
this.speed = speed;
this.f_index = this._alpha;
if(this.f_index >= 100) this.fade_by = -this.speed;
if(this.f_index <= 0) this.fade_by = this.speed;

this._alpha += this.fade_by;
}

Or you can use these to fadeIn() or fadeOut()


Movieclip.prototype.fadeOut = function($decrement, $fadeLimit){



	var $mcObject = this;

	//If $decrement is not defined, then define it

	if($decrement == undefined){

		var $decrement = 11;

	}//End if



	if($fadeLimit == undefined){

		var $fadeLimit = 0;

	}//End if



	if(eval($mcObject)._alpha < $fadeLimit){

		return(true);

	} else {

		eval($mcObject)._alpha -= $decrement;

	}//End if



}//End function

Movieclip.prototype.fade: func[speed][
	this.speed: speed
	this.f_index: this._alpha
	if this.f_index >= 100 [ this.fade_by: 0 - this.speed]
	if this.f_index <= 0   [ this.fade_by: this.speed]
	this._alpha: this._alpha + this.fade_by;
]

Movieclip.prototype.fade: func[speed][
	this.speed: speed
	tellTarget this [
		f_index: _alpha
		if f_index >= 100 [ fade_by: 0 - speed]
		if f_index <= 0   [ fade_by: speed]
		_alpha: _alpha + fade_by
	]
]

And here is new example again: http://box.lebeda.ws/~hmm/rswf/index.php?example=155
 using precompiled tweening prototype

http://box.lebeda.ws/~hmm/rswf/index.php?example=158

just found that the movies for this example http://box.lebeda.ws/~hmm/rswf/index.php?example=116
were missing - in the movie in the middle are czech soldiers on acid 
and the rest are the same chinese soldiers preparing to watch atomic 
explosion.

framTo tweening: http://box.lebeda.ws/~hmm/rswf/index.php?example=159

Organic window: http://box.lebeda.ws/~hmm/rswf/index.php?example=160

I've added an experiment with the Flash's security model http://box.lebeda.ws/~hmm/rswf/index.php?example=161
(there is added new tag so update your rswf dialect from the page) 
I'm not sure if it's working, but it should because it produces the 
same thing as this Macromedia's tool http://www.macromedia.com/support/flashplayer/downloads.html#lcu

I've just updated the dialect to be able override the default settings 
for maximum recursion depth and ActionScript time-out: http://box.lebeda.ws/~hmm/rswf/index.php?example=162

is there a new way to embed the plugin? http://www.rebol.net/plugin/demos/index.html
doesn't work

Pekr: There's a lot of competing templating solutions, and AFAIK, 
XML+XSL is the most used one. You can also look at Enhydra XMLC here 
: http://www.enhydra.org/tech/xmlc/index.html(It's done with JSP, 
but the concept can be easily ported to any other language).