Java Development News:

TheServerSide at AOSD 2004

TheServerSide is taking part in this years Aspect-Oriented Software Development
Conference, hosted in Lancaster, UK.
Here is a writeup of day one

The conference has been a very interesting experience so far. It is not like
the industry conferences, as it is run by primarily academics. An interesting
dynamic comes about when you mix the academic side, with the professional. In
one room you can hear about bleeding edge research coming from the
Universities, and then move over to hear about what is coming from industry and
open source.

Who is representing open source?

When I entered the AspectWerkz for Dynamic Aspect-Oriented Programming tutorial
it was great to see both the JBoss and AspectJ teams in the crowd. Bill Burke
was able to ask questions to Jonas Boner and Alexandre Vasseur. He asked some
tough questions too!

There is a feeling of collaboration within the teams. Yes, in some ways there
is competition, yet I think people realise that the higher level goal is to
further the AOP paradigm in general. To do this we need to work together to
further the cause. For instance, AspectJ has a great Aspect Browser which
allows you to visualise what is going on in your code with respect to your
advice, and what is advised. How nice would it be if other AOP frameworks could
integrate with the browser, and take advantage of the same tools.

The tutorial format allowed the AspectWerkz team to go fairly deeply into what
is going on in their framework. AspectWerkz has really evolved from release to
release, and over a fairly short time-frame. Now that BEA has Jonas Boner
working full time on this effort, productivity will only grow. JRockit JVM
support was recently announced, and that work has already begun.

Big Quesions being asked

At the end of day one, I have repeatadly heard the following big questions:

Is AOP growing in the real world?

Many people feel that AOP is starting its slow march. At the last AOSD, the
majority of the industry may not have ever heard about AOP. Now, although they
may not be using it, a large pool of developers at least know of AOP and
"Aspects". The fact that you can really incrementally adopt AOP is allowing
adoption. Some development teams are tentative about new technology such as
this, but are able to start off by using AOP for dev tasks, handling policies,
testing, and other ways that don't require you to have any AOP products in
production. Teams that are at this stage are getting more and more familiar
with AOP, see strengths, and use cases where they would like to use it. As time
goes on they will slowly use AOP more and more, and in different ways.

I have also learnt from a variety of people that some companies are getting
ready to come out and share the fact that they are using AOP. As with many
bleeding edge technologies, many companies don't readily share the fact that
they are using it. As the market matures, this barrier will be removed, and in
fact as it moves from bleeding edge to leading edge, it can be good marketing
to show that you ARE using this technology.

What about tools support?

A lot of people have been talking about tools support. The AO community knows
that good tools can take us to the next level. Tools such as the Aspect Browser
are essential for visualisation, and refactoring tools are going to become very
important too. One of the issues right now is that if you refactor names of
methods, and classes, you may be breaking the system (due to pattern matching).
It will not be long until we see our IDEs offer functionality that will let you
know what is happening in the AO world. E.g. "By changing the method name you
are no longer going to be advised by X".

Metadata / Annotations

There has been a lot of discussion on how metadata (JSR 175) is going to affect
AOP. We know that it is going to be very powerful, but are also wary about
anti-patterns that may come out. I am personally worried that I will see
methods with huge amounts of @annotations (we are already seeing this in .NET).

This seems to fly in the face of abstracting out "cross cutting concerns". Now
we have the concerns in all the files just as before, however we are using
flags instead of code. The next big learning curve will involve working out
WHEN is it best to use annotations, versus WHEN should the compont be unaware
of an outside policy. As always, there will be a time and a place for both, and
it will take us some time to iron out patterns.

Standardizing AOP

Will there be some JSRs coming with respect to AO? Many people think so. There
are many levels of standardizing that can take place such as:

JVM: Can we add support for features that AOP could really use at the JVM
level (JRockit is doing this, and JDK 1.5 gives us a lot more of this too)

"Advisable": JBoss talked about how they would love to have support for an
Advisable type

Eventually, a long time from now, we may have AOP constructs as first class
citizens (aspects, pointcuts, etc).

Business Aspects

There is a hunt for business aspects. Middleware services are a natural fit for
AO since they are obviously cross cutting. Many people feel that there will be
a lot of business aspects also, and are on the hunt for them!

Conclusion

We will be updating the community on all of the events that take place at AOSD
2004 this week.

TechTarget provides technology professionals with the information they need to perform their jobs - from developing strategy, to making cost-effective purchase decisions and managing their organizations technology projects - with its network of technology-specific websites, events and online magazines.