AltME groups: search

I want to sort [ A14 A2 B300] by either letter (the default of sort) 
or by the number...which is more of a challenge.  I have a crude 
way I am doing this...(this is a block of words, BTW)...what is the 
best "REBOL" way to sort by the number?

Best way? I don't know.

Assuming only a single letter followed by an integer, I'd do this:
 print mold sort/compare [ A14 A2 B300] func [a b][
       return (to-integer next form a) < to-integer next form b]

cool, thanks.  I was thinking there might be some way to keep each 
as a word and do some subparse...but I think there is only a way 
to convert the words to something else and split them apart.

parse handles a literal word indivisibly

And if there are a lot of items, be aware that those transformations 
will occur on every compare, so it could be *verrrrry* slow; a lot 
of churning in there.

If there are a significant number of items, do the transform once 
and build yourself a structure with the numbers in place so you can 
just sort on them.

string comparisons are, in effect, right padded, to equal length 
before comparing.
The comparison is really
max "1000" "999*"

   where "*" is whatever the pad character is (probably a binary zero)

thanks...got all that working (did a parse after all, mold/only the 
block of words to strings before parsing.

hello every body On rebolfrance Forum we have a guy who wants to 
load a library DLL he have done most part of the work but he can't 
find how to convert in his rebol cloned struct! the int intpointer[4] 
from C language to an equivalent type of rebol. Can you enlight us 
please (you can respond directly to shadwolf)

If you have ever tried APPENDing a Block to a Block as a Block (ie. 
append ["a"] to [] and have it be [["a"]])  Then you prolly know 
that you have to jump through a couple of hoops to do it.  The same 
goes to append a string to a string.  Now there are a lot of times 
that I need to append one series to another as a "sub-series" it 
seems to me that this should be much simpler to do, maybe a refinement 
to APPEND.  Any thoughts?

["a" []] = append/only ["a"] []  ;like this?

i'd want to spend a little more tie testing - im trying it on fedora 
core 2 in another few hours as our linux servers go live

your trouble is, that the evaluation of X doesn't have the same effect 
as if you replace X by its value. The evaluation of X only yields 
a set-word instead of setting anything. If you really want to set 
a word 'y, then there are two ways:

set x 'z

do compose [(x) 'z]

Just curious if it looked up the site for a directory. part of my 
rebol editor I am working on.

Gabriele mean that in your post at 5:30 am you miss a slash in the 
url (http:/ instead of http://)

using sort/compare blk func [a b] [a/other/cz < b/other/cz], it will 
survive different location of 'cz field, as it cleverly uses path 
navigation. That is nice. I just wonder about different case ... 
let's say I have object templates, which change once per period of 
xy months ... I also have IOS, so lots of record synced around. My 
plan was, that each object would carry its version info. I wonder 
what to do in case, where new object template version will extend 
object structure, e.g. adding phone-num field ...

I don't think it uses bubble sort. That is a very slow algorithm. 
It's probably quick sort or shell sort.

You have to be careful using /compare. I don' t think it's good to 
use just a logic! value for the swap condition. I think you need 
to specity -1, 0, 1 as values... I forget, you must look it up.

do you have a simple example.

so not a crash, just a rebol error, then ?

In Silesion group, late today I will post about what I have in plan 
and will "complain" a bit about IOS ... it is so primitive db vise, 
that it is not much usable ...

Petr, for fault tolerance, something like:

   sort/compare ...... func [a b] [ attempt [return a/x < b/x] return 
   false]

>>  blk: [[name "pekr" test [cz "bbb"]] [name "adriana" test [cz 
"aaa"]] [name "beatrice" test [cz ""]]]

== [[name "pekr" test [cz "bbb"]] [name "adriana" test [cz "aaa"]] 
[name "beatrice" test [cz ""]]]

>>  sort/compare blk func [a b][attempt [a/test/cz < b/test/cz] return 
false]

== [[name "adriana" test [cz "aaa"]] [name "beatrice" test [cz ""]] 
[name "pekr" test [cz "bbb"]]]
>> sort/compare blk func [a b][attempt [a/test/cz < b/test/cz]]

== [[name "beatrice" test [cz ""]] [name "adriana" test [cz "aaa"]] 
[name "pekr" test [cz "bbb"]]]
>>

Why return false?

It was a very quick attempt to ensure that the sort always returns 
true or false.
But which (as you say) depends on whether a/x or b/x is missing.
Maybe better is
func [a b] [
    attempt [return a/x < b/x]   ;; both exist
    attempt [a/x return true]    ;; only a/x exists
    attempt [b/x return false]    ;; only b/x exists
    return false]                          ;; neither exist


It''d be a lot faster (I guess) if you refactor to remove the attempt 
blocks -- use value?

Pekr: As Sunanda mentioned return -1,0,1 for a stable sort. if you 
want to leave a record untouched when a key field is missing then 
return zero otherwise return 1, or -1

func [a b] [attempt [return a/x < b/x]   ;; both exist

 return 0 ;; nothing can be said because at least one does not exist 
 so they are equilivant
]

a > b -> 1
a = b -> 0
a < b -> -1

there can be several states - non existant 'a, non existant 'b, both 
not existant, a < b, a = b, a > b :-)

in your case you seem to want null have a value that sorts before 
any known value which is fine for you. but in  general,  the three 
cases where a b or both are null are equalivanrt in that no comparison 
can be made and so are "vacuously true" because they cannot be proved 
false.

It's easy to do case sensitive or case insensitive tests for equality:
     >> "abc" = "ABC"
     == true
     >> "abc" == "ABC"
     == false
(Or use equal? and strict-equal?)


Anyone know a  similar shorthand way to do the same for greater/less 
than comparisons?
     >> "abc" < "ABC"
     == false
     >> "abc" > "ABC"
     == false
Right now, I'm using to-binary to get the right result:
     >> (to-binary "abc") < (to-binary "ABC")
     == false
     >> (to-binary "abc") > (to-binary "ABC")
     == true

No, there doesn't seem to be a strict-greater? action, but you can 
make such a function to get more readable code:

strict-greater?: func [value1 value2] [(to-binary value1) > (to-binary 
value2)]


Which makes me remember, that it's not possible to make new in-fix 
actions in REBOL!?

There's no way as fas a as I know of making new in-fix words.  There 
should be -- the currrent ones work both ways, so the mechanism must 
be there somewhere:
>> 6 < 5
== false
>> < 6 5
== false

Thanks for the strict-greater? idea.  I was hoping there was a built-in 
ability somewhere.

One tiny tweak to the function -- you need to restrict the two values 
to series or you can get strange results:
     >> strict-greater? make object! [1] make object! [0]
     == false
     >> greater? make object! [1] make object! [0]
     ** Script Error: Cannot use greater? on object! value
So:

 strict-greater?: func [value1 [series!] value2 [series!]] [(to-binary 
 value1) > (to-
binary value2)]

The infix operators in REBOL can be seen with:
>> ? op!

It's a special corner of REBOL, as I see it. And I don't feel a big 
need to be able to make my own infix operators. There is a funny 
thing with the and, or and xor operators. They have twin and~, or~ 
and xor~ actions. The actions is used like: <action> <value1> <value2>, 
but operators can be used the same way, so the action counterparts 
seem to be irrelevant. Examples:
>> 3 and 9
>> and 3 9
>> and~ 3 9

Why do we have and~, or~ and xor~ made?

I have one little thing to ask for my personal knowledge and I hope 
for people to thinks together on a good way to exploit it in REBOL 
to enhance it's capability to interface with DLL or exploit files 
containing memory struct dump:

the thing is how to load or convert a C structure like this and use 
it in REBOL in a approachant way of C (I hope we could find even 
a better way to do it with rebol than in C)

//-------------------------------------------------------------
//- SMD2Header
//- Header for all Md2 files, 
struct SMD2Header
{
   int m_iMagicNum; //Always IDP2 (844121161)
   int m_iVersion;  //8
   int m_iSkinWidthPx;  
   int m_iSkinHeightPx; 
   int m_iFrameSize; 
   int m_iNumSkins; 
   int m_iNumVertices; 
   int m_iNumTexCoords; 
   int m_iNumTriangles; 
   int m_iNumGLCommands; 
   int m_iNumFrames; 
   int m_iOffsetSkins; 
   int m_iOffsetTexCoords; 
   int m_iOffsetTriangles; 
   int m_iOffsetFrames; 
   int m_iOffsetGlCommands; 
   int m_iFileSize; 
};

//-------------------------------------------------------------
//- SMD2Vert
//- Vertex structure for MD2
struct SMD2Vert
{
float m_fVert[3];
unsigned char m_ucReserved;
};


//-------------------------------------------------------------
//- SMD2Frame
//- Frame information for the model file 
struct SMD2Frame
{
float m_fScale[3];
float m_fTrans[3];
char m_caName[16];
SMD2Vert * m_pVerts;

//Cleans up after itself
SMD2Frame()
{
m_pVerts = 0;
}

~SMD2Frame()
{
if(m_pVerts)
delete [] m_pVerts;
}
};

//-------------------------------------------------------------
//- SMD2Tri
//- Triangle information for the MD2
struct SMD2Tri
{
unsigned short m_sVertIndices[3];
unsigned short m_sTexIndices[3];
};

//-------------------------------------------------------------
//- SMD2TexCoord
//- Texture coord information for the MD2
struct SMD2TexCoord
{
float m_fTex[2];
};

//-------------------------------------------------------------
//- SMD2Skin
//- Name of a single skin in the md2 file
struct SMD2Skin
{
char m_caSkin[64];//filename
CImage m_Image;//Image file ready for texturing
};

//-------------------------------------------------------------
//                        CTIMER                              -
// author: Evan Pipho ([evan-:-codershq-:-com])                     -
// date  : Jul 10, 2002                                       -
//-------------------------------------------------------------
class CMd2 : public CModel
{
public:

//Set skin to one of the files specified in the md2 files itself
void SetSkin(unsigned int uiSkin);
//Set skin to a different image
void SetSkin(CImage& skin);

//Load the file
bool Load(const char * szFilename);

//Render file at the initial position
void Render();
//Render the file at a certain frame
void Render(unsigned int uiFrame);


//Animate the md2 model (start and end frames of 0 and 0 will loop 
through the WHOLE model

void Animate(float fSpeed = 30.0f, unsigned int uiStartFrame = 0, 
unsigned int uiEndFrame = 0, bool bLoop = true);

//constructors/destructo
CMd2();
CMd2(const char * szFile);
~CMd2();

private:

CTimer m_Timer;
//file header information
SMD2Header m_Head; 
//Frame information
SMD2Frame * m_pFrames;
//Triangles
SMD2Tri * m_pTriangles;
//Texure coords
SMD2TexCoord * m_pTexCoords;
//Skin files
SMD2Skin * m_pSkins;
//Interpolated vertices
SMD2Vert * m_pVerts;
//Current skin
unsigned int m_uiSkin;
//Using a custom skin?
bool m_bIsCustomSkin;
//The custom skin
CImage * m_pCustSkin;

};

What I would like to achieve is in REBOL:

1) Declaring in REBOL the struct schemes identically as a in the 
C way
2) read the file containing the datas to fill the declared struct
3) attribute to struct the rode data from the file
4)can interact freely with REBOL common fonctions

