AltME groups: search

Those libraries might be good for inspiration - their code is MIT/BSD, 
cross-platform, documented limitations, etc. But I agree. I simply 
want event port being just another kind of ports, funcitoning as 
a kind of seris - lookup, traversla, sort, filtering, etc :-)

https://github.com/dockimbel/Red/issues?sort=created&direction=desc&state=open

Red: I'm still working on both the compiler and the minimal runtime 
required to run simple Red programs. I have only the very basic datatypes 
working for now, no objects (so no ports) yet. I not yet at the point 
where I can give an accurate ETA for the first alpha, but I hope 
to be able to provide that ETA in a week.


Red string! datatype will support Unicode (UTF-8 and UTF-16 encoding 
internally). I haven't implemented Unicode yet, so if some of you 
are willing to provide efficient code for supporting Unicode, that 
would greatly speedup Red progress. 

The following functions would be needed (coded in Red/System):

- UTF-8 <=> UTF-16 LE conversion routines

- (by order of importance) length?, compare (two strings), compare-case, 
pick, poke, at, find, find-case
- optinally: uppercase, lowercase, sort


All the above functions should be coded both for UTF-8 and UTF-16 
LE.

Can Red/System code be included yet, so the new platform can be sort 
of tested as a shell for Red/System programs?

quick-test has been broken by one of the last 13 commits in branch 
v0.3.0. I'll try to sort it out over the weekend.

But - sort your priorities yourself, no reason to get distracted 
....

Marco: besides coding in Red/System, I don't see what you could do 
currently to speed it up. Here are some ideas for the additional 
coding that will need to be done:


You can write in Red/System some of the non-trivial natives, like 
e.g. set natives: sort, union, intersect, unique, difference. Other 
natives or support code we will need are codecs for:

- compression supporting these algorithms: deflate, lzo

- cryptography: MD5, SHA-1, AES, ...(all the required ones for SSH 
and SSL support)


You can port C code to Red/System, there are tons of available C 
source code, you just have to make it right (crypto requires accurate 
coding, implementations need to be deeply tested for flaws).

So let me just say what I am thinking.. I wonder if R3 would be released 
already if you weren't making so much progress with Red..  I hope 
2 (or more) options will be able to bring even more people into Rebol 
family of languages. The time is about to be right. Python is getting 
sort of backlash (finally).

Nenad, could you describe a little the structure that's built up 
by the lexer? Are you intending to (at some point) allow for some 
sort of AST-like (if this is not what's generated already) structure 
to be passed back in along with some way of describing the start/end 
of a modified region in order to reduce the parsing that would need 
to be done if the lexer was being called relatively frequently when 
editing a large source string?

yes, sort of...

MD3: I don't remember...but I sort of remember a MD version with 
PDF export...

Now in Red/System, we can't pass a function as parameter to Red/System 
FUNC,
but we can pass it to external C FUNC, right?


cmp-func!: alias function! [left [byte-ptr!] rihgt [byte-ptr!] return: 
[integer!]] 
quick-sort: func [
	base	 [byte-ptr!]
	n		 [integer!]
	size	 [integer!]
	cmp-func [cmp-func!]	
][
	; can't use cmp-func in this function
]

coudn't it be done with the jit, if given a block to compile on demand? 
 (not saying its implemented, just thinking about how it could be 
done).   sort of like inlining ASM code in C.

ok I was afraid some sort of memory leak could happen if you forgot.

Doc also did some of that with Red where he developed a non-Microsoft 
method to interface with the Microsoft kernel.  Microsoft doesn't 
provide complete documentation for doing that sort of thing, but 
he did it anyway.

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
]

Is heat map a common term for this sort of tool?

Rebol [Purpose: {make wikibook entry}
Author: "Max Vessi"
version: 2.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 "^/"
            ]
        ]
    ]
    append temp "^/= Source code =^/"
    append temp  reduce ["<pre>" join word ": "]
    if not value? word [print "''undefined''" exit]
    either any [native? get word op? get word action? get word] [
        append temp reduce ["native" mold third get word]
    ] [append temp reduce  [ mold get word "</pre>"] ]
    editor temp
    ;write clipboard://  temp
    exit
]

