AltME groups: search

As Red/System compiler is written in R2, you could imagine a full 
toolchain library for R2 that could integrate Red/System deeply with 
R2, imagine:

>> foo: make-native [a [integer!] return: [integer!]][a + 1]
>> foo 123
== 124


MAKE-NATIVE here would compile the Red/System function, emit a DLL, 
load it and map the function back. ;-)

Got the OpenStreetMap GPS Map browser to work on the Raspberry

For example, I've noted the alias! issue before. As long as all code 
is compiled together, alias numbers are a good interface, like symbol 
IDs are assigned at runtime in REBOL. But when precompiled code needs 
to communicate they become useless, hence why the R3 interface makes 
efforts to map symbols to known numbers

champlain map browser - missing a library

Here are the syscalls that should map to that kernel version (I've 
changed it often):

#syscall [
	init-runtime: 02F0h []
	
	init-serial: 05C8h [
		object	[int16!]
		baud	[integer!]
	]
	prin: 084Eh [
		object	[int16!]
		msg		[int16!]		; string pointer!
	]
	prin-int16: 09FEh [
		object	[int16!]
		value	[int16!]
		type    [int16!]		; unsure about the meaning of this parameter
	]
	prin-int32: 0992h [
		object	[int16!]
		value	[integer!]
		type    [int16!]		; unsure about the meaning of this parameter
	]
	set-pin-mode: 046Ah	[
		pin		[byte!]
		mode	[byte!]
	]
	digital-write: 04B6h [
		pin		[byte!]
		value	[byte!]
	]
	wait: 023Eh [
		delay	[integer!]
	]
]

If you realize that indices are one degree vectors.   A lot of this 
discussion becomes moot.   vectors of length 0 are considered impossible 
when considering only natural numbers (due to 0 divide).  This is 
why I consider R2's handling of indices proper.   


As such, any series "position" is not AT a value it is LOOKING AT 
a value (oriented in positive direction, starting at a point in space 
which is "0").   like extending your arm to grasp the nth thing in 
front of you.  


Tail are 0 length vectors (thus mathematically imposible), when we 
are beyond  the last item edge we are at the edge of space.   you 
cannot "take" the tail item, there is nothin in front of you, just 
as you cannot "take" the 0th item, there is no such thing, 0 is the 
origin of the vector).


when we consider series indices to be vectors, we see the natural 
relationship which Ladislav pointed with SKIP and other methods.


with vectors, things like COPY/PART make sense in the negative direction, 
just as well as in the positive direction.



In R3, this was changed to indices being OVER a value , with the 
first item requiring you to look down and then away for other values. 
 The issue is that index 0 is looking backwards... that doesn' map 
to any good reasoning.  In fact it creates many weird inconsitencies 
in the model, when you try to describe it.


