AltME groups: search

to me the problem is that MS should have created a real application 
framework... actually, only Apple with OSX seems to be really close 
to this.


there should be THREE root directories and only three dirs for each 
application.  windows has dozens, which is crazy.
1. Application SOURCE data (.exe, libs, datafile, etc)
2. Application STORAGE data (game saves, defaults
3. Application Temporary data, flushed on program quit by the OS.


within Storage, you'd have application and user-based storage and 
that's it.


The os refuses to execute any file not within application source 
dir, so you have already clamped down on a lot of security issues. 
 a list of approved .exe is stored whenever you launch an application 
for the first time.


for a bit more flexibility, several application dirs could exist, 
so that you can do stuff like compile items and run them locally 
within your dev environment, but these dirs would be explicitely 
registered within the os.


on install the Application should be required to ask permission (like 
flash) in how much space will be stored within STORAGE if it exceeds 
a max default, independently of SOURCE.


The implementation of MyXxxx folders is completely horrendous, and 
should be a simple and ubiquitous form that has one entry for each 
media type, and a browser where you want to put your stuff (which 
might not be user-specific).


IIRC this was addressed in Vista, but then they went and added aliases 
to everything, which raises errors in the explorer, cause you can't 
use them.  They alias core windows directories in other languages, 
the result being that explorer and actual disk info are different! 
 this completely fucks up many applications (like rebol).


windows has a hard time "fixing" things... they always just patch 
it... its worse since they have a hard time starting with any good 
implementation of anything to begin with.

Anyone know what the discussions are regarding extending the alias 
function in REBOL3?  I have a bit ugly function that does something 
like that now.  What I'm talking about is the ability to alias for 
example find/only or find/case or instead of just find so that no 
refinement has to be supplied.  I submitted a wish for this some 
time ago and hoped it would make it in REBOL3 but don't know what 
is intended regarding that.

Great work, would be a nice alias to add in Rebol.

>> whereof: [get in disarm try [+] 'where]

>> g: f: does [print ["my name is" do whereof]]
>> g
my name is g
>> f
my name is f

Anyway, you can create your own alias.
In R3 >
|: :or
&: :and

In R2 >
alias 'and "&"
alias 'or "|"

view layout [i: image black effect [draw [anti-alias off  circle 
10x10 0.0001]] image (i/size * 5) (to-image i)]

view layout [i: image black effect [draw [anti-alias off scale 0.1 
1 line 100x10 101x10 scale 1 1]] image (i/size * 5) (to-image i)]

view layout [i: image black effect [draw [anti-alias off shape [move 
10x10 hline 10.1]]] image (i/size * 5) (to-image i)]

AGG used in the draw dialect is very good at anti-aliasing. But then 
some (maybe) unexpected results occur, when anti-alias is turned 
off:

view layout [i: image black effect [draw [anti-alias off circle 50x50 
20 line 20x20 80x20 20x80 20x20]] image (i/size * 5) (to-image i)]

view layout [i: image black effect [draw [translate 0.5 0.5 anti-alias 
off circle 50x50 20 line 20x20 80x20 20x80 20x20]] image (i/size 
* 5) (to-image i)]

Yes, that could be a solution.
Is it also slow, if you turn anti-alias off? Hit 'a'!

view layout [box white effect [draw [translate 0.5 0.5 anti-alias 
off pen none fill-pen black circle 50x50 0.5]]]

I've found it, it's anti-alias off not antialias :-) http://www.rebol.com/docs/draw-ref.html

hmm, but maybe mine is not example of binding anyway, it just simply 
created alias, no?

According to the DRAW Document, the shape is closed automatically, 
i.e. as a polygon, unless you specify a move command at the end of 
the shape block. However, the following example is different. why?


view layout [ box 300x300 black effect [draw [anti-alias on pen red 
fill-pen none shape [move 35x12 curve 35x12 line 53x96 curve 53x96 
54x101 57x104 61x104 line 61x108 line 37x108 line 37x104 curve 37x104 
42x104 44x103 44x101 curve 44x101 44x100 44x98 44x97 line 38x72 line 
19x72 line 14x98 line 14x100 curve 14x100 14x102 16x104 20x104 line 
20x108 line 3x108 line 3x104 curve 3x104 7x104 9x102 10x99 line 29x14 
move 20x68 curve 20x68 line 37x68 line 29x29]]]]

REBOL[] view layout [ box 128x128 black effect [draw [anti-alias 
on pen white fill-pen white shape [move 32x19 curve 32x19 33x19 34x19 
35x20 curve 35x20 38x22 40x24 40x25 curve 40x25 40x26 39x27 39x28 
curve 39x28 38x29 38x31 37x33 curve 37x33 35x38 32x43 28x50 curve 
28x50 24x58 19x65 14x70 curve 14x70 9x75 6x77 4x77 curve 4x77 3x77 
3x77 3x76 curve 3x76 3x76 3x76 4x75 curve 4x75 8x71 13x64 19x55 curve 
19x55 23x48 26x40 29x33 curve 29x33 30x30 31x26 31x22 curve 31x22 
31x20 31x19 32x19 move 36x27 curve 36x27 36x27 37x27 38x27 curve 
38x27 40x28 43x29 45x30 curve 45x30 48x32 50x33 51x34 curve 51x34 
51x36 52x37 52x38 curve 52x38 52x39 52x40 51x41 curve 51x41 51x42 
50x43 49x43 curve 49x43 49x43 48x42 47x42 curve 47x42 46x41 44x39 
42x36 curve 42x36 40x33 38x31 37x30 curve 37x30 36x29 35x28 35x28 
curve 35x28 35x27 35x27 36x27 move 42x51 curve 42x51 43x51 44x52 
46x52 curve 46x52 48x53 50x54 50x54 curve 50x54 50x55 48x56 46x56 
curve 46x56 44x56 43x57 41x57 curve 41x57 40x57 38x58 33x59 curve 
33x59 31x59 29x59 28x59 curve 28x59 27x59 25x59 24x59 curve 24x59 
23x58 22x58 22x57 curve 22x57 22x56 23x56 26x56 curve 26x56 31x55 
35x53 40x52 curve 40x52 41x52 42x51 42x51 move 44x66 curve 44x66 
45x66 46x66 49x67 curve 49x67 51x67 52x68 52x69 curve 52x69 52x70 
51x70 48x71 curve 48x71 46x71 43x72 42x72 curve 42x72 40x72 36x73 
30x74 curve 30x74 27x75 24x75 23x75 curve 23x75 21x75 20x75 19x75 
curve 19x75 17x74 16x74 16x73 curve 16x73 16x72 17x71 20x71 curve 
20x71 27x70 34x69 41x67 curve 41x67 42x66 44x66 44x66 move 31x57 
curve 31x57 33x57 34x57 37x58 curve 37x58 38x59 39x60 39x61 curve 
39x61 39x61 39x62 39x63 curve 39x63 38x64 38x65 38x66 line 37x96 
line 32x96 line 31x64 curve 31x64 31x63 31x62 30x60 curve 30x60 29x60 
29x59 29x59 curve 29x59 29x58 30x57 31x57 move 18x82 curve 18x82 
18x82 19x82 20x82 curve 20x82 23x83 25x84 26x85 curve 26x85 27x86 
28x87 28x89 curve 28x89 28x92 27x93 25x93 curve 25x93 24x93 23x93 
23x92 curve 23x92 21x91 19x88 17x83 curve 17x83 17x83 16x83 16x82 
curve 16x82 17x82 17x82 18x82 move 46x76 curve 46x76 46x76 48x76 
49x77 curve 49x77 51x79 52x80 52x80 curve 52x80 52x81 52x81 51x81 
curve 51x81 49x83 46x86 42x89 curve 42x89 41x89 41x89 41x89 curve 
41x89 40x89 40x89 40x89 curve 40x89 40x88 40x88 40x88 curve 40x88 
42x86 43x84 43x82 curve 43x82 44x80 45x78 45x76 curve 45x76 46x76 
46x76 46x76 move 10x97 curve 10x97 11x97 12x98 13x98 curve 13x98 
15x98 16x98 16x98 curve 16x98 17x98 19x98 21x97 curve 21x97 33x94 
41x92 45x90 curve 45x90 46x90 47x89 48x89 curve 48x89 50x89 51x90 
51x91 curve 51x91 51x92 50x93 48x94 curve 48x94 35x99 28x101 28x102 
curve 28x102 26x103 23x104 21x105 curve 21x105 20x106 19x107 18x107 
curve 18x107 17x107 15x106 12x104 curve 12x104 10x101 9x100 9x99 
curve 9x99 9x98 9x97 10x97 move 75x12 curve 75x12 75x12 76x12 77x12 
curve 77x12 79x12 81x13 83x14 curve 83x14 86x15 87x16 88x17 curve 
88x17 89x18 89x19 89x20 curve 89x20 89x21 89x23 88x25 curve 88x25 
87x26 86x27 85x27 curve 85x27 84x27 84x27 83x26 curve 83x26 82x25 
81x24 80x21 curve 80x21 78x18 76x16 75x14 curve 75x14 75x14 74x13 
74x13 curve 74x13 74x12 74x12 75x12 move 104x22 curve 104x22 104x22 
106x23 108x23 curve 108x23 110x25 112x26 112x27 curve 112x27 111x28 
110x28 108x29 curve 108x29 101x29 93x29 85x31 curve 85x31 80x31 73x33 
65x35 curve 65x35 63x35 63x35 62x35 curve 62x35 61x35 59x35 57x34 
curve 57x34 55x33 55x32 55x32 curve 55x32 55x31 55x31 57x31 curve 
57x31 73x28 86x26 97x24 curve 97x24 101x23 103x22 104x22 move 59x32 
curve 59x32 59x32 61x32 64x32 curve 64x32 66x33 67x34 67x35 curve 
67x35 66x37 66x38 66x38 curve 66x38 65x54 63x67 61x77 curve 61x77 
59x86 57x93 54x100 curve 54x100 51x106 47x111 44x114 curve 44x114 
43x115 43x115 42x115 curve 42x115 42x115 42x115 42x115 curve 42x115 
45x110 47x104 49x99 curve 49x99 53x89 55x79 57x69 curve 57x69 58x60 
59x50 59x40 curve 59x40 59x39 59x37 58x36 curve 58x36 57x35 57x34 
57x33 curve 57x33 57x33 58x32 59x32 move 102x35 curve 102x35 104x35 
106x36 109x38 curve 109x38 110x39 111x40 111x40 curve 111x40 111x41 
111x42 110x43 curve 110x43 109x44 109x46 108x47 curve 108x47 106x55 
105x59 105x60 curve 105x60 104x63 102x64 101x64 curve 101x64 100x64 
99x63 99x62 curve 99x62 98x61 98x60 98x59 curve 98x59 98x59 98x58 
98x57 curve 98x57 99x56 100x53 100x49 curve 100x49 101x47 101x45 
101x43 curve 101x43 101x42 100x41 99x41 curve 99x41 97x41 95x41 91x42 
curve 91x42 82x44 77x45 75x45 curve 75x45 73x45 72x45 71x44 curve 
71x44 70x44 70x43 70x43 curve 70x43 70x42 71x41 73x41 curve 73x41 
78x41 86x39 97x36 curve 97x36 100x35 102x35 102x35 move 113x46 curve 
113x46 113x46 115x46 117x47 curve 117x47 119x49 121x50 121x51 curve 
121x51 120x52 119x52 117x52 curve 117x52 110x52 103x53 94x54 curve 
94x54 89x54 83x56 75x57 curve 75x57 73x58 72x58 72x58 curve 72x58 
70x58 68x57 67x56 curve 67x56 65x56 64x55 64x54 curve 64x54 64x54 
65x54 66x53 curve 66x53 82x51 96x49 106x47 curve 106x47 110x46 112x46 
113x46 move 99x60 curve 99x60 100x60 101x60 102x61 curve 102x61 104x62 
106x63 106x64 curve 106x64 105x64 104x65 103x65 curve 103x65 98x65 
94x65 88x66 curve 88x66 85x66 81x67 76x68 curve 76x68 75x68 74x68 
74x68 curve 74x68 73x68 72x68 70x67 curve 70x67 69x67 68x66 68x66 
curve 68x66 68x65 69x65 70x65 curve 70x65 80x63 88x62 95x61 curve 
95x61 97x60 99x60 99x60 move 65x75 curve 65x75 66x75 68x75 70x76 
curve 70x76 72x77 73x77 73x78 curve 73x78 73x79 73x79 73x80 curve 
73x80 72x80 72x82 72x84 curve 72x84 72x89 72x94 71x98 curve 71x98 
70x102 69x106 68x109 curve 68x109 66x112 65x114 63x116 curve 63x116 
61x118 60x119 60x119 curve 60x119 60x119 59x118 59x118 curve 59x118 
59x118 59x118 60x117 curve 60x117 61x114 62x111 63x108 curve 63x108 
64x104 65x100 65x96 curve 65x96 66x92 66x88 66x84 curve 66x84 66x81 
66x79 65x78 curve 65x78 64x77 64x77 64x76 curve 64x76 64x75 64x75 
65x75 move 105x70 curve 105x70 105x70 107x71 110x72 curve 110x72 
113x74 114x75 114x76 curve 114x76 114x77 113x77 113x78 curve 113x78 
112x81 111x85 111x92 curve 111x92 111x96 111x99 111x101 curve 111x101 
112x102 112x104 112x106 curve 112x106 112x111 111x115 109x118 curve 
109x118 107x121 105x123 103x123 line 100x111 curve 100x111 101x111 
102x110 103x110 curve 103x110 104x108 105x103 105x96 curve 105x96 
105x91 104x86 104x79 curve 104x79 104x77 104x77 103x76 curve 103x76 
103x76 102x76 101x76 curve 101x76 100x76 97x76 92x77 curve 92x77 
84x78 79x79 75x79 curve 75x79 74x80 73x80 72x80 curve 72x80 71x80 
70x80 69x79 curve 69x79 68x78 68x77 68x77 curve 68x77 68x77 69x76 
70x76 curve 70x76 75x76 82x75 89x74 curve 89x74 94x72 99x71 101x70 
curve 101x70 103x70 105x70 105x70 move 93x109 curve 93x109 93x109 
93x109 94x109 curve 94x109 97x110 99x111 100x111 line 103x123 curve 
103x123 102x123 102x122 101x121 curve 101x121 98x117 96x114 93x111 
curve 93x111 92x110 92x110 92x110 curve 92x110 92x109 92x109 93x109 
move 98x83 curve 98x83 98x83 100x83 102x83 curve 102x83 104x84 105x84 
105x85 curve 105x85 105x86 103x86 101x87 curve 101x87 99x87 97x87 
95x88 curve 95x88 94x88 90x89 84x90 curve 84x90 80x90 78x91 77x91 
curve 77x91 75x91 74x91 73x90 curve 73x90 72x90 71x89 71x89 curve 
71x89 71x88 72x87 74x87 curve 74x87 81x86 88x85 95x83 curve 95x83 
97x83 98x83 98x83 move 97x94 curve 97x94 98x94 99x94 101x94 curve 
101x94 103x95 104x95 104x96 curve 104x96 104x97 103x97 101x98 curve 
101x98 98x98 96x98 94x99 curve 94x99 93x99 89x99 83x100 curve 83x100 
79x101 77x101 75x101 curve 75x101 74x101 73x101 72x101 curve 72x101 
70x100 70x100 70x99 curve 70x99 70x98 71x98 73x98 curve 73x98 80x97 
87x96 94x94 curve 94x94 96x94 97x94 97x94 move 83x32 curve 83x32 
84x32 85x32 88x33 curve 88x33 90x34 91x35 91x36 curve 91x36 91x37 
91x37 90x39 curve 90x39 90x42 89x45 89x49 line 89x90 curve 89x90 
89x98 88x105 87x111 curve 87x111 86x115 86x117 85x117 curve 85x117 
84x117 83x116 83x113 curve 83x113 83x108 83x102 83x94 line 83x43 
curve 83x43 83x40 82x37 82x35 curve 82x35 81x34 81x33 81x33 curve 
81x33 81x32 82x32 83x32]]]]

Chinese! :-) Cool! To better see the character, you can make it larger 
with this:

view layout [
	box 4 * 128x128 black effect [draw [
	scale 4.0 4.0
	anti-alias on
... followed by the rest of Jerry's program.

If you expect to support large, dense, spreadsheets, you may want 
to minimize storage by having a name mapping interface. If the target 
is small/medium/sparse sheets, having the name explicit for each 
cell may be practical. In any case, having a alias system would be 
nice, for named cells and ranges.

You can acces the your free items of the last group with names
you can use e.g
  alias 'first "portn"
  alias 'second "disabled"
  alias 'third "vlan"

Yeah, R2 isn't great for creating "slick" interfaces without the 
use of graphics. Use can draw text with anti-alias, but most scripts 
just do things the easy way.


The pencil icon is handy as well, so you can use ctrl+s to send. 
I imagine you've already done that, but for others listening in...

Hello again all,  I'm BrianD (but be glad that's not my alias or 
it would make the Wiki back-and-forth with BrianH even harder to 
read).

Todun, contexts and objects are the same in REBOL. The object word 
is just used as an alias name because other languages call them that

If Alias permits one to set up word equivalencies, then it's solving 
a problem I have with Rebmu.

Will is his alias name, not his real life name.

hey while your working on REBOL3 add something that can do this  
 alias object/item "myfunc"

Paul, I'm not sure which of the arguments is supposed to be the alias 
and what is supposed to be aliased. Try
    myfunc: does [object/item]
or
    object/item: does [myfunc]
depending on which direction you meant.

ALIAS is really only meant for internationalization. Assignment is 
for value aliasing, and functions are values.

anyone know if alias will be updated in REBOL3 to support paths? 
 I would like to do something such as:

alias 'find/any "myfind" 

Currently, the alpha that I have gives an error that says:

** Script error: alias does not allow path! for its word argument

No, nor should it. ALIAS is just for aliasing words to other words, 
primarily for internationalization. What you want is function wrappers, 
made easier with the APPLY native function in REBOL 3.

fontize [

	base: [
		font: [
			color: black
			size: 12
			name: "Arial"
		]
		anti-alias: off
	]

	centered: base [
		para: [
			margin: 0x0
			origin: 0x0
			align: 'center
			valign: 'middle
		]
	]

	button: centered [
		font: [
			color: black
			style: 'bold
			size: 14

   shadow: [0x1 255.255.255.100] ; black shadow here. should be transparent 
   and bright.
		]
		para: [
			wrap?: false
		]
		anti-alias: on
	]

]

The real advantage of list! wasn't the speed though, it was the alias 
persistancy. That was the source of the bugs in list! too.

this what in text-draw.r (VID3 sources)
font-char-size?: funct [fstyle] [
	gob: make gob! [offset: 0x0 size: 300x100]
	gob/text: reduce [
		'font fstyle/font

  'para make fstyle/para [wrap?: off] ; avoid infinite loop font bug
		'anti-alias fstyle/anti-alias
		"M"
	]
	size-text gob
]

[ This whole post is mainly in the R2 mindset, but is somewhat relevant 
also to R3. ]


The technique of setting words directly into the global context like 
this:

	context [
		set 'o ...
	]


I do not like, because this code is modifying its environment - it 
has side-effects - thus, it is non-modular, and does not scale.

Being non-modular means large software systems can't be built up 
reliably, because the cumulative effect of all those side-effects 
will eventually cause name-clashes in the global context, so that 
some word exported from one context will be overwritten by the same 
word exported from another context.

For example, suppose I've seen two graphics demos by two different 
authors. They each have an awesome graphics processing routine and 
I decide that I would like to combine both routines into a single 
program. They each wrapped their code up in a context and exported 
a word 'process-image, like so:

	; From author #1
	context [
		set 'process-image does ...
	]

	; From author #2
	context [
		set 'process-image func ...
	]


You can imagine that each of these "modules" also has a large amount 
of supporting code, local variables and functions, and each is in 
a large file on the respective author's website. Somewhere in the 
middle of each of these files, in the CONTEXT body code, are the 
SET lines which export the words into the global context.

When I write my program to combine both of these "modules", I will 
probably write code like:

	; Acquire all dependencies
	do %image-processor.r  ; By author #1
	do %super-gfx.r  ; By author #2

	; Create an image and manipulate it.
	my-image: make image! 400x400
	process-image my-image ...


and here I realise that there is a name-clash with the 'process-image 
word, which is set only to the value exported by the second author.
So what do I do?

Here are some theoretical approaches, which have their own problems.

1) I could reload each file just before use:

	do %image-processor.r  ; By author #1
	process-image my-image ...
	do %super-gfx.r
	process-image my-image ...


  Each "module" is not expecting to be used this way, so this has problems 
  like:

  - "Static" locals which are intended to remain in memory will be 
  lost each time the file is reloaded.

  - Performance could suffer; each file could be large, and many calls 
  to 'process-image might be done.


2) I could set the first imported word to my own chosen word before 
importing the second "module". eg

	do %image-processor.r  ; By author #1

 process-image2: :process-image  ; Create an alias, as 'process-image 
 will be overwritten next line.
	do %super-gfx.r  ; By author #2

	; Now use
	process-image2 my-image ...
	process-image my-image ...


  But this means that a line of code has been created in the dependency 
  acquisition stage which has a complex interdependence between the 
  two "modules". They are not independent, and so individual dependency 
  acquisition lines can't be easily copied from this code and pasted 
  into a new script and expected to work right away. If copy/pasted, 
  the code will have to be examined, probably in great detail, to discover 
  what's going on and how to make it work. This will lead right back 
  into each source file, where the SET lines which export words to 
  the global context must be found. What great fun that will be in 
  a large software system built using many modules.