if that is the struct of the data stored in a file, it should not 
be too hard to parse the file to get the information...looks like 
a 3-D rendering file or ?

my REBOL coding is nearly as good as my C coding...but my C codding 
had a 22 year head start...;-)

coding = codding ... a slip of the fish

shadwolf, it seems, you need some kind of binary format, so external 
data can be loaded directly in to a REBOL structure. Maybe REBin? 
http://www.rebol.net/blogs/0044.html

the goal is to provide to REBOL the capability to do such a load 
in the simpliest and fastest way I think the posibility of using 
a vectorial data like float myvar[3];

is there a site with files I could look at? (just seems there would 
be a very simple way to do this without much problem) sorry I am 
not familiar with md2 (guess the enterprise work distracts me too 
much...;-(

In fact the actual need to support MD2 file format is not requiered 
but We can use such a complicated hierarchical structure to simplify 
in REBOL/Core the C library branchement witch will in reallity very 
important if we want to have the true capabilité to exploite C library 
 that use vectorial dat or vectorial structure based API

parsing binary is a bit different than parsing ASCII...and I have 
done a bit for mp4...but I think your point of making it simple is 
a good thing.

an other way could be to use the MD2 importer script into blender 
but it's not anymore online for the moment (I have a copy of it on 
my local harddrive if you want to test it....)

when Josh appears, we will scratch each others heads and see if we 
can determine a way to parse this...he has done some work like this 
for his NASA project...and he is working on some crazy computer science 
parsing algorithms...I think he has been chatting with Ladislav too 
long ... ;-)

