Dear XOTcl community,
we are working currently on various issues which we think are important for our 1.0 release:
- speedup through byte-code support - better components with introspection facilities - easy to use rel-db interface ...
concerning the first item: i was performing some experiments for providing extension-specific byte-code support, e.g. to allow to register byte-code instructions for the most-used commands in XOTcl (such as [self], next, etc.). through these xotcl-specific bytre-codes we get nice improvements (e.g. [self] is more than 10 times faster, some benchmarks improve by 40%). This improvements require a patch for tcl, which is therefore not acceptable for most people now. We talked to the Tcl implementors to include such a patch, but currently some of them think about a substantial redesign of the bytecode which has much more constraints once extension writers depend on the current design, so i don't expect that a patch with this functionality will be intergrated in tcl in the new future.
however, there is already some influence for XOTcl: In Tcl, compilation is command based: this means, for every call of a command literally available in the the body of a proc, a bytecode sequence can be provided by the command. This means that it is possible to compile the body of method m1 in Object o o proc m1 {} { o set x 123 } o proc m2 {} { [self] set x 234 } to something clever, but not the body of m2, since the command in the body of m2 depends on the results of [self] which the compiler does not know. Since m2 is the much better style, we should address this principal problem, since this will ease future improvements for xotcl. An easy soultion is to provide a tcl-command selfInvoke, which can be byte-compiled. selfInvoke has the following sematics
proc selfInvoke args { eval [self] $args }
and if implemented in C, it leads already to some speedup (without bytecode support), since the call of the tcl command "self" is replaced internally by a call to a c-function.
Another advantage is that the number of [self] in an xotcl script is reduced, an programs might become easier to type ()since less shilft/alt/.. keys have to be pressed) and hopefully less "cluttered" to read.
yet another advantage is that this change makes in a program more visible when a delegation is used (call to a different object) instead of the call of the current object.
since "selfInvoke" is not something i would like to type often either, and this is rather a language primitive, we are considering some syntactical alternatives, and want some input from the "community". Certainly, the explicit call of [self] or to another object will be supported in the future as well.
what do you think about the following variants:
o proc m1 {} { [self] set x 123 } o proc m2 {} { .. set x 123 } o proc m3 {} { = set x 123 } o proc m4 {} { => set x 123 } o proc m5 {} { - set x 123 }
other ideas?
note, that the used symbol cannot be used as an (global) object name (same as with next, self, set, and other global tcl commands)
what do you think?
best regards -gustaf neumann