4

Is there any major weakness for aspect-oriented programming? I like the idea of alleviating crosscutting concerns by limiting the calls towards one class inside its aspect. But to me, it is a little bit weird.

Question 1. Let's take the Logger class example. Every class/method may need to call some method of the Logger class. Writing all those calls inside the Logger aspect makes future modification easy. However, who should maintain the Logger's aspect? If the developer of the Logger class does this, he/she needs to have a global view of the whole project, which I think is kind of impossible if the project is large enough. On the other hand, if we allow everybody to modify the Logger's class, there will be too many people accessing the same piece of code. And if any of them makes a mistake, the code will fail. So, in general, who should maintain the aspects?

Question 2. Will the performance be a problem? I think one pointcut is like registering one event listener. If there are too many pointcut during runtime, will it slow down the program?

Thanks,

Improve this question

1 Answer 1

Reset to default
6

Question 1

I think this largely answers the question: the Logger aspect is not the same as the Logger class/implementation. So whilst the Logger implementation can exist in some standalone unit which indeed performs the task of logging, any logging aspect(s) exist within your application's domain and they can defer the work at their intercepts. The responsibility is therefore localised to the entities for which the aspect is being applied, which makes good sense.

Question 2

Perhaps of interest.

Performance will be very specific to implementation, and I don't know in detail how anyone does it, but at a guess in a compiled (or effectively compiled) situation it would not infeasible to effectively 'inject' the aspect's behaviour into the appropriate places (or things to achieve a similar end) and as such the performance hit would be minimal.

Take this into interpretted languages however, and you are effectively indeed in the 'event listener' style of overhead.

Weaknesses

I'm no expert, but I'll draw a couple of conclusions and invite any additions:

  • Lack of visibility. Can't see by looking at the target which aspects are affecting it, could lead to debugging difficulties - particularly if affecting the code flow. Good IDE support could probably alleviate this.
  • Could perhaps lead to larger binaries when aspects are compiled into the code, though I'd imagine this to be negligible.

Hope this helps.

Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

Hi @jstephenson, thank you very much for your prompt reply. So you mean, maybe, for every class who calls the Logger's method, they can specify their own Logger aspects?
Hi @jstephenson, is there any major weakness for AOP?
I've added a couple of potential weaknesses, but there are probably more (certainly philosophically) - I'd suggest a pros/cons Google for this.
I know of at least one AOP tool with a good visibility via IDE plugin: PostSharp/Visual Studio, but I don't know if similar tooling exists for AspectJ/Spring.
@mgroves the Spring IDE is also able to indicate which objects are advised.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.