thank you ladislave for single int variable that's easy (like header) 
but for file content it's ver hard and harder I think to attribute 
to a REBOL struct based pointer the content of the file

>> a: make object! SMD2Header
** Script Error: Invalid argument: make struct! [
    m_iMagicNum [int]
    m_iVersion [int]
    m_iSkinWidthPx [int]
    m_iSkinHeightPx [int]
    m_iFrameSize [int]
    m_iNumSkins [int]
    m_iNumVertices [int]
    m_iNumTexCoords [int]
    m_iNumTriangles [int]
    m_iNumGLCommands [int]
    m_iNumFrames [int]
    m_iOffsetSkins [int]
    m_iOffsetTexCoords [int]
    m_iOffsetTriangles [int]
    m_iOffsetFrames [int]
    m_iOffsetGlCommands [int]
    m_iFileSize [int]
] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]

why do you want to make object? - it is a struct

that's not that way it has to be done sorry I made a mistake. It's 
only a: SMD2Header

but in this case you can't have a declaration like SMD2Header *myheader; 
that is the common way to do it in C SMD2Header struct will became 
a type in C, In rebol you only make a pointer to the struct so with 
vectorials struct based array mofifying one data will modify all 
data in the array

the we have the posibility to take a bunch of frame for example from 
0 to 10  to say that's  animation set correspond to run

