Also: your understanding of our loadtime weaving is correct. Let me know if you specific questions.

Can you think of any drawback of the needed VM options in the eclipse.ini (except that we need a Sun JVM >= 1.5.0_07, and it shoud not be activated on MacOSX) :
-XX:+UnlockDiagnosticVMOptions
-XX:+UnsyncloadClass

There is not a lot of infos on Google regarding those options…
I am planning to release the next Topcased with those options so we can deploy easily specific hacks to our clients.

Thanks.

I read your blog post and the concepts are more clearer now.

I am really interesting in the technical details of the weaving implementation on the equinox side. Your first link seems to be really interesting on that according to the schematics unfortunately I can’t read german at all .

I guess you are using the loadtime weaving presenting in the paper by patching the bytecode in the ClassLoader to insert hooks to methods that can at least have one role hooking on it : it looks to be the better compromise between perfs (no hit if nothing needs to be hooked on a method, unlike runtime weaving) and ease to use (no modification of the base classes before the execution which is great if we want to hook easily in a library/plugin without modifying it).

thanks for your encouraging comment

> Do you have any data on the performance hit ?

We have done measurements at several levels like: micro benchmarks [1], Eclipse startup time (unpublished), but don’t trust these figures, what really counts is just how *your application* performs with OT/J.

So if you’re concerned about performance, I think it helps more to understand *what* actually incurs any performance costs.

> I understand that it will be slower when a method is surrounded and I am quite ok with that, but does it slow down significantly the whole calling process when no Role is registered on a class ?

A base class that has no role bound to it is totally unaffected. Also, a base method that is not affected by any callin binding is totally unaffected.

Only if a callin binding exists, two kinds of costs have to be paid: for each base object the first dispatch may need to create a role instance (and store it in internal data structures for house keeping) and each invocation of the bound method naturally requires some lookup and dispatch.

If your using OT/Equinox you can actually use the “OT/Equinox Monitor” view to inspect the number of roles that have been created on behalf of a given team (just click on a row and wait for the hover).

In case you should notice a relevant slow down and you know the cause, we do have some tricks for tuning the performance

> I now have to dig a little in the Object Teams programming model but it seems to look a lot like Aspect.

While digging you’re always welcome to ask questions in our forum [2].
As for a comparison with Aspects, have you seen my earlier post [3] ? Does it answer some of your question? For just a quick hack the conceptual differences may not be extremely relevant, but the more you think of evolving the quick hack to something sustainable, the more you should benefit from Object Teams.
And mind you: evolving can well mean to transform an OT/J solution back into a plain Java solution, if you must. That’s what I just did with the null annotation prototype: doing the transformation was easy, only, now I miss the wonderful modularity of the solution.

So my advice typically is: if you use OT/J for some “hacking”, do it with style :), i.e., also the code for the quick adaptation can and should be clean and well-readable code!

[1] http://www.objectteams.org/publications/index.html#haeder
[2] http://www.eclipse.org/forums/eclipse.objectteams
[3] http://blog.objectteams.org/2010/02/compare-object-teams-to-aop/

I am more an eclipse “hacker” than a coder ATM and the fact that we can surround methods of basically any class of any plugin made my day a lot brighter .
I can now deploy a fix easily without having to wait for the fix to be integrated in eclipse: after packaging it in a feature and installing it in a standard untouched eclipse it just works, Thanks for that !

Do you have any data on the performance hit ?
I understand that it will be slower when a method is surrounded and I am quite ok with that, but does it slow down significantly the whole calling process when no Role is registered on a class ?

I now have to dig a little in the Object Teams programming model but it seems to look a lot like Aspect.