Simply Confusing

Any medium+ size application is going to call for quite a number of objects (java, jsp, css, etc, etc) to fit together to get a job done. While it may be the complex algoryhtm that you developed that you put the most pride in - it's well worth taking a step back and making sure the simple names of your objects make sense. Doing so (as discussed in Sun's code conventions) can make things a bit more clear during initial development, but can pay great dividends during support.

An example. I recently worked on an application where the user signs in - selects what "org level" they would like to work with (unless they only are authorized to one) and is presented with the data (items) for that org level. Very common.

This process involved the following jsps: home.jsp, login.jsp, welcome.jsp

To determine how those work together you'd have to get into the Struts config... Checkout some Java code... Checkout some of the form tags in the jsps... This isn't difficult work but it definitely is frustrating when you're thinking: "I shouldn't have to do this".

How about the following changes:
home.jsp -> welcome.jsp
welcome.jsp -> orgLevelNavigation.jsp
login.jsp -> baseDataEntry.jsp

Now (hopefully) you can anticipate:

• welcome.jsp is the first screen: greet the user and provide some basic instructions, etc.


• orgLevelNavigation.jsp is a screen that will help guide the user to their desired org level.


• baseDataEntry.jsp turned out to be a screen that actually had nothing to do with someone logging in. Go figure.

... and I'll spare you what the Java objects supporting this project looked like!

The Spring Experience Wraps Up

Coming in I had some pretty high expectations for The Spring Experience (TSE) and it certainly didn't disapoint. The speakers were exceptional, the style of the conference (manageable audience size, variety of topic choices at any given time, and speaker accessibility) were great. Not to mention the Miami climate!

I'm sure I've missed several people posting on TSE, but I'll throw a few more below. In the meantime though, I wanted to report on something that I took away as quite important but haven't seen mentioned elsewhere:

During Rod Johnson's keynote on Friday he presented us with a list of "What you should be doing". There are probably worse things you could do for your career than listen to Rod.

(keep in mind that the topic of the keynote was Spring AOP/Aspect J)

A few to start with:
1. Develop a background in AOP.
2. Learn AspectJ pointcuts
3. Combine #1 and #2 by using Spring AOP with AspectJ pointcuts

Follow that up with the 2 more on AOP:
4. Look into design level assertions w/AspectJ to improve code quality.
5. Consider converting 'policy documents' to aspects

Finally, the catchall:
6. Look at: XML extensions, JMS, scoping, scripting, Spring MVC, remoting, WebFlow, Acegi security.

The promised additional links...
Jim Moore has been doing quite a bit of blogging on individual sessions in addition to a post on the presentation he gave. I wanted to make that one but like he said... he was up against some pretty tough competition.

Patrick Peralta

And many more here, of course.

More of The Spring Experience

We're passed the midway point of the conference and so far I've been very happy with it. As anticipated, Jay Zimmerman's running the show very much like NFJS shows, which works out great. Laid back - plenty of access to the speakers, etc.

To anyone reading this anywhere in the country other than Miami (and especially you suckers in Wisconsin), I would just like to say: ha ha, ha... ha ha... ha. I hope you're enjoying the weather - I'll be back in a couple days.



A few of my favorite sessions so far...

I've seen a couple of sessions from Rod Johnson. I enjoyed the 'Testing with Spring' session a bit more than the 'Spring Fundamentals' session... where I couldn't help myself and answered the "Knowledge of Subject" line, on the speaker evaluation, with a 1 out of 5. < grin />

I had previously mentioned that I was struggling between whether to attend Matt Raible's TDD session, or Keith Donald's talk on Webflow. I ended up going with the TDD talk. It was the first talk I've seen Matt give and I enjoyed it. The talk centered quite a bit on AppFuse, but did also cover some TDD topics. He also regularly poled the audience on "Who's currently using XYZ" etc for the various frameworks, taking it so far as to completely mold the demo to match what the majority wanted to see - definitely cool.

Justin Gehtland gave a presentation on Spring MVC that may have been my favorite thus far. He did have a bit of an unfair advantage as Spring MVC is something I am quite interested in + have no practical experience with (other than reading about it in Pro Spring).

Want more on what's going on around here?
- I had a previous post
- Craig has a post.
- Colin has a post
- Mr.Raible has some very comprehensive posts going.

The Spring Experience - Day 0

After a strange occurence at the airport on the way in (which somehow happened while I was there, yet I was unaware of); I've made it to The Spring Experience.

Not sure if I want to commit to reporting on what I see hear each day, but I figured I'd report back on the keynote of Day 0.

Knowing going in that the keynote was from Rod Johnson, I was kinda expecting a "state of the world" talk illustrating how Spring was going to save us all. Instead, what we got was a tagteam effort featuring Rod as the main contributor and MC.

Early on Rod let us in on the big news: Spring going 2.0. The plan is that 2.0 M1 will be released by the end of the conference - with an intention of having the legit 2.0 release in March ("Spring") of 2006.

Rob Harrop presented what sounds like the most impressive improvement in 2.0 : incredibly simplified tags for some of the most common xml work. If you've looked at these tags in the past you may think they're already pretty nice... you'll still be surprised at how slick the changes are.

Alef Arendsen demonstrated all of the changes that will be required to upgrade a Spring application to the 2.0 jars... nothing. He swapped in the new jars and illustrated that the jPetStore app (modified from Clinton Begin's version) worked with absolutely no changes. Another 45 seconds later he had swapped in the simplified xml changes that Rob had just demonstrated: again, no problems encountered. Both Alef and Rod repeatedly said that they still have much testing and verification to do but that they know of nothing that would require change on an upgrade to 2.0.

Keith Donald then gave a great demo on Spring Webflow, of which he's co-lead. "Conducting a logical conversation with the server to perform a complete transaction" pretty much summed it up. The demo was amazingly clean and concise, illustrating the independence of flow logic from the rest of the application. In fact, flow logic was even kept independant of other (sub) flow logic... real slick - I am going to be facing a tough decision tomorrow as Keith's session on the topic conflicts with Matt Raible's session on "TDD with Spring and Hibernate" which was one of my "must see" sessions coming into the show.

Anyway, that's my story.