it is sometimes too mind expanding to write code while chatting. 
 Sometimes I think I need a few more heads, and a couple more arms 
to type and click...maybe I should draw a new model of myself.

in my 3D engine I will make a switch to change the animation that 
are into my model that supose for me to have all my 3D model to get 
the identical set of animation or to make animation switch that could 
be adapted to every 3D Model Type (that's why 3D engeneers not even 
more use this format and prefert bone animation based file format 
like MDL or MD3/MD5)

aha...a datatype-sensitive editor...see, I should close down the 
right side of my brain so the left side can type code easier.

so or we allways ue struct! to typify our variables (wich can't be 
reuse). In C if I make SDM2Header *a, *b; a content and b content 
(physical memory localtion) will not be the same

in rebol a: SMD2Header and b: SMD2Header will point to the same memory 
chunk ...

>> a: SMD2Header
>> b: SMD2Header
>> a/m_iMagicNum: 1234234
== 1234234
>> probe b/m_iMagicNum
1234234
== 1234234
>>

and that normal becaus in C to initialise data I will use a malloc 
call witch will attrubute to a and b on the same based type different 
memory location

//-------------------------------------------------------------
//- Load
//- Loads an MD2 model from file
//-------------------------------------------------------------
bool CMd2::Load(const char * szFilename)
{
	unsigned char * ucpBuffer = 0;
	unsigned char * ucpPtr = 0;
	unsigned char * ucpTmpPtr = 0; 
	int iFileSize = 0;
	FILE * f;
	
	if(!(f = fopen(szFilename, "rb")))
	{
		APP->Log(COLOR_RED, "Could not open MD2 file %s", szFilename);
		return false;
	}

	//check file size and read it all into the buffer
	int iStart = ftell(f);
	fseek(f, 0, SEEK_END);
	int iEnd = ftell(f);
	fseek(f, 0, SEEK_SET);
	iFileSize = iEnd - iStart;

	//Allocate memory for whole file
	ucpBuffer = new unsigned char[iFileSize];
	ucpPtr = ucpBuffer;

	if(!ucpBuffer)
	{

  APP->Log(COLOR_RED, "Could not allocate memory for %s", szFilename);
		return false;
	}

	//Load file into buffer
	if(fread(ucpBuffer, 1, iFileSize, f) != (unsigned)iFileSize)
	{
		APP->Log(COLOR_RED, "Could not read from %s", szFilename);
		delete [] ucpBuffer;
		return false;
	}

	//close the file, we don't need it anymore
	fclose(f);

	//get the header
	memcpy(&m_Head, ucpPtr, sizeof(SMD2Header));

	//make sure it is a valid MD2 file before we get going
	if(m_Head.m_iMagicNum != 844121161 || m_Head.m_iVersion != 8)
	{
		APP->Log(COLOR_RED, "%s is not a valid MD2 file", szFilename);
		delete [] ucpBuffer;
		return false;
	}
	
	ucpTmpPtr = ucpPtr;
	ucpTmpPtr += m_Head.m_iOffsetFrames;

	//read the frames
	m_pFrames = new SMD2Frame[m_Head.m_iNumFrames];
	
	for(int i = 0; i < m_Head.m_iNumFrames; i++)
	{
		float fScale[3];
		float fTrans[3];
		m_pFrames[i].m_pVerts = new SMD2Vert[m_Head.m_iNumVertices];
		//expand the verices
		memcpy(fScale, ucpTmpPtr, 12);
		memcpy(fTrans, ucpTmpPtr + 12, 12);
		memcpy(m_pFrames[i].m_caName, ucpTmpPtr + 24, 16);
		ucpTmpPtr += 40;
		for(int j = 0; j < m_Head.m_iNumVertices; j++)
		{

   //swap y and z coords to convert to the proper orientation on screen

   m_pFrames[i].m_pVerts[j].m_fVert[0] = ucpTmpPtr[0] * fScale[0] + 
   fTrans[0];

   m_pFrames[i].m_pVerts[j].m_fVert[1] = ucpTmpPtr[2] * fScale[2] + 
   fTrans[2];

   m_pFrames[i].m_pVerts[j].m_fVert[2] = ucpTmpPtr[1] * fScale[1] + 
   fTrans[1];
			m_pFrames[i].m_pVerts[j].m_ucReserved = ucpTmpPtr[3];
			ucpTmpPtr += 4;
		}
		
	}

	//Read in the triangles
	ucpTmpPtr = ucpPtr;
	ucpTmpPtr += m_Head.m_iOffsetTriangles;
	m_pTriangles = new SMD2Tri[m_Head.m_iNumTriangles];
	memcpy(m_pTriangles, ucpTmpPtr, 12 * m_Head.m_iNumTriangles);

	//Read the U/V texture coords
	ucpTmpPtr = ucpPtr;
	ucpTmpPtr += m_Head.m_iOffsetTexCoords;
	m_pTexCoords = new SMD2TexCoord[m_Head.m_iNumTexCoords];
	
	short * sTexCoords = new short[m_Head.m_iNumTexCoords * 2];
	memcpy(sTexCoords, ucpTmpPtr, 4 * m_Head.m_iNumTexCoords);

	for(i = 0; i < m_Head.m_iNumTexCoords; i++)
	{

  m_pTexCoords[i].m_fTex[0] = (float)sTexCoords[2*i] / m_Head.m_iSkinWidthPx;

  m_pTexCoords[i].m_fTex[1] = (float)sTexCoords[2*i+1] / m_Head.m_iSkinHeightPx;
	}
	
	delete [] sTexCoords;

	//Read the skin filenames
	ucpTmpPtr = ucpPtr;
	ucpTmpPtr += m_Head.m_iOffsetSkins;
	m_pSkins = new SMD2Skin[m_Head.m_iNumSkins];
	
	//Load textures
	for(i = 0; i < m_Head.m_iNumSkins; i++)
	{
		memcpy(m_pSkins[i].m_caSkin, ucpTmpPtr, 64);
		//hack off the leading parts and just get the filename
		char * szEnd = strrchr(m_pSkins[i].m_caSkin, '/');
		
		if(szEnd)
		{
			szEnd++;
			strcpy(m_pSkins[i].m_caSkin, szEnd);
		}

		m_pSkins[i].m_Image.Load(m_pSkins[i].m_caSkin);
		ucpTmpPtr += 64;
	}
		
	delete [] ucpBuffer;
	return true;
}

