Technical Pickles

Today marked the concussion of No Fluff, Just Stuff for the Boston Fall 2007 event. To put it simply: it was a truly amazing experience.

If you aren't familiar with NFJS, it was started just over six years ago by Jay Zimmerman out in Denver, Colorado. After many discussions with members of the Boulder Java User's Group, it was decided that there weren't any local conferences that focused on Java and agility, and that were strictly technical. Shortly thereafter, NFJS was born with a three-day symposium format. It was decided to cap the attendance at 250 in order to keep a high level of interaction between speakers and attendees. Each day has five concurrent tracks with a total of eleven 90 minute sessions with top-notch speakers from around the country.

I had the opportunity to speak briefly with Jay, and one thing I had asked was if much had changed over the past years. Apparently it had not. The particular format of the symposium works amazing well, with the small number of attendees, great speakers, and a high level of interactivity. Changing any of these would detract from what makes it so good, and would violate the original intent in which the event was started. Sure venues change, more schwagg is introduced, and technology continues to plow ahead, but at the heart, it's really the same as it has ever been, and that's a good thing.

The Sessions

There were a lot of great talks this year. Here is a list of sessions I had the opportunity to hit up:

• Friday
  • JavaServer Faces: A Whirlwind Tour by David Geary
  • OSGi: A Well Kept Secret by Venkat Subramaniam
  • 10 Ways to Improve Your Code by Neal Ford
  • Keynote: No, I Won't Tell You Which Web Framework to Use, or The Truth (with Jokes)
• Saturday
  • Productive Programmer: Acceleration, Focus, and Indirection by Neal Ford
  • Productive Programmer: Automation and Canonicality by Neal Ford
  • The Busy Java Developer's Guide to ClassLoaders by Ted Neward
  • Leveraging Annotations with AOP by Ramnivas Laddad
  • Birds of a Feather: Dynamic Languages with Neal Ford
• Sunday
  • Software Development Risk Analysis Techniques by Mark Johnson
  • Adding Behavior to Java Annotations by John Heintz
  • Experts Panel with all speakers present
  • REST: The Basics and Not So Basic... by John Heintz
  • Refactoring Ant Builds with Ivy, Groovy, and Good Old Fashion Common Sense by Andrew Glover

If I can find public copies of any of these presentations, I'll update this list with links.

Some future posts...

I found a few of the talks to be particularly fascinating, so I hope to follow up with several posts:

• Productive Programmer
• ClassLoaders
• Annotations + AOP + Behavior
• A summary of tips, resources, etc from everything

If you don't see something about these in the next week or so, feel free to hassle me a little :)

Pseudo random thoughts, observations, and feelings

• Things were pretty swagtastic this year
  • A pleather binder that zips close, came in extremely useful
  • A nice backpack, but I won't likely use it...
  • A CD with all the presentations
• The venue was the Framingham Sheraton
  • Great food
  • Great service and staff
  • Maybe a little overzealous on the AC in a few rooms
• Being around smart and passionate people definitely rubs off
• Definitely feeling
• Each day felt much longer than it was, in a good way
  • Amazing amount of new material
  • Constantly experiencing paradigm shifts
• All the speakers I spoke with were very approachable
• A lot of people didn't seem quite as engaged, as much as I was at least
  • Sitting leaning back during talks
  • Not taking notes
  • Not asking questions, or talking to the speaker afterwards
  • Not engaging in conversation with other attendees between sessions or at meals
• Survey says...
  • Most people are on Java 1.5 now
  • Most of the people still on Java 1.4 are there because of WebSphere
  • WebSphere sucks
  • A majority of people are doing automated testing
  • More people are doing continuous integration
  • More people are using not struts, including JSF, Tapestry, and Spring MVC
  • Most people are pretty psyched about Groovy, JRuby, and Grails
  • Overwhelming majority of people are using Eclipse
  • Most of the speakers are now Mac users
  • Most of the speakers are using IntelliJ IDEA

Advice for potential attendees

The most significant piece of advice I can give is this: be engaged. You have an amazing opportunity to interact with experts in the fields. You are surrounded by feels geeks and hackers who take time off to go to these kinds of things. Talk to them! Take notes! Absorb!

Wrap it up, B

I really can enumerate enough how awesome of an experience it was. I'm feeling pretty pumped up to get back to development to put this new knowledge to use. If NFJS is coming to a city near you, take the plunge; you won't regret it.

I'm currently working on making use of a Groovy on a project of mine which uses Hibernate and Spring among other things.