Another approach could be to try to bind each module code to a new 
context which contains the exported words, so they are isolated from 
each other... but this is complex.


All the above approaches are attempting to work around a single problem: 
that each "module" is exporting words where and when it likes, without 
consideration for the environment (other "modules", other global 
words etc.) This is "global namespace pollution" and the approaches 
above just introduce more problems in trying to work around it.


The solution to all this, is, in my view, for modules to declare, 
in the script header, the words that are intended to be exported, 
but for the module code not to actually perform the exports. This 
should be done by the user code, at its option. If a large module 
provides an API of 10 functions, then those function words should 
not be forced into the global context. The user script should be 
able to choose which, if any, of those words to import, and into 
which context it would like to import them. Additionally, the exported 
word value should be importable to a differently-named word, which 
can solve the name-clash problem we have above.

If modules do not use SET, but instead declare their "export" words 
in the script header, then digging through code to find side-effects 
should no longer be necessary. In R2, this requires that all module 
authors adhere to this type of module system, and declare their "export" 
words in a standard fashion.


In R3, I'm hoping the module system will develop into one which can 
enforce the modularity of modules, so that a user script can be sure 
that there were no side-effects introduced by loading any module.

I so miss the Amiga's alias command...

Hmm, there is maybe even something like Alias in Windows, no? At 
least in DOS there was some command .... but - never mind, I went 
off-topic here ...