This community seems to need strong leadership and techical support 
by an established entity which replaces Carl.  Saphirion and Doc 
both appear to be in potentially good positions to achieve that role. 
 They're capable and willing to provide new REBOL tools to the community. 
 Perhaps they'll be able to fund the development of those tools with 
commercial work they expect to see down the road, but I have no idea 
how strong their business models are.  Donations are helpful, but 
somehow supporting a business model that encourages leadership efforts, 
should be an important goal for this community.  It seems necessary 
that REBOL achieve some sort of real foot hold - a clear reason for 
use - in industry, education, etc.  For my own purposes, I'd like 
to implement the "business programming for non-programmers" idea 
as a course at business schools (not CS departments).  To me, that's 
REBOL's most relevant potential mainstream use.  How else could the 
REBOL ecosystem potentially grow in a way that encourages others 
to become involved in supporting REBOL, and in ways that financially 
sustain new leadership?  I'd love to see that topic discussed in 
more detail.  I don't think community growth will happen without 
a business plan that addresses the problem.

REBOL and Red needs any sort of "sparkle" possible to make people 
take a look.

My daughter married John Resig's brother.  Long conversations.  John 
is a good guy, a human-centered technology sort of guy.  Saw the 
DOM and went yuk.  I've got to do something about this.

Reactors: I just packed everything on the docs dir we have as a start. 
So, yes, we need to sort it out, get rid of the old stuff etc. So 
feel free to delete it and send a pull-request.

One thing I'm curious about, though - what sort of debugging facilities 
are you thinking about? Will there be any hooks for a debugger somewhere 
not too far down the road? Is it possible to create a symbols file 
for these drivers?

I'd like just to read this url using rebol http://www.amazon.com/s/ref=nb_sb_noss?url=search-alias%3Dstripbooks&field-keywords=%22information+visualization%22#/ref=sr_st?keywords=%22information+visualization%22&qid=1332843525&rh=n%3A283155%2Ck%3A%22information+visualization%22&sort=daterank

I wrote another function which returns in the above format, so I 
can SELECT/SKIP 2,  to get the number of occurence of the value, 
and it doesn't use SORT, uses REMOVE-EACH instead.
it:


>> f: func [b /local c r n1 n2] [r: copy [] foreach v unique b [c: 
copy b n1: length? c remove-each w c [v = w] n2: length? c append 
r reduce [v n1 - n2]] r]
>> a: [a b c c a a b b c d d e e e f f h f f g h]
>> f a
== [a 3 b 3 c 3 d 2 e 3 f 4 h 2 g 1]

Interesting, my tally function and Joel's, work almost in same speed, 
53 sec. for 1 million execution for both.
 - I guess that the version using SORT should be much faster.

Aha, I checked and Joel's code actually *is* using SORT, which means 
it is O(n * log n) algorithm. While, at the same time, the above 
REMOVE-EACH is O(n * n), which is *much* slower as far as I am concerned.

(Search for fast-tally in Altme groups)
using the unique trick:
fast-tally: func [b [block!] /local u i] [
	b: sort b
	u: unique b
	i: 1
	until [
		b: any [find b u/2 tail b]
		u/1: as-pair u/1 negate i - i: index? b
		tail? u: next u
	]
	head u
]

And also, the radix algo is pretty good (if the max value is not 
too large)
radix: func [b [block!] /local u maxv] [
	maxv: 0
	foreach v b [maxv: max maxv v]
	u: head insert/dup make block! maxv 0 maxv
	foreach v b [
		u/:v: u/:v + 1
	]
	u
]

i have a block of objects:
each object is constructed like...
  c: #object! [
    name: "wonderwoman"
    attribs: [
      Y1991: #object! [ a: 1 n: 2]
      Y1992: #object! [ a: 1 n: 2]
    ]
  ]

i need to sort the series based on fields of the attribs inner object
i dont want to create a new series...any ideas?

use the /compare refinement of sort (which can be a function).

>> help sort
USAGE:

    SORT series /case /skip size /compare comparator /part length /all 
    /reverse


DESCRIPTION:
     Sorts a series.
     SORT is an action value.

ARGUMENTS:
     series -- (Type: series port)

