NFJS Conference – Day 1

In a day that starts with being told to stink less and earlier, and ending in dinner with Dave Thomas, Bruce Tate, Justin Gehtland and a host of people from the St. Louis Ruby group, it’s amazing that so much was packed into just a half a day. Here’s what you missed by not coming to the 4th Gateway No Fluff Just Stuff conference (or, if you did, what you missed by not stalking me around).

Registration

The day started with finally running into Jay Zimmerman, the guy whose hard work makes these conferences possible. Jay has been trying to get an NFJS conference in Charlotte (Which, if that’s where you are, I suggest looking at that conference, especially if you are into AJAX), and it figures that he finally gets it there the year I move to Missouri.

Where Agile Meets Argyle

After registration, I wandered over to “Where Agile meets Argyle” by Bruce Tate. We’ve all worked at companies where practices and processes are wielded by business people. But, to sell agile, you can’t just go up to them and say, “Hey! Let’s do this *EXTREME* Programming paradigm where we don’t do any documentation, we pair program, and we write gobs of test code for each line of real code we write!”

In fact, you need to drop the notion that the language you use to describe your ideas is sacred, and just hold the ideas themselves sacred. This means maybe saying something like, “Hey! We’ve been reviewing some of our development processes in order to see how we can improve them for the business. We think by increation collaboration, focusing on the crucial artifacts, and ensuring that the code we produce works as the customers expect we can increase the quality and decrease the time-to-market for our products”. What non-technical manager wouldn’t spin around on that?

Besides that, he touched on some other good points:

• Emphasize: Small, smart teams. Simple Requirement management. Simplicity. Refactoring. Automatic Unit Testing, and good feedback from customers
• Since developer estimations stink, let’s shoot for a goal to stink less and stink earlier in the cycle
• If a customer isn’t interested in a relationship, or doesn’t see the point in the demo, find something that they can’t do today and deliver it to them early anyway to get them excited about the project
• When removing some aspect of discipline from an Argyle process (say, extensive documentation) ensure that some matching form of discipline is added to the agile (say, extensive unit tests)
• If your customer wants lots of or specific documentation, can you possible get a tool that generates it for you?
• Requirements should be your only currency

One additional thought I had during it, that I will expand upon in another post, is that business people always seem to want to see the people behind the curtain doing the real work. Why don’t we as developers ever want the same?

Spring Dependency Injection

After a quick break, I headed over to Justin Gehtland’s talk on Spring Dependency Injection. I’ve played some with Spring.NET, but hadn’t gotten much into the Java version. He touched on a key point, and that is how developers end up with tightly coupled code. It’s through:

• Concrete Classes
• Calls to new (!)
• Checked Exceptions
• Contructors

It was fun to see the reaction to the “Calls to new” point. But it’s true – time after time the advice is to write to contracts (interfaces), especially at flex-points, but it isn’t done often enough. In addition to interfaces, you reduce tight coupling through:

• Interfaces
• Inversion of Control (IOC)
• Unchecked Exceptions
• Bean Properties and Configuration files

And, of course, Spring can help with this. I found it interesting that Spring can use XML files and Property files, but also Groovy, Java, Python and Ruby scripts to define the configurations.

However, Spring 2.0 is coming soon, and is adding some nifty new features, so be on the lookout for that.

Herding Racehorses and Racing Sheep

Finally we headed over to the Dave Thomas talk on Herding Racehorses and Racing Sheep. However, Dave’s plane was late, so Bruce Tate stood up, declared himself to be Dave Thomas, and promptly did a jig. Ok, not quite, but he did do a good job of stalling until Dave did arrive.

Dave’s talk was, of course, fascinating. He stressed People Improvement over Process Improvement since, after all, the people are the ones implementing the process. He then talked more in depth about the Dreyfus Model which Andy Hunt touched on when he came to the Charlotte JUG, but I found utterly fascinating still.

Finally, he touched on what he coined an “Experience Portfolio” and how we should apply common Financial Management concepts to it. For example, diversify by learning a new language every 3-12 months. Set a plan for your end goal, and constantly review it to see if you are on target, remembering that a plan is a plan – not a map.

Dinner

Finally, I made it over to the St. Louis Ruby User Group’s dinner. I was quite glad to meet them – I’ve talked with several people on the mailing list, and it was quite nice to put faces to names. Dave, Bruce and Justin (and Neal Ford!) joined us, and much debuachery ensued. Well, at least some really good discussion over a decent little meal (even if it was a bit Ruby-centric ;))

With two more days to go, and some very difficult sessions to choose from, I am excited to be here. Hope you get to come to one soon as well.