class CMd2 : public CModel
{
public:

	//Set skin to one of the files specified in the md2 files itself
	void SetSkin(unsigned int uiSkin);
	//Set skin to a different image
	void SetSkin(CImage& skin);

	//Load the file
	bool Load(const char * szFilename);
	
	//Render file at the initial position
	void Render();
	//Render the file at a certain frame
	void Render(unsigned int uiFrame);


 //Animate the md2 model (start and end frames of 0 and 0 will loop 
 through the WHOLE model

 void Animate(float fSpeed = 30.0f, unsigned int uiStartFrame = 0, 
 unsigned int uiEndFrame = 0, bool bLoop = true);

	//constructors/destructo
	CMd2();
	CMd2(const char * szFile);
	~CMd2();

private:
	
	CTimer m_Timer;
	//file header information
	SMD2Header m_Head; 
	//Frame information
	SMD2Frame * m_pFrames;
	//Triangles
	SMD2Tri * m_pTriangles;
	//Texure coords
	SMD2TexCoord * m_pTexCoords;
	//Skin files
	SMD2Skin * m_pSkins;
	//Interpolated vertices
	SMD2Vert * m_pVerts;
	//Current skin
	unsigned int m_uiSkin;
	//Using a custom skin?
	bool m_bIsCustomSkin;
	//The custom skin
	CImage * m_pCustSkin;

};

