Jb in a nutshell: Category AspectDNG

At least I've slept in Seattle

jbevain — Sat, 19 Nov 2005 21:13:19 +0100

Previously, in Jb in a nutshell: AOP Goes .NET Workshop

It was my first trip to US, and I liked it.
It was the first time I had to spend almost 24 hours in planes/airport (just for the trip back), and I hated it.

Anyway, the workshop was interesting. It’s clear that Microsoft don’t know how to handle the AOP thing, but at least, it helped a bit. It was very interesting to meet people so motivated by working on AOP on .net. And now, they all know that they can use Cecil as a base assembly to write AOP tool! I will write more on it later on.

To make you wait, a little game, play to: where is Jb ?

AOP Goes .NET Workshop

jbevain — Sat, 22 Oct 2005 15:08:11 +0200

I’ll be there

Microsoft Research AOP Goes .NET Workshop 2005

If you are around between Nov 12-16 and want to talk about AspectDNG and/or Mono.Cecil, drop me a mail !

GMail TrayIcon

jbevain — Wed, 08 Jun 2005 20:30:14 +0200

I’ve played with Lego today

Well, it was some kind of special Lego… I’ve taken bricks from :

A nice tutorial about Tray Icons for GNOME
An perfect and simple example
An amazing Mono Live
GPL icons from a nice project
A simple ATOM feed

With those bricks, I’ve made a very simple and totally incomplete GMail Notification Icon for GNOME. It looks like that:

Yet, it’s no really usable. Username and password are hard-coded, and you just know if you have, or not, unread mails.

If someone is willing to use my code to produce a better applet, he would not have a lot of things to do. The list is simple:

Use GConf to save username and password
Write a really simple window to ask user whether or not username and password have to be stored
Write another simple window to be shown when a new mail arrives, and then disappears

This nice person will find the code here: GMailTray

May starts

jbevain — Mon, 02 May 2005 14:04:41 +0200

ildasm

I’ve spent two days refactoring the old code i’ve wrote for ildasm. After that, i realized i was wrong in the way i should have made it. I’m currently using the top level of Cecil, manipulating ITypeDefinition, ICustomAttribute, etc. This is plain wrong for a disassembler, that need more low level access. So i have to rewrite it using the middle level, manipulating metadata tables, signatures, byte arrays, etc. I have to go this way because there is a loss of data when you go a level up of abstraction, for instance, i miss all the metadata tokens, that Msft’s ildasm prints in comments. I also want to implement natively the /adv switch of Msft’s ildasm, that has been proved to be very usefull when you write compilers, or other assembly manipulating tools. Two days lost. It will learn me to think better before starting writing code i guess. As soon as i have something usable, you’ll find it in the cecil module of Mono’s SVN.

Academic days

I’ve spent three days last week near the Eiffel tower, at Microsoft’s academic days. Some very good sessions, one about the Phoenix project, guys, they are working on what i have in my mind for years. It’s very impressive, maybe my school could apply to the academic program associated. I’ve met Serge Lidin, that is the author of Microsoft’s ildasm, ilasm, peverify, and so on. He talked about the future of the MSIL language, there is not a lot of work to provide to be .net 2 compatible in those tools. Patrice have a pic of me, talking to both Serge Lidin and Mark Lewin, from the SSCLI project, (i’m in the middle) :

It seems that my talk about AOP and AspectDNG was not so bad, some people contratulate me after, and I had a lot of good questions. Anyway, people like researchers love AOP. You can download my slides : “Meet Alice” (yeah, AspectDNG is wonderful…, sorry, it is written in french). So it was three real good days (eating very good food for free, in an hotel the room was bigger than my apartment during three days was cool too).

A funny anecdote, there was a little talk about Mono, it was quite good, the guy used my slides from the DotNetGuru’s Symposium, and at the end, he claims that he wanted to show the PetShopDNG running on the top of XSP, but that it does not works. He tried, but XSP was reporting an exception. Fortunately, i’ve made running the PetShopDNG on Mono, and i’ve even presented it at the DotNetGuru’s Symposium, and i saw the exception. In fact, the PetShopDNG was simply misconfigured. I told it to the guy, that invited me to make this thing work. After two little changes in the Web.config, the PetShopDNG was running on the top of XSP, without any modification. Really cool. As it was the end of the talk, i’ve asked for questions about Mono, and for 15 minutes, i’ve answered to them. It’s good too see that people are really interested in Mono.

Levenshtein Distance

Following Nat’s links, i’ve discovered the Levenshtein Distance algorithm, so i decided to write it in C#. Thanks to others examples, it was really easy, and i still don’t know why i did that. You’ll find the whole stuff, including simples tests here : http://evain.net/public/Levenshtein.zip.

The Module, a new Design Pattern ?

