I have been coding in java for the past 6 years and I thought I knew the language and platform quite well. Well, two days ago I was proved wrong as I discovered a new facet of it that I wasn't aware of: binary compatibility...

There is a good article called Evolving Java-based APIs by Jim des Rivieres.

It's a complex subject that not a lot of persons are aware of and which is extremely important if you're a framework writer. Let me give one example.

Imagine you have a ServletTestCase public API class (i.e. users can use it) and it inherits from an AbstractTestCase class. This latter class is not supposed to be used by end users. However, it has some public API methods accessed through the ServletTestCase by the users.

Now, if you think you can safely refactor the AbstractTestCase class you're wrong! For example, if you wish to split the AbstractTestCase class in 2: AbstractClientTestCase and AbstractWebTestCase , the second one inheriting from the first, you're in for trouble...

Indeed, code that has been compiled with the first version of the framework will have a reference to AbstractTestCase in its .class files (provided it was using methods inherited from AbstractTestCase ). Thus when you bring in the new framework and put it in the runtime classpath of your other code, it will fail with a NoClassDefFoundError !

What it means is that preserving binary compatibility is difficult and is something that strongly impacts how you design your APIs. Using delegation has to be preffered over class inheritance as it will allow you to change the implementation without breaking binary compatibility.

That's what was new to me. So far I had been designing simply using the OO concepts and choosing the pattern the most adapted. Now, I've discovered that I also need to introduce the binary compatibility aspect in the picture and that it drives my design choices!

Evolving Java-based APIs is really difficult...

I spent the last 4 days at the TSS Symposium in Boston. It was just great! I think I can say it was the best conference I've been to so far. The speakers were great, and it was very well organized. Kudos to Floyd, Jay and their team.

I was able to meet all my "heroes of the web": Mike Cannon-Brookes, Jason Carreira, Cameron Purdy, Cedric Beust, Gavin King, Howard Lewis Ship, Erik Hatcher and I also met some others great guys I had not met online before: Rod Johnson, Bruce Tate, Christophe Ney, Scott Ambler and a few others (sorry if I forgot you).

I also met Marjan Bace from Manning, who is editing my JUnit in Action book.

To top it all, I won a Tivo (not sure it works in France but we shall see).

I had the chance to speak in front of this great audience and it was cool. The talks I presented were:

• Unit testing J2EE applications. Here are the slides. All source code for the examples in the slides are available on the JUnit in Action code website on SourceForge (all source code was donated to open source under an Apache Public License).
• Building J2EE applications with Maven. Here are the slides. The source code for the Maven Everest project described in the slides is available here.

I was also invited to sit on the Open Source panel to answer the public's questions (along with Bill Burke, Christophe Ney, Gavin King, Mike Canon-Brookes and Erik Hatcher - Some pictures are available here) and finally I recorded a TSS Tech Talk on "Agile Offshore Software Development" (this is what we are doing at Pivolis).

I will not go in the detail of the sessions as it has already been well covered by Cameron and a few others (see Cameron's links).

I'm looking forward to the next TSSS. Would be cool if it were in Europe. Maybe we could also do it on a cruise boat next time!

PS: Mike, you were not the last one to blog about TSSS... :-)