If I gave Firefox the alias of "browse"  would that solve this problem?

Well, some of the module capabilities aren't done yet (as I mentioned 
above), mostly because most of the system hasn't been converted to 
modules yet. One of the current gotchas is that system/contexts/current, 
system/contexts/system, system/contexts/exports, and system/words 
are all the same object. In the final module system, the first three 
should be separate contexts and system/words should be gone (it is 
now an alias for system/contexts/current).

In R2, where as-binary is an alias:
>> a: "aa" same? a as-binary a
== false

Differing word types should behave the same, even when bound to the 
same context.

Equivalent?: ignores datatype differences, alias distinctions, character 
case differences

i never use ALIAS

Re ALIAS -- it has several security and other issues.

Enabling it via SECURE is a good way of limiting the inadvertent 
damage it can do....And of drawing attention to its dangers for any 
casual dabbler.

Robert - do you need such lazy evaluation? I mean - even 'alias seems 
being removed from R3. Don't we have enough of reflectivity? Anyway 
- anyone who imo wants to propose something, should definitely do 
so in terms of CureCode or R3 Chat, or Carl WILL NOT know about the 
request at all, and your only chance here will be BrianH :-)

Just read a R3 blog post about the future of the alias cmd in R3. 
Someone commented that we should see the state of the art : http://www.extjs.com/products/gxt/
 not too foolish but can we do something similar with R2 or R3 ? 
That's where I would like  to go with R2 and R3 ...

dunno ... Carl is less active for more than 2 weeks. Maybe even more 
- Axing alias was typical trick of Carl, to post some less important 
blog and keep us busy :-)

origanally there was just mod  I may have assumed the rest were alias'

some proposals for a short  alias of  QUOTE.
ice
lay
sit

i just think about an alias to shorten our code, the standardd word 
QUOTE would stay.

What if I use different names for the database, and then alias them 
in the webapp init ?  Then could i just run the one Cheyenne?