REFINEMENTS:
     /case -- Case sensitive sort.
     /skip -- Treat the series as records of fixed size.
         size -- Size of each record. (Type: integer)
     /compare -- Comparator offset, block or function.
         comparator -- (Type: integer block function)
     /part -- Sort only part of a series.
         length -- Length of series to sort. (Type: integer)
     /all -- Compare all fields
     /reverse -- Reverse sort order

hi maxim!

thanks - saw that in the docs, and also saw brett;s sort-object-series 
function on the mailing list
not quite sure how it works with an inner object though

this works great for fields in a simple object series:
sort-object-series: func [
  series
  field
] [

  sort/compare series func[a b][lesser? get in a field get in b field]
]

sort/compare series :sf

can i introduce an additional complexity?
what if i need to sort a hash?
m: #hash! [key-a obj-a key-b obj-b]

sort/compare/skip series :sf 2
??

but if you need to sort with sf above (which uses obj data) then 
you also need to add the index within the skip. (because the obj 
is not the first item of the fields marked with /skip

so it would be:
sort/compare/skip/index series :sf 2 2

doh... that's my old modified sort func...

>> blk: [1 [2  3] 0 [4 8] 5 [4 3]]
>> sort/skip blk 1
== [0 [4 8] 1 [2 3] 5 [4 3]]

sorry - that should read 
>> sort/skip blk 2

i need to sort the hash h by the m attribute of the attribs hash
any ideas? would the same :sf work?

>> sort/skip/compare/all [1 [2  "a"] 0 [4 "z"] 5 [4 "m"]] 2 func 
[a b][a/2/2 < b/2/2 ]
== [1 [2 "a"] 5 [4 "m"] 0 [4 "z"]]

yes, you just need to adapt the paths you lookup.  the sort func 
gets a pair of blocks which are the whole records, which is why I 
start with a /2 to get the second field, which is the block ... in 
your case, that would be the object

sorry maxim - not having any luck with the sort function

>> sf: func [a b][o: select a/attribs "1991-1992" m: select b/attribs 
"1991-1992" o/m > m/m ]
>> sort/skip/compare/all comps 2 :sf
** Script Error: Invalid path value: attribs
** Near: o: select a/attribs "1991-1992"

shouldnt sort/skip/compare/all comps 2 :sf pick up the object?

i get:
>> sort/compare comps :sf
** Script Error: Invalid argument: ?function?
** Near: sort/compare comps :sf

>> sort/compare/all comps :sf
** Script Error: Invalid argument: ?function?
** Near: sort/compare comps :sf

the sort/compare works great if its an object...am stuck because 
its a hash

ok, the sort function must only have 2 parameters.

not quite understanding how to use sort with this structure...

The structure is a little strange. Are you trying to sort the outer 
hash or the inner hash?

i need to sort the hash based on a param (mcap) for an input year 
(say "1991-1992")

yes...
>> sort/skip/compare/all comps 2 func [a b][a > b ]
..sorts in reverse order

if i do:

>> sort/skip/compare/all comps 2 func [a b][length? a/mcapz > length? 
b/mcapz ]
i get an invalid path error

you can do a REVERSE H before and after the sorting. That allows 
SORT to grab the objects.

>> reverse comps sort/skip/compare/all comps 2 func [a b][length? 
a/mcapz  > length? b/mcapz ]
** Script Error: Invalid path value: mcapz
** Near: length? a/mcapz > length? b/mcapz

when you use /all,   you get two BLOCKS.  one for each record of 
length /skip

so your function is called like so: 

sort-func [   "2009-2010"  #[object! [  ... ]]  ]      [ "2011-2012" 
 #[object! [ ... ]]   ]

reverse comps sort/skip/compare/all comps 2  func [a b][probe type? 
a probe type? b length? a/mcapz  > length? b/mcapz ]

block!
block!
** Script Error: Invalid path value: mcapz
** Near: length? a/mcapz > length? b/mcapz

Maxim's SORT-FUNC block shows you how to reference the values properly.

my last example above with ?? added shows this clearly:


>>  sort/skip/compare/all [1 [2  "a"] 0 [4 "z"] 5 [4 "m"]] 2 func 
[a b][ ?? a  ?? b   a/2/2 < b/2/2 ]
a: [0 [4 "z"]]
b: [5 [4 "m"]]
a: [1 [2 "a"]]
b: [0 [4 "z"]]
a: [5 [4 "m"]]
b: [1 [2 "a"]]
== [1 [2 "a"] 5 [4 "m"] 0 [4 "z"]]


what is part of the record is completely irrelevant to sort, it transfers 
all control to your function.

am getting somewhere (i think)
>> sort/skip/compare/all comps 2 func [a b][o: a/2/mcapz probe o]
=== make hash! ["2003-2004" make object! [
        yyyymmdd: 30-Sep-2003
        rebal-year: 2003
        ...]]
etc

then use maxim's sort-func on c instead

you can simply say that when an entry doesn't have a year, it is 
always larger,  so you have them at the end of the list.  you could 
then sort those without a date according to their name.


if you want just the list for "1991-1992" yes, that is a good approach... 


however usually, the fastest way to filter-out lists, is to copy 
the block (not deep, so its quick) and then use remove-each on the 
new block... like-so:

filtered-data: copy data

remove-each [hash mcapz] filtered-data [ not select mcapz "1991-1992"]

isn't that sort of time-critical?

With the 'large' programs I have in mind there will never be lots 
of garbage to collect. I don't know much/anything about robitics 
and control engineering by the way, I am interested in this because 
I realized using REBOL to do things like this could have large potential. 
And I want to move a little car with a photocamera and taking photo's 
from centain positions. The car may also be guided by a rail of some 
sort.

Sunanda: I wrote this function a few months ago for the same task: 
It may not a very good solution but its ok (I think)

similar?: func [
    {Returns true if both object has same words in same types.}
    o [object!] p [object!] /local test
][

    test: [if not equal? type? get in o word type? get in p word [return 
    false]]
    foreach word sort first o test
    foreach word sort first p test
    true
]

with sort
>> (sort/skip third obj1 2) = sort/skip third obj2 2

Two things:

- It iterates through a range of numbers by step, sort of like FOR, 
returning the new value.

- It saves the state of these iterations in a block that is local 
to the function, which it calls "stack" even though it is not a stack.

Here's the function commented:

iter: func [idx start end step  /local stack][

 stack: head []  ; Saved iteration states, persistently updated, indexed 
 by idx
	; Prefill with none through idx
	while [tail? stack: at head stack idx] [insert tail stack none]
	; Initialize iteration state to end value
	if stack/1 = none [stack/1: end ]
	; Increment by step
	stack/1: stack/1 + step
	; If we've gone past the end, rotate back to the start
	if stack/1 > end [stack/1: start]
	; Return the current value of the iteration
	stack/1
]

And optimized/simplified:

iter: func [idx start end step /local stack][

 stack: []  ; head unnecessary, the inline value is at its head already

 insert/dup tail stack none idx - length? stack  ; faster than while

 stack: at stack idx  ; will succeed now, position doesn't persist 
 between calls

 stack/1: step + any [stack/1 end]  ; initialize and increment in 
 one step
	if stack/1 > end [stack/1: start]
	stack/1
]


Note that the function doesn't work if idx, start and end aren't 
numbers, start isn't less than end, and step isn't greater than 1. 
However, all of the code that calls it has these qualities.

(I was hoping that there was perhaps some sort of parallel processing 
solution or some sort of advanced math magic that I knew nothing 
about)

I use the sql dialect like this:

sql [select count [ID title post date] from archive group by [ID 
title post] where [find post "t"]]


The trick with this particular query is the that the "count" selector 
must have exactly one more column than the "group by" selector.  
The first three elements [ID title post] are used to sort the output 
and the last element [date] is counted.

output will be organized:
	ID	title	post	count

What sort of compression?

yeah, google drive is part of  google docs - they've sort of unified 
everything

I am new to Git. I'd like to use it (or something similar) to keep 
a distributed copy of a web app I am developing. I'd like copies 
on two local systems (laptop and desktop) with the possibility of 
sharing with another developer based far away and deploying the app 
on my web host.


I sort of get the concept (at least the part about commits, etc), 
but am not really sure how to keep everything in sync. Is it worth 
using a hosting service like GitHub or Bitbucket (I know that perhaps 
defeats the purpose) to assure availability or figuring out how to 
use the web host for this purpose?

MaxV: I will gladly let it to Carl to sort out. He was reshaping 
a wiki for nearly 3 months, and there are something like 75K pages 
of content. It is also kind of autogenerated/automated. So - do you 
want to do many things manually?

The 64-bit builds are not in any way real 64-bit ports. It's just 
getting 32b R3 to build natively. The R3 data structures are tuned 
for 32b architectures. Nothing of that sort is yet done for the 64 
bit builds.

I remember some sort of discussion, but I think it was at least a 
couple of years ago on the REBOL3 world - can't log in there any 
longer.

Graham, what do you mean all occur in line 1?

More of this sort of discussion needs to take place in this community. 
 So much of the past few years here has been dominated by quibling 
about language details, instead of business potential.

In fact, that sort of thing turns people on when they hear of your 
drive and success

So this discussion is allowing me to synthesize some ideas that might 
be workable.  Perhaps a symbiotic sort of relationship like Stanford 
and Xeorox park for educational technology.  I'm up for a faculty 
spot in So Cal.  Fingers crossed.

stil need to sort out whether the issue is in the rebol port or userland

Tasks sort of work. They actually do start, but there are a lot of 
unresolved problems in the internals, and some of what is supposed 
to make them work properly hasn't been done yet, and some stuff like 
the synchronization and sharing models hasn't even been designed 
yet. So it's not really recommended that you use them yet.

The generic problem to solve is this: You somehow have to specify 
what should happen for different actions. 


Let's start with the "somehow have to specify what should happen". 
For this you have some options:

1. Write the application logic code in the GUI spec block. For sort 
stuff OK, for long not.

2. Just call a function from the GUI spec block and write the rest 
somewhere elese. That's IMO the best way. I used FSM and just send 
"application logic events".

The next part is the "for different actions". Same here:

1. Name them explicitly on-* and specify the code with one of the 
options above.BTW: IIRC R3-GUI has click and right-click blocks for 
convinience.

2. Define an implicit mappging from block order to event type. 1st 
block = click, 2nd = right click, 3rd = double left, 4th double right, 
etc. IMO that's not a good style.


Overall what I never liked about VID was that is was not explicit 
enough. For big projects that's a must. For small you might skip 
this but if those projects get bigger, you are hit again.

Ladislav, I agree about the level of activity not being as useful 
if the number of contributors is not specified, but for now this 
will have to do. The way to do this is through some reasonably smart 
scripting that can obtain a better breakdown of posts by user, either 
through scraping or some sort of API, if available.

Hey, fun stuff -- REBOL.org just got attacked by some sort of spambot 
trying to generate hundreds of fake signup accounts.
It managed to create 10 before our bot detection kicked in.
They must think we're stupid.

Yep, we have our  own sort of flood detection running. I call it 
RID (rampaging intruder detection)


Problem with a captcha tyope solution is that we may need View to 
generate the random images. But our CGIs currently can only run under 
Core. Plus it disadvantages the visually disabled.

Each time I see an attack like this, it gives some more ideas for 
tightening up. Most of the time (like tis time) were one step ahead 
of the vandals.

You could download all messages via the LDS interface...But I wouldn't 
recommend that: you need over 43,000 separate calls to do that.

REBOL.org doesn't offer a single packaged download of the ML archive. 
Maybe it should....

....Bui remember, that service is available from Graham; though it 
is off line until 1and1 sort out thier billing problem (scroll up 
to see Graham's message)

Graham in the All group asked:

<<Is it not true though that you are limited in what you can do with 
rebol.org ? >>
Yes and no.

It's a shared server with the usual sort of quote limits, so that 
stops some of the wilder plans.

On the other hand, the limits are fairly generous. Right now, we 
do these sorts of numbers:
* 150,000 CGI executions per month
* 2.5 gigabytes of data served per month

* 70 megabytes of hard disk used (mainly for the Mailing List archive)


Of course some sort of bandwidth quota would exist with a dedicated 
server too -- that one comes from the ISP, not the box.
---- 

We've had the same problem most of us have had with servers at one 
time or another: REBOL going feral and failing to close tasks. That 
brought down the server once, and got us suspended for about 30 minutes 
until I beseeched forgiveness. Of course, that could happen with 
a dedicated server (no one quite knows why it happens).


Similarly, we get some leak-through from what are supposed to be 
the chinese walls; and that has caused the odd problem: mainly file 
permissions going askew.
---

As Peter said, the main limitation is manpower. There are several 
things under development at rebol.org right now; there is room for 
many other improvement projects too.

Ingo, what's needed is some sort of REBOLbot that trawls the main 
REBOL websites, takes all REBOL-related RSS feeds (and perhaps chats 
to RIXBot), and produces a regular (hourly?) summary of what's new.....That 
way people can easily go where the action is.


If someone writes such a bot, then its summaries could be published 
anywhere. REBOL.org is one possibility; though REBOLCentral was announced 
to do that sort of publicising.


But first, someone needs to write the automated REBOL newshound. 
 Any offers?

It's a glitch between REBOL.org's escaping of codes and makedoc's 
escping of codes.

Someone has to do it to prevent XSS attacks via contributed documentation, 
but not both of uss.

Part of the problem  is that almost all Dialect==>HTML converters 
assume they are there to produce browser-ready HTML. In tne real 
world that isn't always true: they are a step in a pipeline.
I'll sort it out soon. Thanks for reporting the problem.

oh thanks... that sort of works

I am trying to sort out what the POST data should look like coming 
to a Rebol web server from a browser after someone hits submit.

Nice, Henrik!


I do that sort of stuff all the time, and I am sure others do too. 
So to have it as a single item is a good thing.


One small point -- your way of extending the existing object works 
only for single-level values....I often have configuration objects 
that have sub-objects. A field added to a sub-object would be missed 
by your code.  Take a look at:

http://www.rebol.org/cgi-bin/cgiwrap/rebol/view-script.r?script=extend-an-object.r
Which was created for this sort of purpose.

If I can throw my two cents here. Terry is right to complain, because 
you can feel he cares, it's not destructive criticism. Pekr is saying 
he's a realist, but to me he sounds more like a dreamer (no offense).Flash 
is a Virtual Machine that lives in the browser. Rebol is a VM that 
lives on several OSes. Flash VM is present on 99% of the browsers. 
Rebol VM is not present  on browsers (plugin doesn't count because 
last time I tried it wouldn't install, and last version is more than 
a year old), and it is present on OSes of a small number of creative 
developers and hobbyists. If I had to develop a commercial app for 
the web, Flash and Flex give me extensive documentation, and a whole 
framework. Rebol can't compete with Adobe, and should not. Last week, 
I developed a GUI in Rebol and Rebgui that would have taken me four 
times longer in any other graphical toolkit, and I had a knack at 
it. But this app is for internal use. Rebol is a great language, 
and I would like to see it evolve as a computer language, not as 
a throw it all in kind of gizmo. It should go Open Source, because 
RT doesn't have the means to provide versions for all platforms. 
Where is the rebol for NetBSD? Last version is 2001. If RT hasn't 
the resources, let the developers do it. I want to run rebol on an 
internet tablet. I had wanted to run rebol on a palm (not anymore 
because Palm is deas, sort of). But the Nokia tablet run debian linux. 
There is no reason for the unabailability of rebol. It is just a 
matter of building it and packaging it. Who has the time for this? 
Plenty of people, they're just not at RT, because there people are 
busy with more important things (like developing the product).

got it. we'd have to look at some sort of licensing.

Personally, I'd be very cautious to allow any third-party to have 
"trusted access" to my machine.


I'm the sort of person who turns off any type of automated updating.

As Graham or someone else suggested - let's sort out few issues first 
- UI, installation, integration ....

pekr, I sort of agree with you, but it's impossible to ignore how 
widespread flash is, not for apps, but for animations, stylish pages 
and now video with youtube and video.google.com. I actually think 
the easiest way to watch video is through flash.


The point is though not really what flash does, it's how it gets 
spread. I think REBOL/Plugin should emulate that behavior as close 
as humanly possible. people who have installed flash, would know 
how to install REBOL/plugin (visit a specific site, wait for download, 
click 1-2 buttons, done). That initial "installation experience" 
is incredibly important for the widespread use of REBOL/plugin. If 
people can't use it within the first 1-2 minutes, they'll forget 
about it and move on.

how about a simple flag, like a checkforupdates="true" attribute 
or something.  Every other operation, including the sort of actions 
that are necessary to install update is handled through normal security 
requestors.  ... yeah, like Brian said :)

I'll add a remark module for it  :-)  its adds dialected tags to 
html, sort of a functional approach to web.