[Mono-devel-list] Mono Runtime AOP - Book recommendation for the runtime

[Jonathan Pryor]

On Wed, 2004-10-20 at 03:38, Christoph Stiedl wrote:
<snip/>
> The topic of my internship is to extend the mono runtime with aspect
> behavior. (AOP = Aspect Oriented Programming)
> 
> At the moment I've got no glimpse where to start understanding mono. I
> have to implement additional code at loading classes, jit compiling
> classes and rejitting classes. Could you please help me to find the
> corresponding places in the code.

In the "mono" CVS module, read everything in the "docs" directory (in
particular "docs/mini-doc.txt").

The JIT compilation code is in mono/mini.  (The mono/jit directory is an
older version of the JIT engine; mono/mini is the current version.)

It should also be noted that there is no support to "re-JIT" a class. 
Classes are only JITted once.

> Furthermore I'd be very happy if you could recommend me some books to
> read for understanding the runtime and its behavior. For short: Which
> books should I read to understand mono?  I have already visited the
> "book" page on the homepage
> (http://www.mono-project.com/about/books.html), but those books are 
> rather more about compilers. What I would like to ask is, if there are
> some good books about runtimes themselves and about the architecture,
> mainly corresponding to mono.

A JIT engine *is* a compiler, so books about compilers are very
pertinent. :-)

The other parts of the "runtime" include mono/io-layer, a Win32 API
compatible layer which is used for file I/O (to simplify Windows/Unix
portability); libgc, the garbage collector; mono/metadata, for metadata
handling (e.g. getting the classes & class members within an assembly);
and other support areas (profiling, platform-specific code, etc.).

Then there's the C# class library, in the "mcs" CVS module, in the
"class/ASSEMBLY-NAME" directory.

You should also read the Papers section of the mono site: 

	http://www.mono-project.com/about/papers.html

As for how all the disparate parts fit together, I don't know of any
books that discuss it.

I would also suggest that you read up on ContextBoundObject, which is
another way to get AOP-like behavior within .NET.  (Summary: it uses the
remoting infrastructure to "capture" method calls & member access.  It's
like remoting, but *within* an AppDomain instead of between AppDomains. 
This would allow you to "easily" trace method calls, AFAIK a common AOP
example.)  The downside to ContextBoundObject is that it "burns a base
class", so you can't use it in all circumstances.

 - Jon