Same error after upgrading Chromium, here's the verbose 5 log of 
the request:


3/4-01:38:00.891-[HTTPd] ================== NEW REQUEST ==================

3/4-01:38:01.531-[HTTPd] Request Line=>POST /ecg/blah.rsp HTTP/1.1

3/4-01:38:02.109-[HTTPd] Trying phase method-support ( mod-static 
)

3/4-01:38:02.828-[HTTPd] Trying phase url-translate ( mod-static 
)
3/4-01:38:03.062-[uniserve] Calling >on-received< with {^M
Host: localhost:8080^M
Connection: keep-alive^M
Us}
3/4-01:38:03.547-[HTTPd] Request Headers=>
Host: localhost:8080
Connection: keep-alive

User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/530.5 
(KHTML, like Gecko) Chrome/2.0.173.0 Safari/530.5
Referer: http://localhost:8080/ecg/blah.html
Content-Length: 153149
Cache-Control: max-age=0
Origin: http://localhost:8080

Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryEv3SZArZWdjyznJZ

Accept: application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5
Accept-Encoding: gzip,deflate,bzip2,sdch
Accept-Language: en-US,en;q=0.8
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.3



3/4-01:38:03.797-[HTTPd] Trying phase url-to-filename ( mod-alias 
)
3/4-01:38:04.031-[HTTPd] => request processed
3/4-01:38:04.766-[HTTPd] Trying phase url-to-filename ( mod-rsp )
3/4-01:38:05-[HTTPd] => request processed

3/4-01:38:05.469-[HTTPd] Trying phase url-to-filename ( mod-internal 
)

3/4-01:38:05.719-[HTTPd] Trying phase url-to-filename ( mod-static 
)
3/4-01:38:05.969-[HTTPd] => request processed

3/4-01:38:06.453-[uniserve] >> Port: 3789, low-level reading: 17520

3/4-01:38:06.703-[uniserve] >> Port: 3789, low-level reading: 17520

3/4-01:38:06.953-[uniserve] >> Port: 3789, low-level reading: 17520

3/4-01:38:07.437-[uniserve] >> Port: 3789, low-level reading: 17520

3/4-01:38:07.906-[uniserve] >> Port: 3789, low-level reading: 19980

3/4-01:38:08.391-[uniserve] Calling >on-received< with "------WebKitFormBoundaryEv3SZArZWdjyznJZ^M^/Content-"

3/4-01:38:08.875-[uniserve] >> Port: 3789, low-level reading: 16680

3/4-01:38:09.344-[uniserve] >> Port: 3789, low-level reading: 17520

3/4-01:38:09.844-[uniserve] >> Port: 3789, low-level reading: 17520

3/4-01:38:10.312-[uniserve] >> Port: 3789, low-level reading: 1149

3/4-01:38:10.797-[uniserve] Calling >on-received< with {037.17923" 
"4429 SUNNYSLOPE RD SW" "Port Orchard" }

3/4-01:38:11.266-## Error in [uniserve] : On-received call failed 
with error: make object! [
    code: 303
    type: 'script
    id: 'expect-arg
    arg1: 'insert
    arg2: 'series
    arg3: [series! port! bitset!]
    near: [insert/part tmp/port s skip e]
    where: 'process-bounded-content
] !
3/4-01:38:11.734-[uniserve] Port closed : 127.0.0.1

Currently there's only URL=>script aliasing available, but looking 
at the ALIAS code, I think that : 
	alias ".html" /cgi-bin/rebol-cgi-dispatch.cgi

might work (need to be tested). Do you really think that there's 
much users waiting for that feature?

Maybe alias can do as well, look in heepd.cfg, there are examples 
for both

also alias is not working for me.

Henrik, trying to answer your questions/issues :


to serve multiple document roots on the same site without having 
separate domain names

 => Use sub-domains for such isolation. Everything that's under one 
 domain can be accessed with /.. parent syntax. I think that you can 
 hack it around with ALIAS, custom webapps on-page-start event  handler, 
 but there aren't clean solutions. Use sub-domains for such isolation.

I think webapps require a bit more than static pages?

 => Just to make it clear, webapps are REBOL applications interfaced 
 with external world using RSP scripts. Webapp are not meant to be 
 container for *only* static pages (HTML/CSS/JS/images).


attempt [load join request/config/root-dir %/app-init.r] ; TBD: report 
errors !!! [...] 
RSP: error in events from %app-init.r now logged. 
That's from the change log. That's not correct.

 => Yes it is. What's being logged so far is the errors caught at 
 runtime in event functions declared in app-init. What need to be 
 logged is the LOAD %app-init.r process (syntax errors at boot time).


after a lot of experimentation, the latest encapped version was the 
only one that worked properly.

 Both encap and sources versions works well on Win/Mac/Unix. The issues 
 you have are related to running a rebol app as daemon in console 
 mode on a remote Unix server (without a UI desktop). Cheyenne can 
 work in source mode on such server, but it's much easier and pratical 
 to use it in binary form in such case (typical remote linux server 
 case).

looking into mod-alias to see what's going on.

Try with ALIAS keyword. See ChangeLog file for more info (search 
for ALIAS).

alias "/path/to/target" %script  -- I found this  .. can I use regex 
or something else to do 

AliasMatch ^/some-(.*) /script.rsp?a=$1