so you make a SDM2Header *m_Header; to declare your header type from 
structure SMD3Header, then you read the correct emont of data in 
the file  storing it to ucpPtr then you init m_Header it using  memcpy(&m_Head, 
ucpPtr, sizeof(SMD2Header));

Shadwolf: "in rebol a: SMD2Header and b: SMD2Header will point to 
the same memory chunk ..."


yes, but you should do it as follows: a: make struct! SMD2Header 
b: make struct! SMD2Header

I'm not an expert on struct! far of that (wel in C yes but in REBOL 
no and I think it's because I'm not using load/library capability 
until now) but that's a good discution to point to difficulties on 
this kind of task and I hope help rebol Core to have a bettre handling 
of that

>> a: make struct! SMD2Header
** Script Error: Invalid argument: (missing value)
** Near: a: make struct! SMD2Header

a: make struct! SMD2Header none ; or [some values here]

yes so I had to read the file first then make my variable content 
basing me on a precut of the rode datas from file to be allowed to 
fill my variable content on inititialisation

a-struct: make struct! [
        in-string [string!] "Input string"
        in-int [integer!] "Input integer"
    ] ["This is input" 42]

while in C my struct is struct a-struct { char in-string[25]; int 
in-int; }

that's not a direct use for me I intent thru thi discution to enlight 
some problems that every one can infront using rebol external library 
capability

It is on you to not override the length of the string IMO You have 
to deal with this as you are working with static  memory so it is 
not a problem of Rebol itself. I think you ca easily write 'dangerous' 
code when dealing with DLL interfaces ;) Making error in this are 
usually ends up with crash (memory acces violation).

maybe that IS a good point to make it harder to crash at the interface. 
 The toughest code to write is always the in-between stuff.

It takes a guru level REBOLer who is also profishant in C to write 
an interface to a DLL, although there are becoming more and simple 
examples...but maybe shadwolf wants to make it a graphical process?

an ez-dll.r which takes in a .h and a .dll and lets you play, experiment, 
and try to controll any .dll might be a fun project.

I have written a research proposal grant for such a tool...

Interfacing with lower-level naguages (such as C) from Rebol looks 
a bit harder but when you gain more experience with it (=no crashes 
anymore ;)) you realize it works logically. I was also dissapointed 
for the firt time I tried to use some DLL. But now I'm more optimistic. 
The only think I miss is the callback handling.

so, ok, let's write a little script.

graham: depends on number of speakers. we had to rush a lot at last 
one (my speech was reduced from 45 mins to about 10 mins)

I think if you're going to pay 1000s of $ to travel so far, then 
that is a real shame to cut short the speakers.

Find me a language that make it shorter ! (except a phone call, that's 
just 12 number ;-)

How about "Lake Como"? Only 30 min outside of Milan, and quite a 
sight from what I have heard.

if there's time, we could do a trip there. but... not sure about 
the time part :)

a reboler that works in a school near milan offered to host the conference.

Ok. Then thats a good reason.

Is the location for the conference a school?

yes. a high school.

but I need a restaurant too :-) Hope there will be some after-party 
in the evening? :-)

very exciting.  seems an excellent idea to use the school, better 
facilities than a hotel, and likely all the equipment for classes 
(projectors, screens, even overheads maybe?)

so far 8 people sent in the survey email. we need a bit more to decide 
for dates and so on.

not yet. i'd like to get the feedback from the rebolers first, then 
make up a plan based on that.

reason: first of all, the devcon is for rebolers first, others second. 
second, we need speakers, otherwise there's no point in having other 
people coming; if we have no speakers, then let's just make a "meeting" 
or "party" or whatever you want to call it.

'Sept' shall be fix a Rebol DevCon month

so, future devcon should not deviate from it too far off.

+- half a week

if so - do the others that selected 19-25 have a problem with that?

i'm asking because a lot selected 26-2 too. i haven't counted the 
submissions yet, as they are still coming.

to speakers: i'd like to prepare a list, with arguments and so on, 
for the public. so please contact me. :)

If I remember correctly Linate is a long way from Milan.

Speakers: could you please send me a text similar to the one provided 
by Maarten? Thanks!

Also... anyone not yet in the list that wants to be a speaker should 
contact me ASAP!