R3's series changes seem like a kludge work-around to map non-vectorial 
infinite integer space to a bounded vectorial space. sacrificing 
model integrity in the process (while trying to ease its mathematical 
properties).  R3's series *may* be "easier to count in a loop"  but 
the values being used make no sense.   counting backwards requires 
us to manipulate the indice for it to "make sense", whereas before, 
counting backwards was the same as counting forward.  we where just 
LOOKING in the opposite direction (the vector's orientation is inversed).

The issue is that index 0 is looking backwards... that doesn' map 
to any good reasoning.  In fact it creates many weird inconsitencies 
in the model, when you try to describe it.

 - it may not be a "weird inconsistency", but it is almost imposible 
 to describe to a newbie in a reasonable way

One very important point is, I think, that this discussion is not 
necessarily about 0-based vs 1-based.


It is more about if and how to map the concept of ordinals to the 
concept of integers. If you choose to use indices-as-ordinals ("1-based 
indices"), those two questions collapse to one. If you choose to 
use indices-as-offsets ("0-based indices"), the question of how to 
handle ordinals _still remains_.

The more interesting question is how ordinals map to integers :) 
That basically requires a decision of how you want to do indexing 
with integers, then it's easy as well.

Now Red supports 21 datatypes. In the following R3 datatype list, 
datatypes with a minus prefix are not supported in Red yet.


action -binary -bitset block char -closure -command datatype -date 
-decimal -email -end -error -event -file -frame function get-path 
get-word -gob -handle -image integer -issue -library lit-path lit-word 
logic -map -module -money native none -object op -pair -paren path 
-percent -port -rebcode refinement set-path set-word string -struct 
-tag -task -time -tuple -typeset unset -url -utype -vector word

clojuredocs: check out this http://api.clojuredocs.org/search/clojure.core/map
real state of the art documentation :D

My first reaction was the same as Endo and Bolek, because I'm used 
to the way it is. I rarely have to alias a loop counter for access 
outside the loop, and I like the language being smart enough to help 
me, so I don't have to declare these things all the time, or worry 
about leakage.  However, my recent work on the idea of a new, general 
LOOP func (%mezz/new-loop.r here for those who didn't follow it) 
made me keenly aware of loop costs.


I've only had a few instances where it really mattered, but I've 
still almost always avoided FOR, for performance reasons.  Doc thinks 
things through carefully, and he has already said that FUNCTION could 
probably be smart enough to handle things for us, but we would have 
to consider how that works, to avoid environment dependent behavior. 
And how it affects very simple map/filter funcs. That is, do those 
one-liners now need /local specs.

Since it's early days in Red, I'm toying with a lot of ideas and 
revisiting old REBOL funcs as I port them. JS has an interesting 
spin on MAP. I thought I'd see how hard it would be to do in Red.

; 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]

Bindings not in there are SDL and OpenGL, for graphical 2D and 3D 
programs, ZeroMQ for network messaging, and some specific extra widgets 
for the GTK+ binding, such as a (real) web browser, two map browsers 
and a PDF and other document viewer

Generating apk...
/bin/bash: builds/tools/aapt: Bestand of map bestaat niet
Signing apk...
jarsigner: unable to open jar file: builds/eval-unsigned.apk
Aligning apk...
/bin/bash: builds/tools/zipalign: Bestand of map bestaat niet
...all done!

Bestand of map bestaat niet
 means the file doesn't exist

directories under red.esperconsultancy.nl are according to the script 
download.r:

test common C-library cURL ZeroMQ-binding REBOL-3 Java SQLite SDL 
OpenGL GLib GTK GTK-WebKit OSM-GPS-Map GTK-Champlain 6502

I copied my list from my browser address field history. Should have 
noticed GLib (first I had tried GLIB and found nothing) was the one 
you asked for.

We just released our first R3 based tool. See: http://www.saphirion.com/development/heat-map/


The tool gives you an editor to build hierarchical structures / layouts 
where you than can map given information criterias (Skills, Performance, 
...) into visual recognizable values (color, line width, ...).


We use this tool to visualize complex situations on one page. The 
values could be feed from a database or other source in real-time 
and the visualization will update immediatly.

I've updated the GTK-WebKit, GTK-Champlain and OSM-GPS-Map bindings 
for the new interface

I'd add r3lib.dll to the heat map demo .zip, as without it, the program 
won't run.

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

head-map: Yes, common term. The tool actually does tree-maps.

Heat-Map:
- example added
- read-me added

I downloaded fromthis link: http://www.saphirion.com/development/downloads-2/files/heat-map-gui-demo.exe.zip
 and the models/ contains some test data

I have all the images from the docs from REBOL-IDE cluttering my 
scripts folder now. Is it possible to use a seperate map for these? 
Please?

---------------------------
OSM-GPS-Map-browser.exe - Unable To Locate Component
---------------------------

This application has failed to start because LIBGTHREAD-2.0-0.DLL 
was not found. Re-installing the application may fix this problem. 
---------------------------
OK   
---------------------------

OSM-GPS-Map is an extra library on top of that

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.

REBOL is structured more like LISP or Haskell (but without being 
a pure functional language).


So, yes, it does not have direct access to the machine instructions 
or low-level op sys APIs in the way that assembler or assembler-wrapper 
languages (like C) does.


What REBOL does have is easy integrated access to very high level 
APIs: parse. bind, map, etc.

Functions and objects aren't copied, but everything else seems to 
be:


>> a: reduce ["" #{} 'a/b [] quote () make list! [] make hash! [] 
does [] context []]

== ["" #{} a/b [] () make list! [] make hash! [] func [][] make object! 
[
    ]]
>> b: bind/copy a 'a

== ["" #{} a/b [] () make list! [] make hash! [] func [][] make object! 
[
    ]]
>> map-each [x: y] b [same? :y first at a index? x]
== [false false false false false false false true true]

map-each [x: y] [...] is an interesting use. I sometimes needed to 
get that "index" value but I didn't know that usage so I used forall 
instead. Good to learn.

Endo, when you are using set-words with MAP-EACH and R3's FOREACH, 
be sure to include at least one regular word, or it won't advance 
and you'll get an endless loop. We made that possible in order to 
support the foreach [x:] data [... take x ...] code pattern. It's 
the type of thing that would generate a warning in other languages, 
but REBOL is inherently incompatible with warnings.

Before you ask, the MAP-EACH fix is going in there too :)

