Performance Engineering: Approaches

As a software developer we continuously need to design and develop solution for the complexity thrown upon them. It is therefore very important for one to keep oneself abreast with different tools, technologies and methodology, while, having said that, I'm not exactly asking to run after them but it makes sense to stop and at least get the central idea about a given tools etc. because you would at least learn a new perspective of solving an existing problem or better still identify a potential problem with the existing solutions.

AspectJ appeared multiple times during my search efficient techniques to profile my application for conducting performance engineering exercise. I decided to take the plunge and try my hands with this methodology.

The underlying theme which the authors have tried to sell this methodology to us developers by exposing the shortcomings with object orientation, according to them, the OOAD methodology shines for solving the core problem but falls short to provide bells and whistles for the enterprise applications efficiently. They refer it to as 'Cross-cutting Concerns', concerns which are not exactly the part of the core problem (subject to the context) and form the supporting functionality. Simplest example is that of logging, frequently logging code is tangled with the core logic itself, thus forcing the developer to focus on far too many things at a time.

This seems to solve the 'Architects- Dilemma' where one is always trying to do the balancing act between the 'Over-engineered' vs. 'Sloppily-designed' systems. AOP seems to provide extension points to the application to provide utilities later. That serves us well because, whenever an extension is required only new code is written without modifying the existing code.

There seems to exist good amount of tooling support AspectJ for Eclipse, JBoss AOP etc. can't really compare and contrast them at this point in time but I have a feeling that AspectJ has fuller support than JBoss.

There are interesting articles available on IBM Developerworks to give a head start to the subject.

Another, technique that needs to explored is JMX that seems to provide JVM level support for application monitoring.

My primary approach to the problem of monitoring application for performance was to create custom class loader using java reflections API but I have a feeling now that this approach although very powerful is also quite complicated and error prone.

May be I should focus on AOP for the time being for better turnaround time in the longer run, also because learning this approach may expose me to solve other problems in a more efficient manner.