jbevain — Mon, 25 Apr 2005 15:31:04 +0200

I’m partially enthusiast about the partial classes. Here is a sample of code that a French Microsoftee presented to us :

<!~~- code formatted by http://manoli.net/csharpformat/ -~~>

<span class="kwrd">public</span> <span class="kwrd">partial</span> <span class="kwrd">class</span> Person
{
    <span class="kwrd">public</span> <span class="kwrd">string</span> firstname;
    <span class="kwrd">public</span> <span class="kwrd">string</span> lastname;

    <span class="kwrd">public</span> Person (<span class="kwrd">string</span> firstname, <span class="kwrd">string</span> lastname)
    {
        <span class="kwrd">this</span>.firstname = firstname;
        <span class="kwrd">this</span>.lastname = lastname;
    }

    <span class="kwrd">public</span> <span class="kwrd">void</span> Format ()
    {
        <span class="rem">// ...</span>
    }
}

<span class="kwrd">public</span> <span class="kwrd">partial</span> <span class="kwrd">class</span> Person
{
    <span class="kwrd">public</span> <span class="kwrd">static</span> Person FromDataRow (DataRow r)
    {
        <span class="rem">// ...</span>
    }

    <span class="kwrd">public</span> <span class="kwrd">static</span> Person FromAnotherDataSource (DS s)
    {
        <span class="rem">// ..</span>
    }
}

Isn’t it a neat design ? Grrrr, I know this is only a sample, to explain the partial keyword, but i know that lots of people will use it this way. Please, use only the partial keyword where it is meant to be.

April come she will

jbevain — Sun, 24 Apr 2005 14:44:47 +0200

Tech’Ed

Microsoft invited me to the Tech’Ed Europe, some sessions seems very promising. The good point is that I have not yet visited Amsterdam, this is the occasion. I hope to see people there, feel free to mail.

AspectDNG

Thomas Gil have started using Cecil to produce ILML inside AspectDNG, sounds like he is waiting for me to end my job, so that he can use Cecil to convert an ILML file to a valid assembly.

OPath

Sebastien Ros offered me for Christmas his OPath parser library. Two options, I can write a clone of its Eon library that uses it, so that we could query objects graphs, just like Sebastien does. If I go this way, the Evaluate method should be a generic one, so that we could return strongly typed collections or items. The second option is to integrate natively into Cecil the ability to query the assembly, but it is too much Cecil centric, I’m sure other people wants to play with OPath !

Microsoft Research

I’m finishing my slides for Tuesday, again, the agenda is very promising, the thematic this year is Software Engineering, Architectural Design and High Performance Computing. Hope they’ll enjoy AOP AspectDNG’s way. I’ll be hosted there, (even if I live at 15 minutes from there). Every details here.

XScale

I’ve look toward installing Linux on my Dell Axim X30 (I don’t really know what to do with it), but it looks like it will be a very time consuming task, the Linux port is not really ready. However, I’ve added a new entry in my TODO list: trying to port Mini, Mono’s JIT, to this architecture, so that I can learn from inside the Mono runtime. I’ll need help, but Massi said one time that he was working on this on his spare time, and there is some interesting threads in the devel list to read fist. Sounds like it is a good holiday work, but I have to finish Cecil first!

Journ�e Acad�miques 2005

jbevain — Wed, 23 Mar 2005 23:59:30 +0100

I have the honor to be one of the speaker of the “Academic Days” event, my talk is about Aspect Oriented Programming on the .net framework.

I have to admit that i’m really impressed, I’ll meet there people like John Lefor, PM for the Phoenix project at MSR. It seems that we share some ideas on compiler design, I hope I’ll be able to talk with him a little. Serge Lidin, the author of Inside .NET IL Assembler, and the writer of ildasm, ilasm, peverify, ..., will be here too, talking about the the evolution of the CIL. Be sure I’ll hear carefully ! Should be 3 exciting days ! All details here.

White box unit testing with AspectDNG

jbevain — Thu, 13 Jan 2005 01:16:21 +0100

Last time, Tom was kidding me (softly) about the fact that we can do almost everything we want with AspectDNG. I begin to think he wasn’t wrong…

Once again, here is a very, very complex system that should be hard tested:

<!~~- code formatted by http://manoli.net/csharpformat/ -~~>

<span class="rem">// Main.cs</span>

<span class="kwrd">using</span> System;

<span class="kwrd">public</span> <span class="kwrd">class</span> ComplexSystem {

    <span class="kwrd">private</span> <span class="kwrd">int</span> m_secret;

    <span class="kwrd">public</span> ComplexSystem() {
        m_secret = 0;
    }

    <span class="kwrd">private</span> <span class="kwrd">void</span> SecretOperation(<span class="kwrd">int</span> oper) {
        m_secret += oper;
    }

    <span class="rem">// should always return a multiple of 2</span>
    <span class="kwrd">public</span> <span class="kwrd">int</span> PublicOperation() {
        <span class="kwrd">if</span> ((m_secret % 2) != 0) {
            SecretOperation(1);
        }
        <span class="kwrd">return</span> m_secret;
    }
}