An associative database would be fun to have in REBOL. The 'map data 
structure in R3 replaces 'hash, and is supposed to be better.

There have been some linkups between REBOL and the relavance associative 
database, but nothing much has come of it.

    http://www.rebol.org/aga-display-posts.r?offset=0&post=r3wp500x1919
    http://www.rebol.net/cgi-bin/r3blog.r?view=0161
    http://www.relavance.com/

am still on R2
? map tells me:
map!            datatype! hash!
map?            action!   Returns TRUE for hash values.

is map! only truly availale on R3?

>> do %compare.cgi
Script: "Untitled" (none)
Script: "MySQL Protocol" (12-Jul-2008)
MySQL protocol loaded
connecting to: localhost
** Script Error: Invalid path value: oneone
** Where: map-rebol-values
** Near: result/oneone
>>

I still have some rebol services stuff in production, and always 
had high hopes for it. And while I would like a self-contained, dialected 
model, I also want to be able to easily use 0MQ as a transport and 
REST interfaces to map over services.

There's only so much of the process that can be rewritten to uzse 
FORALL. And of course MAP-EACH is getting hit by the same bug.

It might be easier. It's parsing, and uses MAP-EACH a lot, and there's 
a bug in MAP-EACH in R2 (that's my fault, sorry), but that is one 
approach I'll have to consider.

If you are writing tests, there are a few things you should know 
about the behavior-as-designed of REWORD:

- values is a collection of key/value pairs, like a map. If a block, 
no reduce is done, it's just data.

- Keys are converted to strings if they aren't strings already, and 
are considered equivalent if their strings are equivalent.

- Empty strings don't count, but the check for empty keys is done 
after the string conversion so none is not empty, it's "none".
- If a value is unset or none, the key/value pair is ignored.

- If the same key is specified more than once, the last value of 
that key takes precedence.

- After all of the key/value conflicts are resolved, if there are 
ambiguities between keys (like "ab" vs. "a") then the first key gets 
priority. That means that you probably want to put the longer key 
first, same as with PARSE alternates.


If we're writing tests, we need to write tests for all of those. 
And we probably need tests because it was intended that REWORD be 
converted to a native for speed after we settled on its behavior. 
The current REWORD works as designed, but we might want to tweak 
the design after further discussion.

If MAP-EACH was more powerful I wouldn't need COLLECT. Ditto with 
Gabriele's PARSE extensions.

when we talk about changing the datatype names, I think we accept 
that decimal wouldn't have any currency or denominator. 

its the implementation behind the type which would be switched, and 
a "new type" added which would map to the current decimal! handling.

execve("../rebol2558042", ["../rebol2558042"], [/* 18 vars */]) = 
0
uname({sys="Linux", node="dino.local", ...}) = 0
brk(0)                                  = 0x809b000

old_mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, 
-1, 0) = 0x40017000

