The journey of a developer is never completed - due to constantly learning, retooling, and grasping new concepts. It's this continual learning that lures many to our profession. Sometimes, though, it can be tiresome trying to keep up and hoping what you're learning today will still be there tomorrow. At times, software disciplines come and go quicker than fashions.

For my own part, I took a sabbatical of sorts for six months. I had quite a lot going on in my life and didn't have the time to be looking in any great depth at the new disciplines coming through. Fortunately, though, my role here at JDJ keeps me informed of all trends so I wasn't completely out of the game.

Java is a wonderfully diverse and very comprehensive language. Keeping up with the latest developments in the JDK is a full-time job in itself. The rate at which it is growing is enough to make even the seasoned developer scratch his or her head in exasperation. It's a common complaint we hear from developers new to the language, but that's the price of progress.

A new area that is gaining a lot of traction at the moment is AOP or Aspect-Oriented Programming. I've been hearing more and more on this, and this month Bill Burke from JBoss has written our first AOP article, introducing this new, powerful complement to Java.

AOP is something I've been casually reading about on various blogs and sites, but for some reason I just wasn't clicking on the usefulness of it. Maybe I was reading the wrong level of articles. But at a recent No Fluff Just Stuff conference, I made a point of attending Ron Bodkins' introduction to AOP, and I'm thankful I did. Instantly all the pieces fell into place.

AOP is a wonderful complement to the whole OO philosophy and Java is very capable, through AspectJ, of taking advantage of what AOP has to offer. What can it do? In a nutshell, it has the ability to give you god-like control over the object calls within your JVM. You can set up "filters" that can be triggered before and after method calls. This allows you to not only inspect parameters but also affect them.

It's often touted as a clean way to perform logging or control security, but one of the cool features is the ability to create "wormholes" in your code to pass references around. Instead of carrying around a reference to a particular class that you need in a deep call, remove it from the call and simply reinsert it when the method needs it.

Sounds like a hack doesn't it? In many respects it is. You could think of it as a legalized, completely authorized "goto." Possibly that's not entirely fair, but the main drawback I hear about AOP is that when you do it right, it's a wonderful addition; do it wrong and it's a nightmare to trace.

So you have to respect the power it offers and use it only for the greater good, as opposed to short-cutting a poor design.

On that note, I would like to wave goodbye to the look'n'feel of this JDJ because next month we introduce JDJ v3. We've been busy working on a new style for the magazine that will reflect the changing Java landscape. We have restructured the sections and assigned new editors to cover a wider range of subjects. In addition to focusing on new technologies, we will be looking at the application of Java in the field and interviewing those behind the decisions to deploy Java over and above the alternatives.

There are those who would lead you to believe Java is dead. Believe none of it. From January on you will be reading success stories and, if your faith has been flagging a little, we'll perk it up for you.

Until next month, have a great Christmas and see you in 2004.