[DotGNU]C@ goes dynamic / box files

[Peter Minten]

Hi,

it's Saturday again, which means I have some new stuff from the IRC meeting to
report. After the helpdesk (aka Rhys :-) closed we (James Mc Parlane, BioChem333
and me) discussed address@hidden The following things came out of the dicussion:

* C@ will have dynamic aspects, this means aspects aren't compiled into the code
in a preprocessor fashion like I origninally intended but are applied at runtime
and can be changed at runtime.
* To support dynamic aspects the reflection capabilities of the runtime engine
will be expanded by the C@ hackers (aka don't blame Rhys for those changes). The
expanded reflection capabilities will be made available to C@/C# programmers
through DotGNU.Reflection in DotGNU-Base.
* C@ will have dynamic inheritance (this was decided before but it's important
to mention it again), this means that a class can change it's parent on the fly,
this makes the aspect stuff a lot easier.

The extended reflection system could also open the door for a lot of cool
possibilities: redefinition of methods at runtime (remember SilverScript, this
was the key feature), templates/generics, compiling interpreted languages. Note
that these are non-very-well-reality-checked possibilities for the future,
dreams so to say, they may work, they may not work, we'll have to wait and see.

A few theoretical problems and a lot of practical problems would have to be
solved but I think we can do this. And if we succeed we would have the killer
language that could give MS some big nightmares. The big advantage of C@ is that
MS doesn't have a compiler for it (and if they build one they will implicitely
admit that we did a better job that they did :-) so everybody using C@ will have
to use DotGNU tools, improving our marketshare.

Unfortunately dreams cannot come true without a lot of hard work, so I'd like to
encourage everybody to help with C@ development :-).

--

Another matter discussed at the meeting was the size problem, C@ seemed to
create big files which are problematic for the net, after a few minutes we
discoverred that dynamic aspects reduce the size dramatically, but it got me
thinking. What if we would have a jar like system for IL: combining multiple IL
bytecode files in a compressed file. We could give the compressed file a .box
extension. Executing the file would be relatively easy, simply unzip the file
into a temp dir or into memory and run from there.

Greetings,

Peter