access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file 
or directory)

open("/etc/ld.so.preload", O_RDONLY)    = -1 ENOENT (No such file 
or directory)
open("/etc/ld.so.cache", O_RDONLY)      = 7
fstat64(7, {st_mode=S_IFREG|0644, st_size=51977, ...}) = 0
old_mmap(NULL, 51977, PROT_READ, MAP_PRIVATE, 7, 0) = 0x40018000
close(7)                                = 0

access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file 
or directory)
open("/lib/tls/libm.so.6", O_RDONLY)    = 7

read(7, "\177ELF\1\1\1\0\0\0\0\0\0\0\0\0\3\0\3\0\1\0\0\0\2405\0"..., 
512) = 512
fstat64(7, {st_mode=S_IFREG|0644, st_size=141236, ...}) = 0

old_mmap(NULL, 139712, PROT_READ|PROT_EXEC, MAP_PRIVATE, 7, 0) = 
0x40025000

old_mmap(0x40047000, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED, 
7, 0x22000) = 0x40047000
close(7)                                = 0

access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file 
or directory)
open("/lib/tls/libc.so.6", O_RDONLY)    = 7

read(7, "\177ELF\1\1\1\0\0\0\0\0\0\0\0\0\3\0\3\0\1\0\0\0\200X\1"..., 
512) = 512
fstat64(7, {st_mode=S_IFREG|0644, st_size=1270908, ...}) = 0

old_mmap(NULL, 1281292, PROT_READ|PROT_EXEC, MAP_PRIVATE, 7, 0) = 
0x40048000

old_mmap(0x40176000, 36864, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED, 
7, 0x12d000) = 0x40176000

old_mmap(0x4017f000, 7436, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, 
-1, 0) = 0x4017f000
close(7)                                = 0

old_mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, 
-1, 0) = 0x40181000

set_thread_area({entry_number:-1 -> 6, base_addr:0x401812a0, limit:1048575, 
seg_32bit:1, contents:0, read_exec_only:0, limit_in_pages:1, seg_not_present:0, 
useable:1}) = 0
munmap(0x40018000, 51977)               = 0

rt_sigaction(SIGCONT, {0x804b6c4, [CONT], SA_RESTART}, {SIG_DFL}, 
8) = 0

rt_sigaction(SIGTSTP, {0x804b67c, [TSTP], SA_RESTART}, {SIG_DFL}, 
8) = 0

rt_sigaction(SIGINT, {0x804b700, [INT], SA_RESTART}, {SIG_DFL}, 8) 
= 0

rt_sigaction(SIGTERM, {0x804b700, [TERM], SA_RESTART}, {SIG_DFL}, 
8) = 0

rt_sigaction(SIGHUP, {0x804b700, [HUP], SA_RESTART}, {SIG_DFL}, 8) 
= 0

rt_sigaction(SIGCHLD, {0x804b718, [CHLD], SA_RESTART}, {SIG_DFL}, 
8) = 0
socketpair(PF_UNIX, SOCK_DGRAM, 0, [7, 8]) = 0

clone(child_stack=0, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, 
child_tidptr=0x401812e8) = 21686
close(8)                                = 0
brk(0)                                  = 0x809b000
brk(0x80be000)                          = 0x80be000
brk(0)                                  = 0x80be000
brk(0)                                  = 0x80be000
brk(0x80eb000)                          = 0x80eb000
brk(0)                                  = 0x80eb000
brk(0x810c000)                          = 0x810c000
ioctl(0, TCGETS, {B38400 opost isig icanon echo ...}) = 0
ioctl(0, TCSETSW, {B38400 opost isig -icanon -echo ...}) = 0