Btw, alias "/path" %script, should work for whole /path/*.

could I do something like alias all except some pattern: for example 
all except /static/

alias "/show/" %www/mobispots.net/show.rsp -- gives me normal 404 
of cheyenne  (or any nonexistent file) 
<html><body><h1>404 Page not found</h1></body></html>

alias "/show/" %show.rsp -- gives me 
#[object! [
    code: 502
    type: access
    id: cannot-open

    arg1: %/D/devel/cheyenne0919/www/mobispots.net/www/mobispots.net/
    arg2: #[none]
    arg3: #[none]
    near: [change-dir first splitted: split-path file]
    where: #[none]
]]

There no exceptions support in Alias. The rewrited url should be 
available in request/headers/location.

this is my config that makes error when I go on localhost/show/
default [	
	root-dir %www/mobispots.net/	
	default [%index.html %index.rsp %index.php]	
	on-status-code [ 404 "/custom404.html" ]	
	alias "/show/" %show.rsp
]

It's not related to ALIAS but to another config option (REDIRECT).

anyone here had problem using mod-alias? I'm not using it but have 
an old patch and would appreciate some user cases where current version 
fail before subitting to Dock, thx

On WinXP, I can not get Alias to work... e.g.  alias "/docs" %md.rsp 
    Is there any debugging mode to see what Alias thinks I am asking 
it to do?  From my testing, the .rsp script is not being invoked. 
 Can there be  an Alias in each sites definition in the config file?

MikeL, I've added the alias issue to the new CC instance for Cheyenne. 
I let you add a ticket for the path issue with worker-libs.

Is there any debugging mode to see what Alias thinks I am asking 
it to do?
 


Yes, with at least verbose level 2 (-vv), you get the "Translated 
file:" log line showing you the target file once config file rules 
have been applied.

Doc yeah... I'm starting to be pretty knowledged on the phases (though 
some things still elude me a bit).


I'm just saying that some mods... like extapp, expire, action, alias, 
internal, etc...  probably have non-negligible effects in the chain 
that some other modules might react to or not (depending).  and its 
currently quite tricky to understand what effects the mods actually 
have on requests and response.


anyhow, as usual, Its not critique its just observation from someone 
"outside the box"   :-)

i have a couple of ideas how to hack this, but what would be the 
correct" way?"


You could try using the ALIAS config option. Add this to the httpd.cfg 
file in a domain section (not sure if it would work in a webapp context):

    alias "/rest" %rest.rsp

and call your REST resources with:
    /rest/asd 
    /rest/qwe


In %rest.rsp, you can put your URL parsing code to produce a "REST 
routing" and return the JSON object. It might also work with "/" 
(untested).

Dockimbel: the alias "/" %x.r works too. beautiful.

onetom ~/rebol/delete $ cat httpd.cfg 
modules [ internal extapp static rsp alias ]
globals [ listen [8888]    bind RSP to [ .r ] ]
default [ debug root-dir %./ alias "/test" %test.r ]

onetom ~/rebol/delete $ cat test.r 
<% print request %>


onetom ~/rebol/delete $ rm chey-*.log; rebol -qws ~/rebol/cheyenne-server-read-only/Cheyenne/cheyenne.r 
-w 0 -vvv


onetom ~/rebol/delete $ curl -X DELETE -D- http://localhost:8888/test
HTTP/1.1 404 Not Found
Server: Cheyenne/0.9.20
Date: Wed, 20 Apr 2011 11:14:04 GMT
Content-Length: 53
Content-Type: text/html
Connection: close

<html><body><h1>404 Page not found</h1></body></html>


>> p: open/no-wait/direct tcp://localhost:8888
>>  insert p "DELETE /show.rsp HTTP/1.0^/^/"
>> probe copy p
{HTTP/1.1 404 Not Found
Server: Cheyenne/0.9.20
Date: Wed, 20 Apr 2011 11:17:34 GMT
Content-Length: 53
Content-Type: text/html
Connection: close

<html><body><h1>404 Page not found</h1></body></html>}



u were doing 1.0 DELETE request though, but it didn't make any difference.

onetom ~/rebol/cheyenne-server-read-only/Cheyenne $ svn up
U    mods/mod-action.r
Updated to revision 131.

- modules [ internal extapp static rsp alias ] : it is missing 'action 
module which is required for external handlers (RSP and CGI)

im trying to put an alias into a webapp. is it possible?

In theory, it should be possible, but never tested. I'm having a 
quick look at 'alias code atm...

I don't see anything in the 'alias implementation preventing it to 
work from within a webapp.

Works here. Here is my webapp config:
	webapp [
		virtual-root "/testapp"
		root-dir %www/testapp/
		auth "/testapp/login.rsp" 
	
		alias "/testapp/hello" %testapp/login.rsp
	]

btw, that error at ! is logged even if my cfg file is only
$ cat httpd.cfg
modules [ internal extapp static action rsp alias ]
globals [ listen [8080]    bind-extern RSP to [ .r ] ]

hmm... cheyenne binary and the source works differently w the same 
configfile.
$ cheyenne --version
0.9.20.129
WORKS
latest source doesn't work with the following config:

modules [ internal extapp static action rsp alias ]
globals [ listen [8080]    bind RSP to [ .r ] ]
guan-huat [ debug root-dir %./ alias "/docs" %jsondb/to-json.r ]

im testing w $ curl http://guan-huat:8080/docs/test/1

hmm... how can i map a directory under a certain path in vhost? im 
trying this:
yp [  root-dir %~/p/ob/yp  alias "/public" %../public/ ]

then for curl http://yp:8080/public/angular-0.9.15.min.js  i get

HTTP/1.1 301 Moved Permanently
Location: /public/angular-0.9.15.min.js/

wtf?

i remember seeing something like "/some/path" [ options ] in a vhost 
config block, but i can't find anything about it now

im loading libraries from on-application-start, then i was hoping 
to load some static data too, but the words i assign there can't 
be found in my script later.

the script is called via an alias though which was specified within 
a webapp section.

on-application-start: does [
do %some/lib.r
db: %db/dir/some/where/
]

httpd.cfg:
vhost [
  webapp [
    alias "/xxx" "db.r"
  ]
]


db.r can't access the db variable, although it can use the words 
defined in the library loaded by 'do

By the way, I still want to get rid of the loading of the REBOL CGI 
script on each request, even though I've minimised its size. It's 
a fallback script that now executes in the not-found handler. If 
I would change it from a fast-rebol-cgi script to an .r script, and 
put it in an ALIAS handler, would that preempt the loading of the 
script one each request? I'm not using the RSP interface, so the 
loading of that would be extra overhead. Would it still be faster 
than loading the small fast-rebol-cgi script?

When using a Mac, you look at an OpenGL output. If you use the zoom 
function, there is a key combination to put anti-alias on/off. If 
it's off, you see the correct pixels, as there is in the drawing 
(bitmap). But you're right, if you put in anti-aliasing and other 
effects, it can look different on different hardware.

Reposting from R3 chat (which seems a bit quiet lately).


I've been looking at the rich text gob! functionality and it seems 
the following dialect commands are supported:

	anti-alias logic!
	bold [off]
	italic [off]
	underline [off]
	size integer!
	left|center|right
	drop integer!
	font object!
	para object!
	caret object!
	scroll pair!
	string!


Are there any I've missed? Any doco on this yet? I havn't figured 
out how to use drop or caret yet. Anyone have any working examples 
for these?


A design question: is there any reason for retaining font and para 
support given that we could move the few remaining unsupported words 
out of those objects and into the dialect itself? (e.g. have the 
dialect directly support font names and valign words).


Also, it would be nice if we had control over the default font name, 
size and alignments [at the very least]. Perhaps a system/view/text 
object?

Any way of using anti-alias with caret? Seems:

	[text: [anti-alias on s caret c]]


kills the caret and font/para objects don't have an anti-alias word.

Just tried to run the style-browser.r3 on Amiga and hit the following 
problem
>> do %r3-gui.r3

Script: "Untitled" Version: none Date: none

>> do %style-browser.r3

 Script: "R3 GUI Style Browser" Version: $Id: style-browser.r3 1179 
 2010-11-19 18:11:46Z Rebolek $ Date: none
** Script error: cannot 
 MAKE/TO image! from: make gob! [offset: 0x0 size: 400x300 alpha: 
 0 draw: [clip 0x0 400x300 anti-alias false pen false fill-pen 192.192.192 
 box 1x1 399x299 0 fill-pen false pen 64.64.64 line-cap square line-width 
 1.0 variable line [0x0.5 399x0.5] line-cap square line-width 1.0 
 variable line [0.5x0 0.5x299] line-cap square line-width 1.0 variable 
 line [0x299.5 399x299.5] line-cap square line-width 1.0 variable 
 line [399.5x0 399.5x299] clip 6x6 394x294 translate 6x6 line-width 
 1.0 variable pen 255.255.255 fill-pen false anti-alias true clip 
 0x0 0x0 pen false line-width 0.0 variable grad-pen linear normal 
 1x1 0x2...

Any ideas?

Suggest both alternatives: Renaming it, or making an alias.

yes.... wtf? as a small undocumented easter egg could be a nice little 
rebol detail   :-D   

basically it could be an alias for why?

The original was written before MAP-EACH and the new COLLECT. Here 
is the source I have, updated to use those as the current version 
does, but with the last rule reverted to the original.

Related cc reports: 
    http://issue.cc/r3/1096
    http://issue.cc/r3/690

split: func [

    "Split a series into pieces; fixed or variable size, fixed number, 
    or at delimiters"
    series	[series!] "The series to split"

    dlm		[block! integer! char! bitset! any-string!] "Split size, delimiter(s), 
    or rule(s)." 

    /into	"If dlm is an integer, split into n pieces, rather than pieces 
    of length n."
    /local size count mk1 mk2
][
    either all [block? dlm  parse dlm [some integer!]] [
            map-each len dlm [
                either positive? len [
                    copy/part series series: skip series len
                ] [
                    series: skip series negate len

                    ; return unset so that nothing is added to output
                    ()
                ]
            ]
    ][
        size: dlm   ; alias for readability
        collect [
            parse/all series case [
                all [integer? size into] [

                    if size < 1 [cause-error 'Script 'invalid-arg size]
                    count: size - 1
                    size: round/down divide length? series size
                    [

                        count [copy series size skip (keep/only series)]
                        copy series to end (keep/only series)
                    ]
                ]
                integer? dlm [

                    if size < 1 [cause-error 'Script 'invalid-arg size]

                    [any [copy series 1 size skip (keep/only series)]]
                ]

                'else [ ; = any [bitset? dlm  any-string? dlm  char? dlm]

                    [any [mk1: some [mk2: dlm break | skip] (keep copy/part mk1 mk2)]]
                ]
            ]
        ] 
    ]
]

split: func [

    "Split a series into pieces; fixed or variable size, fixed number, 
    or at delimiters"
    series	[series!] "The series to split"

    dlm		[block! integer! char! bitset! any-string!] "Split size, delimiter(s), 
    or rule(s)." 

    /into	"If dlm is an integer, split into n pieces, rather than pieces 
    of length n."

    /local size piece-size count mk1 mk2 res fill-val add-fill-val
][
    either all [block? dlm  parse dlm [some integer!]] [
        map-each len dlm [
            either positive? len [
                copy/part series series: skip series len
            ] [
                series: skip series len
                ; return unset so that nothing is added to output
                ()
            ]
        ]
    ][
        size: dlm   ; alias for readability
        res: collect [
            parse/all series case [
                all [integer? size  into] [

                    if size < 1 [cause-error 'Script 'invalid-arg size]
                    count: size - 1

                    piece-size: to integer! round/down divide length? series size
                    if zero? piece-size [piece-size: 1]
                    [

                        count [copy series piece-size skip (keep/only series)]
                        copy series to end (keep/only series)
                    ]
                ]
                integer? dlm [

                    if size < 1 [cause-error 'Script 'invalid-arg size]

                    [any [copy series 1 size skip (keep/only series)]]
                ]

                'else [ ; = any [bitset? dlm  any-string? dlm  char? dlm]

                    [any [mk1: some [mk2: dlm break | skip] (keep/only copy/part mk1 
                    mk2)]]
                ]
            ]
        ]

        ;-- Special processing, to handle cases where the spec'd more items 
        in

        ;   /into than the series contains (so we want to append empty items),

        ;   or where the dlm was a char/string/charset and it was the last 
        char

        ;   (so we want to append an empty field that the above rule misses).
        fill-val: does [copy either any-block? series [[]] [""]]
        add-fill-val: does [append/only res fill-val]
        case [
            all [integer? size  into] [

                ; If the result is too short, i.e., less items than 'size, add
                ; empty items to fill it to 'size.

                ; We loop here, because insert/dup doesn't copy the value inserted.
                if size > length? res [
                    loop (size - length? res) [add-fill-val]
                ]
            ]
            ; integer? dlm [
            ; ]

            'else [ ; = any [bitset? dlm  any-string? dlm  char? dlm]

                ; If the last thing in the series is a delimiter, there is an

                ; implied empty field after it, which we add here.
                case [
                    bitset? dlm [

                        ; ATTEMPT is here because LAST will return NONE for an 

                        ; empty series, and finding none in a bitest is not allowed.

                        if attempt [find dlm last series] [add-fill-val]
                    ]
                    char? dlm [
                        if dlm = last series [add-fill-val]
                    ]
                    string? dlm [
                        if all [
                            find series dlm
                            empty? find/last/tail series dlm
                        ] [add-fill-val]
                    ]
                ]
            ]
        ]
                
        res
    ]
]

split: func [

    "Split a series into pieces; fixed or variable size, fixed number, 
    or at delimiters"
    series	[series!] "The series to split"

    dlm		[block! integer! char! bitset! any-string!] "Split size, delimiter(s), 
    or rule(s)." 

    /into	"If dlm is an integer, split into n pieces, rather than pieces 
    of length n."

    /local size piece-size count mk1 mk2 res fill-val add-fill-val
][
    either all [block? dlm  parse dlm [some integer!]] [
        map-each len dlm [
            either positive? len [
                copy/part series series: skip series len
            ] [
                series: skip series negate len
                ; return unset so that nothing is added to output
                ()
            ]
        ]
    ][
        size: dlm   ; alias for readability
        res: collect [
            parse/all series case [
                all [integer? size  into] [

                    if size < 1 [cause-error 'Script 'invalid-arg size]
                    count: size - 1

                    piece-size: to integer! round/down divide length? series size
                    if zero? piece-size [piece-size: 1]
                    [

                        count [copy series piece-size skip (keep/only series)]
                        copy series to end (keep/only series)
                    ]
                ]
                integer? dlm [

                    if size < 1 [cause-error 'Script 'invalid-arg size]

                    [any [copy series 1 size skip (keep/only series)]]
                ]

                'else [ ; = any [bitset? dlm  any-string? dlm  char? dlm]

                    [any [mk1: some [mk2: dlm break | skip] (keep/only copy/part mk1 
                    mk2)]]
                ]
            ]
        ]

        ;-- Special processing, to handle cases where the spec'd more items 
        in

        ;   /into than the series contains (so we want to append empty items),

        ;   or where the dlm was a char/string/charset and it was the last 
        char

        ;   (so we want to append an empty field that the above rule misses).
        fill-val: does [copy either any-block? series [[]] [""]]
        add-fill-val: does [append/only res fill-val]
        case [
            all [integer? size  into] [

                ; If the result is too short, i.e., less items than 'size, add
                ; empty items to fill it to 'size.

                ; We loop here, because insert/dup doesn't copy the value inserted.
                if size > length? res [
                    loop (size - length? res) [add-fill-val]
                ]
            ]
            ; integer? dlm [
            ; ]

            'else [ ; = any [bitset? dlm  any-string? dlm  char? dlm]

                ; If the last thing in the series is a delimiter, there is an

                ; implied empty field after it, which we add here.
                case [
                    bitset? dlm [

                        ; ATTEMPT is here because LAST will return NONE for an 

                        ; empty series, and finding none in a bitest is not allowed.

                        if attempt [find dlm last series] [add-fill-val]
                    ]
                    char? dlm [
                        if dlm = last series [add-fill-val]
                    ]
                    string? dlm [
                        if all [
                            find series dlm
                            empty? find/last/tail series dlm
                        ] [add-fill-val]
                    ]
                ]
            ]
        ]
                
        res
    ]
]

For the sake of completeness, here are the highlights of the alpha 
108 changes:

- Script headers can have an options block, a simple block of flag 
words. User extensible.

- The standard script header now has a lot fewer words in it. More 
stuff is optional or in the options block.

- Script compression, either binary and base 64 binary! encoded. 
Automatic, transparent.

- Script checksums, both to verify the script and for IMPORT to compare 
with. Applies to decompressed source.

- An optional script length header field (like http's Content-Length). 
This allows binary script embedding.

- Internal support for getting the end of an embedded script, so 
a multi-loader is possible.

- The 'content and 'isolate header fields are changed to option words. 
The content is still saved to a 'content header field.

- The 'content field, if set, is set to the start position of the 
script proper, even if there is stuff before it.

- The whole system/contexts/system concept is gone, as part of the 
system restructuring. Now we have SYS.

- The system/contexts/exports concept is gone too, replaced by a 
not-module-specific runtime library called LIB.

- The old type: 'extension is now the 'extension header option word. 
The only module type is 'module. And it's optional for most code.

- Mixins are now called "private modules", and are flagged by the 
'private option word. And they can have names.

- Private modules can be added to the system modules list (because 
of the names). This lets them be reused without being reloaded.

- Unnamed modules are now prohibited (until alpha 109, where they 
become private modules that reload every time).

- Delayed modules, which can be partially loaded and then not fully 
made until they are imported. Use the 'delay option word.

- A HIDDEN module source keyword, which applies PROTECT/hide to a 
word or words. Acts like the EXPORT keyword.

- Better errors are triggered when the bad things happen. Including 
new error codes.

- DO and MAKE--MODULE intrinsics are now in sys, as DO* and MAKE-MODULE*. 
No more system/intrinsics.

- DO-NEEDS is no longer exported (it's in sys). IMPORT block is a 
public alias for DO-NEEDS anyways.

- MODULE now makes modules that act more like those in script files. 
And has /mixin support too.

- A whole bunch of changes and fixes to native functions to support 
the above stuff.

How about a minor addition to/restructuring of the comparison functions:
- equal?
- equiv?: equal + binding

- strict-equal?: equal + type + case + alias + decimal  (but _no_ 
binding)
- srict-equiv?: strict-equal + binding
- same?: as currently


(See http://www.rebol.net/wiki/Comparisons#EQUAL.3Ffor the status 
quo.)

strict-* makes alias distinctions.

Oh, right. All words are aliased. That's how case insensitivity is 
implemented in R3. So case = alias for words.

maybe alias implies case, but case does not imply alias.

What we seem to be missing at the moment is a comparison function 
with ignores binding but is otherwise "strict" in the sense of type/case/alias/decimal 
precision.

So let's update this with the decimal precision moved:

- equal?
- strict-equal?: equal + type + case + alias

- equiv?: equal + binding + decimal 
- strict-equiv?: equiv + type + case + alias

- same?: as currently

Edit "no aliasing" to "alias distinctions". Thanks.

Equal plus alias distinction
 was clearer to me.

Actually, that feature might go away. The ALIAS function has been 
a big hassle in R3 because of the lack of a central system/words 
repository. We are likely to keep the aliasing facility for internal 
use to implement case insensitivity, but the ALIAS function to do 
other kinds of aliasing may go away.

But as of A110, we still have it  :) So to formulate the wish on 
that basis, we need to take it into account, or someone else will 
hassle us about having left out alias.