My code wasn't particularly well tested in terms of unit tests. By this, of course, I mean there were no unit tests.

So like a good code monkey, I decided to get some unit tests going, verify they work, then move code over to use Groovy. The benefit here being that by having these tests, I can verify that things still work as expected after the migration.

I figured on trying out rMock, one of the many mocking libraries out there for Java. I get my first test case written, cross my fingers, and hit the run button (this is in Eclipse)... and what do I get, but the infamous red bar. NoClassDefFound... WTFBBQ?!? For whatever reason, it wasn't finding certain classes from dev-java/asm.

I won't go into further detail about how I found this problem, and found the cause, but here are my findings (versions here refer to slots):

• dev-java/groovy uses dev-java/asm-2.2
• dev-java/hibernate uses dev-java/cglib-2.1
• dev-java/rmock uses dev-java/cglib-2.1
• dev-java/cglib-2.1 uses dev-java/asm-1.5

The issue here is that asm apparently changed it's API quite a bit between 1.x and 2.x. This problem seems to have cropped up a few times at least according to google (search for 'NoClassDefFoundError: org/objectweb/asm/CodeVisitor').

The asm tutorial even goes so far as to the changes... kind of. See here under the "Changes in the ASM 2.0 API Since ASM 1.x" section. A few things bother me about this.

• I don't see why the major changes, like renamed classes, and changed method signatures, couldn't have been deprecated at first, and do some twiddling to proxy calls to deprecated things to the newer ones.
• The line that goes like "In general, it would be a good idea to run tool like JDiff and review the differences between the ASM 1.x and 2.0 APIs." Maybe it's just me, but this seems a bit presumptious. I mean, while such a tool is probably useful, it is far from thorough. It might point out where the API changed, but would have no clue as to the significance of those changes, or how you would account for them.

A question that might come out is why would rmock expose this problem, when hibernate is using the same version of asm? Presumably it is because hibernate isn't exercising the parts of the cglib API that use the offending parts of asm, so I must have lucked out before now.

Regretfully, this seems somewhat common in the Java world. Maybe not very common, or even common, but common enough that they stick out in my mind, causing a handful of angst and frustration.

There is some good news though. cglib-2.2_beta1 seems to have been updated to use the asm-2.x's API. Another bit of fortune is that it's unlikely that anything in the tree will run into this particular snaggle, just code monkeys like me using these various libraries.

For the record, I don't get the ClassDefNotFound anymore, but instead I get a lovely NullPointerException from down in Groovy. Oh well, one step forward, one step back.

This news is a bit belated by a few days but.... over the weekend, I spent some time getting the recently released Groovy 1.0 into the tree.

In case you hadn't heard about it, Groovy is, among other things, a dynamic language that runs on the the Java VM. Some interesting data points about it:

• It's dynamic, for reals.
• It's about 98% syntax compatible with Java code (I made that number up, but really, it's pretty durn close).
• Java bytecode gets generated at runtime, no need to compile.
• Groovy can generate Java bytecode to your typical .class files

A consequence of these points is that you can easily migrate from Java to Groovy, and have your project running exactly as it was. Then slowly, you can get into the swing of things, and take advantage of everything that Groovy has to offer as you get the hang of it.

One fear I've noticed of Java developers of jumping into a more dynamic language like python or ruby is late binding. You can't really be sure the type of your objects until runtime. Sure, you can read the documentation (assuming it's up to date) or peek at the code to be sure. With Java, binding occurs at compile time, so you can be sure that foo method expects a Bar, or that Bar has the aieeeee() method. I suspect some of this comes from defensive coding, where you become concerned about how your code will be (ab)used by others.

To combat this, a coworker and I have this idea... You use Java to define interfaces for the, uh, interfaces you care about. You can then use Groovy to implement these interfaces. By doing this, you get the best of both worlds: clients of your code get their strongly typed interface, and you get to do implementations with a more expressive syntax.

Overall, I've been pretty impressed with Groovy so far. Granted, I haven't used it as deeply as possible yet, but it certainly has a lot of potential.

In case any of this sounds interesting, here's some resources:

• The Groovy homepage, get your documentation on
• The recently released Groovy in Action
• The Disco Blog, by Andrew Glover, one of the authors of above mentioned book.

And in other Java dynamicism news, I've added the freshly minted JRuby 0.9.2 to the tree this past weekend as well. I haven't played with it yet, so I can't speak much on its behalf other than it's an implementation of Ruby written on the Java VM. Perhaps that can be the topic for a future blog post.