open("/etc/termcap", O_RDONLY)          = -1 ENOENT (No such file 
or directory)
write(1, "R", 1)                        = 1

Gordon, your method only works for chars than happen to map to decimals. 
 Try this for an error:

print to-integer to-string to-hex to-integer to-decimal to-char "M"


Variant on Tom's to produce the same result as yours (may not work 
with 64-bit REBOL)
     form skip to-hex to-integer first "a" 6

How to set correctly progress function for read-net? Or what causes 
following error and :                                            
                >> myProgr: func [ tot bt ] [ print bt / tot ]

>> read-net/progress to-url "http://maps.dnr.state.mn.us/cgi-bin/mapserv36?map=/usr/loca

l/www/docs/mapserver_demos/tests36/expressions/test.map&map_counties_class_expression=(%

5bAREA%5d %3e 7577272785.15339)&layer=title&map_title_class_text=Counties+Larger+Tha
n+Itasca+County&mode=map" :myProgr
0.425625
** Script Error: not is missing its value argument
** Where: read-net

** Near: all [:callback size not callback size length? buffer data: 
true break]
not data
>> source read-net
read-net: func [

    {Read a file from the net (web). Update progress bar. Allow abort.}
    url [url!]

    /progress callback {Call func [total bytes] during transfer. Return 
    true.}
    /local port buffer data size
][
    vbug ['read-net url]
    if error? try [port: open/direct url] [return none]

    size: to-integer any [port/locals/headers/content-length 8000]
    buffer: make binary! size

    set-modes port/sub-port [lines: false binary: true no-wait: true]
    until [
        if not data: wait [60 port/sub-port] [data: true break]
        if data: copy port/sub-port [append buffer data]

        all [:callback size not callback size length? buffer data: true break]
        not data
    ]
    close port
    if not data [buffer]
]
>>

You could use Andrew Martin's map function to achieve this

do http://www.rebol.org/library/scripts-download/arguments.r; 
Needs

do http://www.rebol.org/library/scripts-download/map.r; Instantiate
map func [a][2 * a] [1 2 3 4 5 6] ; supply the function to map
>>[2 4 6 8 10 12]

Graham: Are you asking for  email/1 & email/2 to map to the current 
email/user and email/host  refinements ?

I should remember that the doc of the original functions are in source-destination 
order, so for me is a good idea to make the same in Rebol,  there 
a direct map of OS function and OS doc on rebol functions

BrianH i'm not the only one in that case 90% of the people present 
here in 2005 have magicaly disapeared from the rebol map ...

The structure of an object is static (which fields in which order), 
but the values assigned to those fields are as dynamic as you want. 
Also, if you want to add or delete fields it is quite easy to create 
a new object with your changes at runtime. If you are just using 
an object as what other languages call a dictionary or hash map, 
you might as well use a block or hash type for your data.

Simple blocks mappings: I looked in the maillist, but did not find 
for such a simple case.  I am trying to devise a function to map 
values from rebDB to the user UI in rebGui.  So I need to map the 
respective values in two blocks, as in a: [a b c d e] and b: [1 2 
3 4 5], thinking that a foreach would do the mapping.  To no avail?
z: []
foreach [i j] [a b] [append z [i j]]
I want [a 1 b 2 c 3 d 4 e 5]

I would need two foreach, side by side, not to embed one in the other. 
This does not work, but the idea is there.
>> z: []
== []
>> foreach i a foreach j b [append z [i j]]
== 5
>> :z
== [i j i j i j i j i j] -> ?What is the formula?

I then I have to map the results so that different laboratory's fields 
can be made equivalent.

Rather than storing the HL7 result as free text, to store each sub 
test in a database.
So, a Hb result will be stored as a Hb record.

Another laboratory might call that "haemoglobin", so I need to map 
these two together.

I would like you to suggest me some Linux distribution:

Current situation:


I run old Fedora Core 1 linux, so it lacks on security updates. The 
server is used for few domains, it runs apache, old mySQL 3.5.x version, 
glftpd, sendmail (I am used to that). Server has 2 hads. Content 
of server is packed each week via script and copied to other disk.

Objectives:


- need some easy distro, graphical mode installation, which even 
monkey can configure, forget somo guru stuff, target hardening, etc.
- need mysql 5.x family, Apache 2. family

- adding new users/developers by some tool, e.g. webmin - ftp, apache 
domain, webmail (squirrel)

- needs to run rebol in cgi mode, eventual sqlite library compatibility 
welcomed

- kind of easy recovery - install from CD in graphical mode, copy 
configs, reboot, or even better - instasll some kind of loader, map 
to second hd, unpack backup, reboot. Maybe this could be automated?


Of course I have some sympathies already - stay with Fedora? Try 
Ubuntu server edition? Any other suggestion?

Thanks.

But I bet that it could put Rebol on the map as a code golf language.

Graham. Yes! Would like to map other things to. Like.. 1 hard thump 
== ctrl-alt-del

new functions, and added support for it to temple-map-data etc.

Difficult, as trying to map:


 "I'll take base and not include any of the networking mezz source"

to:


 "Encap using latest rebview but exclude all the graphics and networking 
 code *I* know I'm not going to need"

doesn't sound too easy to me.

Terms: I'm all for using "standard" terms. I must say that View always 
forces me to map the words and rethink them. I would like to see:
	Window
	Canvas instead of face

 Attribute instead of facet (please keep non-native speakers in mind)
	Action instread of feel
	Widget instead of style

For me a Widget can have different styles: Windows, Mac etc.

If this list doesn't fulfill all your needs, here's the additionnal 
features planned for the 1.0 release :

    * RSP: REBOL Server Pages support.
    * General CGI support (run any CGI script).

    * Chunk-encoding transferts support (streamed data transferts).
    * Standard compression methods support: gzip, deflate, bzip2.

    * Byte-ranges request support (ability to request files in parts 
    and resume broken downloads).

    * mod-rewrite module for powerful request URL transformations (without 
    the regexp complexity!).

    * mod-map-url module for direct URL to REBOL functions or objects 
    mapping.
    * SSL support.
    * Advanced GUI client for local and remote administration.

So if we implement this api in rebol, we could use standard documentation? 
And browsers are based on DOM, we could map that to rebol-plugin 
and control browser?

There are two major types of XML (or SGML) APIs:

Tree-based APIs

    These map an XML document into an internal tree structure, then allow 
    an application to navigate that tree. The Document Object Model (DOM) 
    working group at the World-Wide Web Consortium (W3C) maintains a 
    recommended tree-based API for XML and HTML documents, and there 
    are many such APIs from other sources. 
Event-based APIs

    An event-based API, on the other hand, reports parsing events (such 
    as the start and end of elements) directly to the application through 
    callbacks, and does not usually build an internal tree. The application 
    implements handlers to deal with the different events, much like 
    handling events in a graphical user interface. SAX is the best known 
    example of such an API.

Chris - following is true imo which favors SAX with me:


Tree-based APIs are useful for a wide range of applications, but 
they normally put a great strain on system resources, especially 
if the document is large. Furthermore, many applications need to 
build their own strongly typed data structures rather than using 
a generic tree corresponding to an XML document. It is inefficient 
to build a tree of parse nodes, only to map it onto a new data structure 
and then discard the original.

If they are functions, we can map the same names to browser-calls. 
think protocols.

The important thing is to make sure that the events or data structures 
are a good map of the semantic model of XML. They have standards 
abut that too.

I guess in rebol we have fewer problems than java, as rebol is dynamic 
and java has to emulate that? So it cant map its own classes because 
the format is not known at compile-time? While we can. And then xml 
in memory should be in the order of rebol-blocks?

does having XSLT also means we can map that into /View?

when i think about representing data conceptually, i tend to always 
come up with a graph or a tree (then i map the conceptual graph to 
a relational model, or maybe to a dialect). so for selecting data 
a "navigation" approach (which is basically what xpath does) seems 
rather natural for me; then you can map the navigation to SELECT 
statements etc if needed.

not the best map, but I think I found Milan, Treviglio, and the airport 
in-between http://www.maporama.com/affiliates/popup/share/Map.asp?SESSIONID={E711FE54-B9BB-4D1C-BCB7-FD1C82113A3B}&ZoomSet=9

http://www.maporama.com/affiliates/popup/share/Map.asp?SESSIONID={E711FE54-B9BB-4D1C-BCB7-FD1C82113A3B}&ZoomSet=9

shadwolf, a good example to use with your svg renderer is the word 
map with political borders (public domain license) http://www.mappinghacks.com/maps/world_borders.svgz

Anton:
** Script Error: cv has no value
** Where: do-parse
** Near: cv mold type-converter/c-to-rebol-map

Hello Denis,


So, one of the things a group of us have been talking about is doing 
some group lessons (world wide).


We have researched some tools for making this possible.  We narrowed 
it down to Macromedia's Breeze.  In fact last week I talked for about 
2 hours with their team (meaning the people that actually designed 
and programmed it).


This week I'm talking to their OEM leads about integrating Breeze 
from Rebol into Web applications.


So our first Breeze interactive lesson will be in a few weeks is 
my guess.  WE have not idea how good it will be with more than 10 
people, and world wide, but we are going to try.


As to a road map.  Programming languages in general are difficult 
to learn in a methodical method.  Rebol being even more difficult 
(in my opinion), because learning the structure does not help very 
much.  Even learning how Rebol works is not all that usefull (compared 
to lets say Basic, or a Batching system).

I will make some simple suggestions though:


1.	Go to Rebol.com, and read what is offered there.  It actually 
is a good starting point.  Rebol Essentials" which is a PDF on the 
site is worth reading.


2.	Write your own dictionary.  Literally, pick a given word in Rebol, 
use it in a sentence.  And just work your way through all 400+ words. 
 You can do it in a few hours.  All you need to do is try to use 
it in a way the Rebol Dictionary does not use it.



3.	Build something you really want to build.  Unless you have a goal, 
working on anything is going to be boring.  Think of a utility, or 
a game that you have always wanted to understand better, or want 
to play with, and build it.  Another cool concept is to simply copy 
it from an existing version in some other language you already know, 
or that is more simple (like Basic).

I'm glad you agree that Rebol requires a different road map to learn 
than, say, C++ or Pascal, or even Prolog and such languages. I know 
a few languages, having been a programmer for a living in my younger 
days. Now I teach programming for young students starting in science 
(18 years old +)

Reichart, you are working on defining the paradigm of the language. 
I think that is the right direction to follow to generate a faster 
learning map of Rebol.

A word is basically a value that can be put in a value slot. This 
value includes a pointer to a symbol and a pointer to a context.


A symbol is like a string that is only stored once. The symbol that 
is pointed to by a word is the same symbol (same chunk of data) as 
that pointed to every other word that is made up of the same characters 
as the word (case-insensitively).


A context is like a map from symbols to value slots. When you create 
a context it has the specified set of symbols associated with it 
and each one of these symbols has an associated value slot. When 
you bind a word to a context, you change the context pointer of a 
word to point to the context. If you try to bind a word to a context 
that doesn't include the word's symbol, the bind fails silently and 
the word is unchanged. With the exception of system/words, all contexts 
are of fixed length once they are created (for now).


If the word's context pointer is not set, the word is considered 
unbound. If the corresponding value slot in the context the word 
is bound to is supposedly empty, the value slot really contains the 
unset! value, and the word is considered unset.


(Current implementation) Every word you create is added to the system/words 
context, which expands to include it if it isn't already there. Currently, 
system/words has an upper limit of 8000 words. This effectively means 
that the words your script uses must not exceed 8000 unique symbols, 
including those used by the runtime.

I'm looking for a LEARNING MAP that could be used as a fast track 
to learning to build interesting little applications.

Same for lisp MAP.

Actually, I do know why - I just read it today. The reason is that 
url paths don't necessarily map directly to the filesystem.

other thing is, if we should support /object as original scheme did? 
Even  with odbc, some time ago, I simply created map-record function, 
which mapped record to object, for easier access (block position 
independent) .... dunno if you find that possibility usefull though 
....

But they are not the same way ...

	SQL "insert into t values ('text')
	SQL {insert into t values ('"text"')}

map to:


 SQL ["insert into t values (?)" "text"]	; with /direct refinement

 SQL ["insert into t values (?)" "text"]	; without /direct refinement


The first approach in each case is saying, "I want this value to 
be stored as a SQLite TEXT value which will not be LOADed upon retrieval"; 
while the second is saying, "I want this value to be stored as a 
MOLDed SQLite TEXT value which will be LOADed upon retrieval back 
into a REBOL string value (as opposed to the word 'text)".


A string! statement is strictly literal, it is passed onto SQLite 
with no parsing or conversion. If you want to bind values, use the 
block form ... that's what it's there for!

DESCRIBE returns the column ID 0 based. As I map this either to block 
positions or objects and Rebol is 1 based how about adding an option 
to either get the results 0 based or 1 based as in Rebol?

Brian asks, "Can you map nodes to physical world objects?"

mario, mind maps are very cool... I would like to make an optimised 
tool for quickly creating and organising mind maps in elixir but 
I can say that I hope others will join me in adding toolsets... its 
the whole point of elixir, an open, common framework of integrated 
and live tools.  anything goes into anything, so you can do things 
like share data between, you graphics, mind map and project management... 
why not even use some of it to drive the GUI building for one of 
the panes... I mean, in the end, they are all being used for one 
goal.

Terry, in my todo-list, I have a generic module for interfacing cheyenne's 
HTTPd with REBOL applications called mod-map-url (or mod-mapping). 
It will map predefined URLs to REBOL objects. Example: http://domain.com/app/show
will call the function ''show from your object 'app. This module 
should cover most of needs if you have to embed Cheyenne in your 
REBOL application. If it doesn't cover your specific needs, you'll 
have to write a specific mod_xyz HTTPd module, which might be a little 
more complex.

i  use positions and an immage for background-collision. less performant 
than grids but the map can be a big image without much work.

hmm, maybe think links. thereis no real map, only relations. when 
someone browses, the page is picked by chance too, not only choice. 
when something good happens and you have high statistics, you may 
 get it.

gah - i forgot how hard the ricebowl map was..

Mahjong updated with save/load, scoring, timer, fixed ricebowl map 
and other general craziness.  http://rebol.mustard.co.nz/mahjong.zip
 or http://rebol.mustard.co.nz/mahjong.rif you dont care about the 
bad ricebowl.map

.r file is just for updaters who already have resources :)  altho 
i did fix the ricebowl.map in this update

had 2 extra tiles in the map for some reason.. was causing unfinishable 
games :(

So, let me help you help me (I have designed about 120 video games). 
  You need to break down your art as follows

 name, size, comments

For example

In looking at your image names, I can't map them to "purpose"

What are card and card1?


May I suggest  you rename things first, and a smart move is to put 
in place holder art that is the size you want to finally use.  Even 
if it just has the name of what will be there, ie "Gold" etc.

There was a world map at one point, maybe done by Chriss Ross-Gill 
on an old IOS world.

The version of your script that I have is showing only the time-zone 
map in newer views.

Brock, I know you don't get much sunshine but your "circle" doesn't 
show up on the rebcon-map. Thanks Chris for this, by the way.

In case you're wondering, I made this map for DevCon '05.

A little lower on the map.. Slovenia.  Do we all (viewers) login 
with devcon u/p when the conf will start?

How well does the Draw semantic model map to the Windows printing 
semantic model?

Righ, gobs being lower level would require less work to map to OS 
Printing API.