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).
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!
We will be updating the community on all of the events that take place at AOSD 2004 this week.