This can be safely compiled to a Main.dll.
Ok, this ComplexSystem is the central point of your next application, you NEED to test it. What can be better than NUnit ? But here is the problem, you would like to be sure that the secret operation have a correct behaviour, and that the m_secret field is well setted… Two way to do that, first you use boring Reflection, or you can even take a look behind your back, you ensure that you’re alone, you change the visibility of all this, but you promise yourself that you’ll change it as soon as tests passed. Also you may note that somewhere not to forgot, this is a SECRET operation.

What about introducing a new way of testing this ? Using AspectDNG ? Something I may call white box unit testing ? Here is one aspect to do that :

<!~~- code formatted by http://manoli.net/csharpformat/ -~~>

<span class="rem">// Tests.cs</span>

<span class="kwrd">using</span> System;
<span class="kwrd">using</span> NUnit.Framework;

<span class="rem">// dummy complex system, may have been generated</span>
<span class="kwrd">public</span> <span class="kwrd">class</span> ComplexSystem {
    <span class="kwrd">public</span> <span class="kwrd">int</span> m_secret;
    <span class="kwrd">public</span> <span class="kwrd">void</span> SecretOperation(<span class="kwrd">int</span> oper) {}
    <span class="kwrd">public</span> <span class="kwrd">int</span> PublicOperation() { <span class="kwrd">return</span> 0; }
}

[TestFixture]
<span class="kwrd">public</span> <span class="kwrd">class</span> TestComplexSystem {

    <span class="kwrd">private</span> ComplexSystem m_complexSystem;

    [SetUp]
    <span class="kwrd">public</span> <span class="kwrd">void</span> SetUp() {
        m_complexSystem = <span class="kwrd">new</span> ComplexSystem();
    }

    [Test]
    <span class="kwrd">public</span> <span class="kwrd">void</span> TestPublicOperation() {
        Assert.AreEqual(0, m_complexSystem.PublicOperation() % 2);
        m_complexSystem.SecretOperation(1);
        m_complexSystem.SecretOperation(1);
        m_complexSystem.SecretOperation(1);
        Assert.AreEqual(0, m_complexSystem.PublicOperation() % 2);
        Assert.AreEqual(4, m_complexSystem.PublicOperation());
    }

    [Test]
    <span class="kwrd">public</span> <span class="kwrd">void</span> TestFieldSecret() {
        Assert.AreEqual(0, m_complexSystem.m_secret);
        m_complexSystem.SecretOperation(1);
        Assert.AreEqual(1, m_complexSystem.m_secret);
    }

    [Test]
    <span class="kwrd">public</span> <span class="kwrd">void</span> TestSecretOperation() {
        <span class="kwrd">int</span> cursor = m_complexSystem.m_secret;
        m_complexSystem.SecretOperation(12);
        Assert.AreEqual(12, m_complexSystem.m_secret - cursor);
    }
}

What can we see there ? I use a dummy ComplexSystem, that looks like really close to the real one no ? It is just a trick, with that, I’ll be able to compile this single file into a Tests.dll assembly. Once this is done, all I have to do it to inject the content of my TestComplexSystem into the real ComplexSystem. This can be done with the standard MetaAspect Insert from AspectDNG.
When weaving is done, after using a simple insert advice, here is the result :

“Et voila”, the ComplexSystem is now a test fixture itself. Pretty simple no ?
And this sample works with Mono. Of course it is a very lightweight one, but hey, it looks good !

UPDATE: You can download the sources of the example here. Just compile as described in the post, and run AspectDNG -w on the AspectDNG.xml provided.

So, what do you think about this kind of unit testing ? I’m curious about you opinion !

new DotNetIde("x-develop");

jbevain — Mon, 20 Dec 2004 14:06:55 +0100

This morning Hans Cratz announced in the Mono Devel List the preview release of the new x-develop IDE.
I’m currently trying it, and you know what ? I’m happy. I’m switching my current development to it, just to see. At least it seems to be very promising. I have to admit I’m a bit jealous, it seems that I’m not the only one to want an Eclipse#. Yes, it is cross platform, and if I’ve not tried it under my Linux box, be sure I will.

Here is a quote from the mail :

Feature showcase:

Instant detection of errors throughout all files

No need to compile in order to find out if there are errors. X-develop checks all files in the solution on-the-fly in the background and displays errors in an instant.

Refactoring

X-develop includes refactorings for renaming variables, methods, classes, changing method signature, extracting methods and more.

Productivity features

X-develop boosts productivity with coding tools such as Organize imports, Usage search, Code formatting, Smart templates, Go to class, Go to symbol and more.

VS.net 2005 compatibility

X-develop uses the solutio/project concept from VS.net 2005. Solutions/projects created for Windows can be loaded and modified with X-develop on Linux.

It rocks. I’m now playing with code templates, code metrics. There is a lot of good stuff in this. I’ve not enough time to write a complete review of it, but it’s an interesting article idea for DNG.

Go, try it, and make your own idea. My question now is will it be free ?

Some links :

Edit
I was so excited that I did not even notice that it is written in Java, but does it cares ? A little, I think an Eclipse# written in .net should be a very exciting thing.

Type 6 IOC, weaving the dependency

jbevain — Thu, 16 Dec 2004 17:14:34 +0100

Everybody’s gone weavin’,
Weavin’ D.N.G. !

Life is a beach, let’s try a new meta aspect : ReplaceConstructorCall, and by the way, discover a new type of IOC, not constructor based, not setter based, everything is done by AspectDNG. Maybe this is not even IOC. Don’t care, it’s cool.

I’ve written this today, it’s some kind of proof of concept. It is in CVS now, but maybe it will evolve or change. IOC is one buzz word of today. In one of his (famous) article, in French, and in English, Sami Jaber describes 3 types of commonly used IOC, interface based, getter based, and constructor based. I have named this blog entry after this article on tss. Mainly because I’m not really serious. However, I think that AOP may “eclipse” IOC.
An example is coming.

The beginning, a very simple set of base classes :

<span class="rem">// base.cs</span>
<span class="kwrd">namespace</span> AspectDNG.Sample {

    <span class="kwrd">public</span> <span class="kwrd">interface</span> IComplexSystem {
        <span class="kwrd">void</span> DoTheWholeThing(<span class="kwrd">string</span> a);
    }

    <span class="kwrd">public</span> <span class="kwrd">class</span> MockSystem : IComplexSystem {
        <span class="kwrd">public</span> MockSystem() {}
        <span class="kwrd">public</span> <span class="kwrd">void</span> DoTheWholeThing(<span class="kwrd">string</span> a) {}
    }

    <span class="kwrd">public</span> <span class="kwrd">class</span> Pono {

        <span class="kwrd">private</span> <span class="kwrd">string</span> m_a;
        <span class="kwrd">private</span> IComplexSystem m_system = <span class="kwrd">new</span> MockSystem();

        <span class="kwrd">public</span> Pono(<span class="kwrd">string</span> a) {
            m_a = a;
        }

        <span class="kwrd">public</span> <span class="kwrd">void</span> TryTheThing() {
            m_system.DoTheWholeThing(m_a);
        }
    }

    <span class="kwrd">public</span> <span class="kwrd">class</span> EntryPoint {

        <span class="kwrd">public</span> <span class="kwrd">static</span> <span class="kwrd">void</span> Main(<span class="kwrd">string</span>[] args) {
            Pono p = <span class="kwrd">new</span> Pono(<span class="str">"HELLO IOC6 !"</span>);
            p.TryTheThing();
        }
    }
}

What can we see there ? An interface, describing a complex system we want to use, then a Mock object, that may be avoided, but that is there for type safety, and for bookmarking. After this you find a plain old .net object, that depends on our complex system. The entry point creates the Pono object, and ask him to call its dependency. If you compile that and call it, nothing will happens. Let’s weave the dependencies ! Here is my aspect :

<span class="rem">// aspect.cs</span>
<span class="kwrd">namespace</span> AspectDNG.Sample {

    <span class="kwrd">using</span> AspectDNG;

    [Insert(<span class="str">"module:"</span>)]
    <span class="kwrd">public</span> <span class="kwrd">class</span> RealComplexSystem : IComplexSystem {

        [ReplaceConstructorCall(<span class="str">"* *.MockSystem::.ctor()"</span>)]
        <span class="kwrd">public</span> RealComplexSystem() {}

        <span class="kwrd">public</span> <span class="kwrd">void</span> DoTheWholeThing(<span class="kwrd">string</span> a) {
            System.Console.WriteLine(a.ToLower());
        }
    }
}

This is a concrete implementation of my complex service. I use custom attributes to describe that I want RealComplexSystem to be inserted in the main module of the target assembly, and I use my new ReplaceConstructorCall. It’s explicit, every call to the constructor of MockSystem will be replaced by the constructor of RealComplexSystem. It rocks no ?

If I execute this, my complex system will do its job :

D:/temporary/adng&gt;AspectDNG -dw base.exe aspect.dll
D:/temporary/adng&gt;base
hello ioc6 !
D:/temporary/adng&gt;

So, what do you think about this ?