Matt Stine's Blog

I've Moved!

2009-03-23T16:43:00.002-05:00

At long last, I finally have combined my personal web site and my blog into one site, which is now hosted on WordPress. This will be my final post at this Blogger site. To continue the conversation, jump on over to http://www.mattstine.com!

The Manifesto for Software Craftsmanship

2009-03-15T22:45:00.005-05:00

So as I'm sitting here thumbing through my InfoQ feed on Google Reader, I come across the following posting: Software Craftsmanship Manifesto: A Call to Arms. It seems that a group of "programming patriots" has struck again (see the Manifesto for Agile Software Development - circa 2001), complete with a "founding document" look and feel. Clicking through the source link, one finds the following:

As aspiring Software Craftsmen we are raising the bar of professional software development by practicing it and helping others learn the craft. Through this work we have come to value:

Not only working software, but also well-crafted software

Not only responding to change, but also steadily adding value

Not only individuals and interactions, but also a community of professionals

Not only customer collaboration,but also productive partnerships

That is, in pursuit of the items on the left we have found the items on the right to be indispensable.

© 2009, the undersigned. this statement may be freely copied in any form, but only in its entirety through this notice.

You can't even imagine my excitement in reading this. This statement of values is something that I have been trying to get across without having the needed words for quite some time.

The motivation, says the InfoQ article, is right on target:

The members of the manifesto group answered two key questions: “How will it help solve the problems of crap code?” and “What will motivate "The developer just churning out code" to become a craftsman?” - the distinction is between the developer who is just getting it done vs the one getting it done right.

I have felt for a long time that the elements of craftsmanship are something sorely missing from our field. We, as programmers, are often so consumed with getting the job done that we do often neglect getting it done right. In our haste to move on to the next exciting project and/or technology, we neglect the tenets of simple design, test-driven development, merciless refactoring, clean code, etc. We're often quite satisfied with the "hacky solution here" and the "quick and dirty solution there."

Quite frankly, I've had enough of that. I'm not satisfied when the contractor building my house cuts corners. I'm quite irritable when my mechanic does a less than thorough job with my car. Why should I expect my clients to settle for software built like that?

So, to make this a practical rant, I thought I'd share a couple of the things that we're doing in our team to move us in the right direction:

First of all, we started a weekly "brown bag lunch/workshop," inspired by Andy Hunt and Venkat Subramaniam's discussion in Practices of an Agile Developer.

Second, we selected books to read as a team that will point us in the right direction. Our first two titles were The Pragmatic Programmer: From Journeyman to Master (see, there's craftsmanship right away!) and Clean Code: A Handbook of Agile Software Craftsmanship (sense a pattern yet?).

Third, we make a point of our weekly discussions to look at ways we can integrate the principles and practices that we're learning into our daily work. An example: We're working to integrate peer code review into our development process. The principles, patterns, and practices that we're picking up from Clean Code will be informing us as we review code and look for possible improvements.

So, with that said, tonight I became a signatory of the manifesto. Why don't you join me and fight the fight against crappy code!

Grails+Dojo Ajax File Upload

2009-03-13T22:08:00.002-05:00

I'm currently working on a Grails application with a requirement for uploading product images, which are subsequently resized into thumbnails of various sizes for different shopping screens. Since it took a bit of doing to get this done, I thought I'd post my solution here in case anyone could benefit from it.

First, to set the stage, I've upgraded the application all the way to the newly released Grails 1.1.

To start off, I naively attempted to use the built-in Prototype library to do the upload with a simple <g:submitRemote/> tag. You might have guessed that this didn't work at all. Continuing to learn the hard way (without reading the manual I might add), I submitted this as a bug to the Grails project. Graeme ever so politely informed me that this was known and expected behavior, as Prototype doesn't support such a thing. However, it was Graeme that also tipped me off to try Dojo.

So, continuing down this path, I proceeded to install the Grails Dojo plugin. Once this is done, a <g:javascript library="dojo"/> is supposedly all that is required to convert your Ajax calls from Prototype to Dojo. This turned out to not be the case for me, with Javascript errors popping up all over the place, not the least of which was that dojo.js seemed to be installed in an unexpected location via the plugin. The hacker in me simply copied this to the expected location and moved along. However, as I attempted to work with Dojo's file upload support, I discovered that the version of Dojo shipped with the plugin seemed at first glance to be way behind. Frustrated by this, I went ahead and stripped the Dojo plugin out and installed the latest version available (at this writing 1.2.3), and set about to develop my solution.

Here goes:

1. Add the necessary Dojo dependencies to your GSP:


<script type="text/javascript" src="${createLinkTo(dir: 'js/dojo', file: 'dojo.js')}"
   djConfig="parseOnLoad:true, isDebug:true"></script>
<g:javascript>
   dojo.require("dojo.io.iframe");
</g:javascript>

2. Write a function using dojo.io.iframe to send the form:


function submitForm() {
   dojo.io.iframe.send({
      form: 'uploadProductImageForm',
      load: function (data) {
         dojo.byId('productImage').innerHTML = data;
      }
   });
}

3. Create the file upload form:


<g:form name="uploadProductImageForm" method="post" action="uploadProductImage" enctype="multipart/form-data">
   <input type="hidden" name="id" value="${productInstance?.id}"/>
   <input type="file" name="newProductImage"/>
   <span class="button"><input class="add" type="button" name="uploadImage" value="Upload Image" onclick="submitForm()"/></span>
</g:form>

4. Create the controller method:


def uploadProductImage = {
   def f = request.getFile('newProductImage')
   if (!f.empty) {

   def imagePath = grailsApplication.config.store.productImages.location

   //Create unique name for this image set based on current timestamp
   def name = "image" + new Date().getTime()

   //Store the file 
   def file = new File("${imagePath}/${originalFilename}")
   f.transferTo(file)

   //Do some image processing (resizing, etc.)
   ...
 
   //Dojo requires returning the result nested in an HTML document containing a body and textarea tag. Do this with
   //Groovy's built-in MarkupBuilder
 
   def writer = new StringWriter()
   def xml = new MarkupBuilder(writer)

   xml.html {
     body {
       textarea {
         img(src: resource(dir: grailsApplication.config.store.productImages.webPath, file: product.mediumImage.name), width: '250')
       }
     }
   }

   render writer.toString()
   }
   else {
      flash.message = 'file cannot be empty'
      redirect(action: show)
   }
}

And there you have it. Let me know what you think of this solution. It definitely works for me. You will notice that I didn't include an upload progress bar - I'll be doing this in a future iteration of the project. Cheers!

I'm speaking at the March Memphis JUG meeting

2009-03-13T12:24:00.001-05:00

I learned a great deal about JMS from Mark Richards at last weekend's NFJS Gateway Software Symposium, and I thought I'd share it with the Memphis Java community. Take a look at http://www.memphisjug.org for details!

My iPod is on rice

2009-03-13T11:55:00.002-05:00

Let me set the stage for you. I'm driving home happily listening to Ted Neward discuss the merits of Scala on the Javaworld podcast. As I pull into the driveway I see my wife waving frantically in the window. As geek brain struggles to process this, home brain kicks into gear. She needs me in the house now! I jump out of the car and slam the door shut, leaving all of the belongings I typically carry in the house.

I enter the house to find that a wasp has some how gotten in and is terrorizing the family. What ensues is roughly 15 minutes of wasp hunting. Wasp dead - end of story. Or so I thought.

As I'm driving my iPod (attached to the iTrip FM transmitter/charger) typically sits in my lap (for some reason I get the least FM interference that way). What I didn't notice in my hasty departure from the vehicle is that my iPod nano flew out of the vehicle and was hanging by the iTrip cable. Unaware of this, I slammed the door on the cable and walked away.

This in and of itself wasn't a huge problem. Leaving it that way for approximately 24 hours - most of which included rather steady rainfall - was.

So, a quick Google search finds that the consensus approach seems to be sticking the iPod in a cup of dry rice to soak up the moisture. So there you have it - my iPod is on rice. I hope it works. Stay tuned.

It's been a long time...

2009-03-12T21:32:00.004-05:00

...since I actively spent any time blogging. What you don't know is that it has been a long time since I've done any writing whatsoever. The last two posts on this blog revolved around the birth of my first son, Grant Dawson, on May 16, 2009. This was one of several events that took place almost a year ago that sent me directly into a whirlwind of activity that found me barely keeping my head above water.

It was also about this time that I found myself newly promoted into front-line management. The team that I entered first in 2000 as a Bioinformatics Intern during my last summer as an undergraduate, and then as a Software Engineer/Web Developer I following graduation in 2001, was now mine to lead. After doing this job now for nearly a year, I can safely say that my career as a developer has both prepared me for this role and left me completely bankrupt when faced with the responsibilities that are now mine. More on this to come.

Another event that transpired in May was the sale of our first home. It had been on the market since March, and we "paused" the showings as Grant's arrival became imminent. It was near the end of May that we received both our first and our last post-Grant showing phone call. I remarked to Wendy - "these folks are going to buy the house." And buy it they did. Unfortunately for us, we had no idea whatsoever where we were going to move. What ensued was a chaotic whirlwind of house hunting which ended with us making an offer on a house that wasn't even on the market. And that's the house I'm sitting in while I write this first entry of 2009. Ask me to tell you the story sometime - it's a good one.

So, why I'm I here? Why not just leave the blogging task. After all, isn't blogging passe at this point?

I credit my return to the blogosphere to an incredible book by Jared Richardson and Matthew Bass - Career 2.0: Take Control of Your Life. The basic premise of this book is to "Actively manage your career." One of the ways by which the authors share how to do this is writing - sharing what you know with the community at-large. Of course what they shared was no surprise to me. I already knew all too well the career benefits associated with blogging. What I needed was a proverbial "kick in the pants." And that's what Career 2.0 did for me. If you're in the software industry - take that back, I don't care what industry you're in (these principles are transcendent) - do yourself a favor and read this book. It will change something about your life, guaranteed.

So, with that, let's start the conversation again. I'm looking forward to where it might lead. Cheers!

Little Man

2008-08-14T22:54:00.000-05:00

Here's little man Grant himself smiling for the camera!

Introducing Grant Dawson Stine

2008-05-18T14:11:00.000-05:00

So I haven't blogged in quite awhile. I've been rather busy - here's one VERY important reason why. Grant was born Friday, May 16, 2008, weighing in at 9 pounds 4 ounces and 22 inches long. Mom and baby are doing wonderfully, but as you can see, Dad is in a bit of shock!

On our way to the Gateway Software Symposium

2008-02-08T14:49:00.001-06:00

We're taking most of our team to the St. Louis, Missouri, edition of the No Fluff Just Stuff 2008 tour. This will be my first actual NFJS event. I attended the Spring Experience in 2007, which was put on by the NFJS guys, so I expect this event in St. Louis to be great. Since we're based in Memphis, St. Louis is only about a 4 1/2 hour drive. We're all going to pile in a van and road trip. It should be a great time.

I'm going to have a hard time choosing sessions: Neal Ford, Scott Davis, David Geary, Jeff Brown, and Bryan Sletten all have sessions that I'd like to attend, several of which are in conflict. I hope they do post-conference video delivery of these sessions just like they're doing for the Spring Experience.

If anyone's going to be there, let's do dinner one night and you can meet some of the St. Jude team.

Set Conditional Breakpoints in IDEA

2008-02-05T11:27:00.006-06:00

So yesterday I was attempting to debug an issue in a batch processing module within one of our applications. In short, an assertion was failing deep within Hibernate as it attempted to flush the session. Using a combination of various log statements, I had isolated the problem down to a particular record that the batch process was attempting to update. (BTW: I know you shouldn't be using Hibernate for batch processing - however, we're talking about batches of at most 1000 records here, not millions!) What I really wanted to do was set a breakpoint and examine the state of the objects at runtime; however, I dreaded the thought of clicking through the breakpoint time and time again until I got to the particular record that was causing the problem. "Surely," I thought, "there must be a way to tell the debugger to only break under certain conditions."

So, here's the code I wanted to examine:


public Publication parsePublication(String inputLine)
   throws ParseException {
       Publication publication = new Publication();

       String[] fields = inputLine.split("\t");

       publication.setPublicationType(fields[0]);
       ...
       return publication;
}

Essentially, I wanted to break after inputLine.split("\t"); if and only if fields[35] existed and was equal to "PM:16732581." After examining IDEA's Breakpoint dialog, I noticed a section in the bottom right-hand corner that I'd never played with before:

As it turns out, this is exactly what I needed. If you click on the ellipsis next to the drop menu, you get a context-sensitive editor equipped with code completion:

Enter the desired conditions and voila! A conditional breakpoint. It worked like a charm the very first time, and I only had to inspect the breakpoint when the problematic record came up.

Another nice feature of the conditional breakpoint is that if some sort of exception (such as a NullPointerException) occurs while attempting to evaluate the conditional expression, IDEA pops up a dialog informing you what happened and asking if you want to stop at the breakpoint or continue. Nice.

Grails 1.0 Released!

2008-02-05T09:48:00.001-06:00

Grails, by far my favorite of the JVM dynamic language frameworks, was released this morning, with a snazzy, new, "Web 2.0 style" website to boot. Congratulations Graeme and company on all of your hard work!

A Javascript Code "Prettifier"

2008-02-04T16:43:00.000-06:00

I came across a link today that would allow you to post "pretty" code in any HTML page. I've had plenty of problems (as have others) posting well-formatted source code to my Blogger-based blog. I've wanted to correct this problem for some time, and this project appears to be a decent solution. Here's an example:

function chooseWinner() {
   $('p3').removeClassName('winner');
   participantBo.chooseWinnerForEvent(eventId, function(data) {
      people = $A(data);
      updateDivs();
      intervalId = setInterval(doShift, 500);
   });
}

Now that isn't too bad is it? There seems to be a bit of a delay as the Javascript is loaded, but I think that's more a symptom of my connection than it is a problem with the script.

Here's how you can take advantage of this solution (quoted from http://google-code-prettify.googlecode.com/svn/trunk/README.html):

Download a distribution
Include the script and stylesheets in your document
(you will need to make sure the css and js file are on your server, and
adjust the paths in the script and link tag)
```
<link href="prettify.css" type="text/css" rel="stylesheet" />
<script type="text/javascript" src="prettify.js"></script>
```
Add onload="prettyPrint()" to your
document's body tag.
Modify the stylesheet to get the coloring you prefer

Put code snippets in
<pre class="prettyprint">...</pre>
or <code class="prettyprint">...</code>
and it will automatically be pretty printed.

The Spring Experience 2007 - Videos on the way!

2008-02-04T14:28:00.000-06:00

I got an awesome email today...

We are happy to announce that the video/audio streaming from TSE 2007 will be available online the week of February 11th for you. You will have the opportunity to see/hear the TSE 2007 presentations you were not able to make at TSE 2007 due to all of the great sessions available per time period. We have captured the entire session length including any demos/live coding. Please look for the email from us next Monday, February 11th with the details about viewing the session content online.

I'm extremely excited about this. For two reasons:

I didn't get to finish my reviews of the sessions that I attended. Now that it has been several weeks since the conference, I don't feel like my memory of them is good enough to do a fair review. Now I can do a refresh and write!
There were several sessions that I wanted to attend that I couldn't - now I get to attend...and write!

Look forward to some more reviews from The Spring Experience 2007 in the coming weeks!

Practical JRuby on Rails Web 2.0 Projects

2008-01-25T13:29:00.000-06:00

Are Java's days numbered as a web development technology? With buzzwords like Ruby, Rails, and Web 2.0 zipping around the web development community, one may begin to wonder. Could Java's lifespan be extended by finding synergy between Java and Ruby? On the scene comes JRuby, the definitive implementation of Ruby for the JVM. In his new book from Apress, Ola Bini guides the reader through the development of four Web 2.0 projects using JRuby on Rails. I think that Bini does a masterful job of always using the right tool for the right job. Read my review for complete details.

Mid-Year Review: My Professional Development Goals for 2007-2008

2008-01-02T16:33:00.000-06:00

Back in July I posted my professional development goals for the year (My performance review is annually in July, so it's a good time to set goals.), and it seemed like a good idea to take a look at my progress while doing the "New Year's Resolution" thing.

Learn Groovy and Grails

Andy and Dave suggest learning a new language every year, so this seemed like a good goal for me. I can't say that I've truly learned Groovy and Grails in depth, but I did learn them enough to do a presentation on them (as well as Ruby, JRuby, and Rails) at our Java User Group meeting in October, so I've effectively touched on two languages and two frameworks for those languages. I've since gotten interested in Scala as well. At any rate, I'd like to go deeper w/ Groovy and Grails as I have time, which is scarce!
Release HallKeeper v1.0 as part of #1

This project seems destined to fail. I haven't worked on it in any meaningful way since the summer. I've thought about it in the past week, and I'd actually like to try doing it in straight Java POJOs with Spring and Hibernate since I'm more well-versed in that area. At any rate, it really is my lack of spare time that keeps this one on the perpetual back burner.
Read and LEARN the following books:
- The Definitive Guide to Grails - Rocher
- The Pragmatic Programmer - Hunt, Thomas
- Computer Algorithms: Introduction to Design & Analysis - Baase, Van Gelder
- Concepts of Programming Languages: Sebesta
- Groovy in Action - Konig
I've pretty much finished #1, got started on #2, and haven't really touched the last three. Again, the needs of the moment have necessitated I focus on other areas, particularly other books. Recent projects have pointed me to three additional books I'd really like to cover this year, so I may not get to my original list. Here are the titles:
- Working Effectively with Legacy Code - Feathers
- POJOs in Action - Richardson
- Domain Driven Design - Evans
Review two books for the JavaLobby/DZone book review team

This is one I've hit the nail on. I just completed my second book review, which will be published some time in the next few weeks. My first review, Ajax Construction Kit: Building Plug-and-Play Ajax Applications, was published in October 2007. These have been rather time consuming and have kept me from other projects, so I don't plan to take any more reviews this year.
Pass the Sun Certified Programmer for the Java 2 Platform, Standard Edition 5.0 Exam

Haven't touched this one yet. Preparing for this will be one of my foci in the coming weeks.
Write one Java/software development blog article per week

I haven't done so hot on this one. OK, let's be really honest. I haven't come close. However, my recent flurry of entries on The Spring Experience 2007 have gotten me into a bit of a groove. I'm going to try to keep up the momentum and finish this year strong.
Attend JavaOne 2008 or similar conference

I've actually traveled twice since my original post. My first trip was to the Northeast Life Sciences Core Directors Meeting last November at Cornell University in Ithaca, NY. The purpose of this trip was to present and generate interest around our open source shared resource management system for core facilities, STJUDE-SRM. The trip was a great success. My second trip really fulfills this goal, as I attended The Spring Experience 2007 in Hollywood, FL. This proved to be one of the best technical conferences I've ever attended, and also one of the most fun!
Start a Memphis/Mid-South Area Java User Group

I don't think this goal could have gone any better than it has. In late July I started a Google Group and a small Google Page Creator website to attempt to drum up interest in a Java User Group for the Memphis, TN and surrounding Mid-South area. On July 23, 2007, along comes Diane Tabulog, a technical recruiter with local company Vaco Technology, who convinces her company to throw its support behind our JUG. All of a sudden we have an offer for a meeting location, food budget, giveaways, etc. Later, Clayton Naeve, our CIO at St. Jude, agreed to let us use our awesome conference room at our division's new offices at 160 Shadyac Avenue to meet, as Vaco's facilities were a bit small. On August 15, Carol McDonald, a Java Technology Evangelist from Sun Microsystems, offered to speak at our JUG, and we signed her up for the first meeting. Little by little, all of the necessary pieces started to fall into place, including additional free giveaways from Sun, O'Reilly, Atlassian, and JetBrains. The first meeting was a great success, and since then we've had two more successful meetings. Our next meeting is Thursday, January 17, 2008. Find out more at http://www.memphisjug.org.

Web Application Data Access Patterns: Keith Donald

2007-12-21T14:48:00.000-06:00

Well, after a short hiatus of getting back to "real" work, I'm going to attempt to squeeze in another Spring Experience 2007 entry. This particular session was my first of Friday morning. I've always enjoyed Keith Donald as a speaker, having first heard him at TheServerSide.com's Java In Action conference in 2005, and again during his Java University session at JavaOne 2007.

Keith began with a discussion of why we need patterns. In his opinion, patterns simply provide a way of thinking about a particular approach to a problem. One could liken them to blueprints. They typically have a name, a description of the problem being solved, a description of the solution approach, and finally a selection of implementation guidelines and considerations. Pretty nice summation.

The particular patterns that Keith planned to discuss surrounded the different data access patterns typically found in web applications.

Keith began by discussing the "Unit of Work" pattern, which he defined as a unit of interaction with a shared resource that executes independently of other units. These interactions exhibit ACID properties, and a database transaction provides a typical example. In the context of an ORM such as Hibernate, a Unit of Work tracks changes to the object graph during a transaction and then synchronizes those changes with the database when the transaction is complete. Keith followed this discussion with an implementation example from his "Reward Network" sample application.

Keith followed this discussion with two of what I'll call "subpatterns" of the Unit of Work pattern: Pessimistic and Optimistic Locking. With pessimistic locking, you prevent other units from accessing your data during a given unit of work, and then release the "lock" as soon as possible. This locking is performed to prevent a race condition, resulting in an inconsistent state in your model. Keith briefly illustrated implementation of pessimistic locking with Hibernate.

It's always interesting when someone asks a slightly off-topic question which ends up in a take home gem of information. At this point, someone asked if the implementations that Keith was showing showcased Spring's Hibernate support. To this Keith surprised me by answering (and I paraphrase), "Hibernate's native API's are much more mature and powerful now, so we recommend you use those rather than Spring's Hibernate API wrapper. Why add another dependency?" He then proceeded to recommend Rossen Stoyanchev's Saturday morning session on "Working with Hibernate in a Spring 2.5 Environment" (blog entry to come later!). One of the better quotes of the conference came during this aside as well:

Whenever you can eliminate a dependency, you should.
- Keith Donald

Well, back to the presentation. Keith then moved into a discussion of Optimistic Locking. Here, within a business transaction that executes across a series of system transactions, you use optimistic locking to prevent corruption of shared data. An examples is where several users can edit account information concurrently, but the frequency of concurrent access is fairly low. Data integrity is still at risk, so you use optimistic locking to handle those infrequent cases. Keith them demonstrated the use of Hibernate versioning to implement optimistic locking.

Keith next moved into a discussion of the controversial "Open Session in View" pattern. This is a specialized technical pattern where by the Hibernate session is kept open for the duration of a given web request. It is generally used as a "quick fix" to prevent lazy loading exceptions in the view tier. This is generally considered a bad thing, as you end up with a great deal of "N+1 Select" situations while rendering the view, resulting in way too much SQL executed against the database. Typically, the need to use this pattern reveals a flaw in the design of your model or queries. For example, since you generally know how far in the object graph you'll need to go for a specific view, you should load those relationships eagerly for that use case. You may also consider whether or not a given object association is appropriate to begin with.

The final major pattern that Keith discussed was the "Conversational Persistence Context" pattern that is present in the upcoming Spring Web Flow 2.0 release. It is essentially a more flexible variation of the Open Session in View pattern, where by you can have an open session spanning multiple requests during a long-running user interaction context, or "conversation." To be perfectly honest, I still don't quite "get" this pattern beyond that, probably because I don't know much about Web Flow or it's cousins (e.g. Seam, Web Beans JSR-299).

Keith closed with a very brief description of Master Detail, where you show an overview of objects in a collection and then allow drilling down into object details, and Paging, where you allow users to easily browse through a list of items of interest. I raised a point of contention with Keith at this point. His example implementation showed delegation of the paging concern to the DAO layer, rather than implementing that concern in the View layer. When I asked him where he thought it belonged, he thought it was obvious that it belonged in the DAO layer. I then let on that we had this debate in our team and decided the the concern belonged in the View layer. Why should I run the same query multiple times just to page through the data? Why not load the entire data set and then let the View tier decide how to page through it? Keith gracefully acknowledged my point.

All in all, this was a great session, if for no other reason than it reminded me of some best practices in this area and let me in on the little secret about using native Hibernate API's rather than Spring's Hibernate template. Nice job, Keith.

Goodbye Spring Experience 2007!

2007-12-15T21:09:00.000-06:00

Well it had to end eventually. As you can see, I'm hopelessly behind on my blog entries, having only made it through my first day of sessions. I've still got several more I intend to cover (I probably won't do the last two as I started blanking out - I think my brain was pretty much melted by this afternoon). Look for those entries in the coming days. Many thanks go out to No Fluff Just Stuff and SpringSource for putting on an awesome conference!

There were several things I really liked about this conference that I believe set it apart from most of the conferences that I have attended.

The technical content was top-notch - Spring topics from the developers themselves. There were also quite a few architecture/design sessions that were also superb.
The session length, at 90 minutes, provided ample time to cover each topic pretty well in-depth. The session scope cooperated with this, as most of the speakers didn't try to do too broad of subjects for the time allotted.
It was a smaller conference, at a little over 500 developers. This meant you weren't trying to weave through crowds to get in queues for packed out sessions like at JavaOne. Much less stressful.
The atmosphere was just plain fun. Everyone was laid back. I mean, how many conferences give you a bobblehead doll on the first night! I now issue a call out to Sun that we must have a James Gosling bobblehead doll issued to every attendee at JavaOne 2008!
The food was top notch - every meal was provided, buffet-style (no boxes!!!). I ate way too much.
The location was great. You can't beat a front-on view of the Atlantic Ocean from the conference center balcony during session breaks.
SWAG! Let's see what all I collected: a computer bag, a binder with all of the slides, two t-shirts, a hat, sunglasses, a beach towel, a Frisbee, a NFJS Anthology, a bobblehead doll, a Spring Source toolkit (two screwdrivers and a measuring tape - you'd have to see it)...what's more, Jay Zimmerman distributed the left-over swag after the conference closed. I picked up two more computer bags full of swag and two conference binders to give away at the January and February Memphis JUG meetings!

Once again, thanks for a great conference. It was easily the best all-around that I've attended.

The State of the Art in Dependency Injection: Rod Johnson

2007-12-15T09:06:00.000-06:00

This was a truly fascinating talk. If you ever wanted to learn the entire history and landscape of dependency injection (DI), this was your opportunity. I really didn't realize how deep of a topic DI really is.

According to Rod, DI had its beginnings in 2002, in the Interface 21 Framework that was born from his seminal work, Expert One-on-One J2EE Design and Development. In the beginning, DI was done solely through setter injection (SI), with external metadata (usually in XML). 2003 gave us Spring 0.9, which had the same DI model, but added FactoryBeans for indirection and proxy-based AOP (enabling among other things, declarative transaction management). With Spring, DI was always just one enabler of a complete enterprise solution. Contrast that with PicoContainer, also arriving on the scene in 2003, which was an ultra-lightweight DI-only container. PicoContainer brought us several innovations, including constructor injection, automatic resolution by type, and an attempt to dispense with external configuration.

Rod then discussed the Pros and Cons of Constructor Injection (CI). On the Pro side, we see that CI is great for immutable objects, can be used with existing code, enforces that the necessary dependencies are provided at object construction, and allows developers to dispense with methods like afterPropertiesSet(). On the Con side, there are no default arguments in Java, which forces us to ALWAYS provide all of the necessary dependencies, constructor overriding can be somewhat messy, and constructor argument names are not usually available through reflection, which forces us to depend on argument order for dependency resolution.

Spring 1.0, which arrived in late 2003, incorporated some of PicoContainer's innovation: CI, "Autowiring" by type and by name, as well as the ability to mix CI and SI. Here Rod reflected on Spring's pragmatic philosophy, whereby they are more than willing to incorporate the good ideas that others had first.

Spring 1.1 brought us method injection, a unique Spring feature, which solved the problem of long-lived managed objects which depend on short-lived objects. It also brought us Factory Methods. You now had the ability to create objects through invoking static factory methods or instance methods on other beans.

With the finalization of the EJB 3.0 standard in May 2006, several new ideas became available in the world of DI: annotation-based DI, annotations for callback methods (e.g. @PostConstruct), scanning for annotations without any external configuration needed for a deployment unit, and field injection (FI). These EJB standard brought with it a new philosophy - that annotations are a superior model and that externalization should be a second-class citizen. The Pros of this standard? One big one - no configuration is necessary for simple cases. The Cons? Rod listed several: resources could only be injected from JNDI, no CI, limited control over object lifecycle, unsuitability for fine-grained object graphs, effectively usable ONLY with annotations, as the XML configuration option is so verbose, and it isn't just DI - it brings along with it enforcement of many obsolete EJB concepts (such as bean instance pooling).

Spring 2.0 arrived in late 2005 with its own share of innovations: integration with AspectJ, the ability to inject anything with an AspectJ aspect via @Configurable, namespaces to provide an XML-based DSL for external configuration, the @Required annotation, and pluggable scopes to manage the object lifecycle. About that same time, JBoss Seam introduced many strange ideas (that I didn't quite grasp from Rod's explanation): bijection, outjection, and subversion of control.

Some additional players on the field include Spring Java Config, which is a DSL for configuration in Java, Google Guice 1.0, and the JSR-299 Web Beans spec, which Rod described as "blogware" in that there is currently no available implementation.

Finally we got to Spring 2.5, released last month. Rod didn't have his slides printed or available on the web (argh!), so about this time my hand was really hurting from taking furious notes, and I simply gave up. Fortunately, most of what Rod covered was redundant from some of the other sessions, so I'll have or will blog about it later. About the only thing I really don't have good notes on is Spring Java Config, which he discussed pretty extensively. If you want to learn more about it, check out http://www.springframework.org/javaconfig.

Ajax Integration Guide for 2008: Jeremy Grelle

2007-12-14T14:40:00.000-06:00

This talk looked really exciting going in. Jeremy is a member of the Spring Web Products team and the lead of Spring Faces, as well as a member of the JSF 2.0 Expert Group. He describes himself as the resident Ajax freak at SpringSource. Jeremy began by discussing the current Ajax landscape, highlighting what he believes are the important features a successful framework must deliver, and then identifying the frameworks he considers to be the cream of the crop. No surprises here on the list: Prototype/Scriptaculous, jQuery, YUI, Ext, and Dojo. He then gave a brief high-level overview of each framework - I really didn't learn anything new here, as I've been following these frameworks for quite awhile. He mentioned the commonality that all of these frameworks are about more than asynchronous client-server communication - they're about improving your client-side code and user experience. See Dion's May 2007 comment that Ajax "was never about the acronym - it's about building killer websites." What is good about all of these frameworks is that you can use all of them in an unobtrusive manner and progressively enhance your UI. This gives you the ability to only Ajaxify what you need and also get graceful degradation.

In the second portion of his talk, Jeremy talked about connecting to Spring. I was really hoping that the "goods" would be delivered here. He started by mentioning DWR, which I think is a really nice framework. It merited 2 slides and no demo (even though there was a slide mentioning a demo). I don't think Jeremy really cares for it or GWT, as he sort of lumped them together and didn't mention them again. I do appreciate his point that neither really allows you to harvest any existing controlling infrastructure that we may have built using Spring MVC or another framework.

Jeremy then moved into what he considers the better way to do it, which is the progressive enhancement I mentioned above. He took the existing Spring Booking MVC + Web Flow example application and ajaxified portions of it. He did this using an interesting combination of Apache Tiles, some Javascript "pseudo-AOP" he lifted from the SpringFaces project, and a bit of Dojo. It seemed to work really well, but it wasn't immediately clear how this type of technology was going to be made available to us as developers. He said something along the lines of "you don't have to be using JSF to use this Javascript, so we probably need to change the name to something else." I hope they figure out soon so I can get my hands on it. :-)

He closed by briefly discussing REST's place in the future of Spring Web. The ideal scenario, according to Jeremy, is that we will be able to request different representations of the same resource. For example, we could request HTML for full page display or partial DOM updates, and JSON for intelligent widgets like the Dojo table.

It looks like a lot of exciting things will happen in 2008. I hope I don't have to wait too long.

What's New in Spring 2.5? : Juergen Hoeller

2007-12-14T14:20:00.001-06:00

This was my second talk of TSE 2007. I have to admit I chose it by process of elimination - none of the second session talks particularly jumped out and grabbed me like Chris Richardson's talk.

Juergen is the project lead for the Spring Framework, so he was the obvious choice to give this talk. Juergen split it up into three sections:

Platforms
Annotation Configuration
AspectJ Support

To break down part one as quickly as possible, Spring supports virtually EVERYTHING. You get JDK 1.4 all the way to Java 6, including all of the new API's in Java 6. It fully supports Java EE 5 while remaining backward compatible all the way to J2EE 1.3. You can now deploy a Spring ApplicationContext as a RAR file, and you also get full JCA 1.5 support (if you want to know what that means, don't ask me :-)). Quite notable was the fact that they have worked with IBM to support WebSphere's proprietary transaction manager. Also interesting was Spring's continuing strong support for OSGi as an alternative enterprise runtime.

The annotation configuration part of the talk was quite fascinating. I'm something of an annotations junkie - I have to be careful about that. At any rate, it was so good that I was interested enough to attend Juergen and Mark Fisher's later talk that was completely dedicated to the subject. I'll leave the details for my entry on that talk.

The final portion, on AspectJ support, was equally fascinating. The first new feature was the ability to advise specific beans by name rather than by type using AspectJ. This was made even sweeter by the fact that you can use pattern matching in your definition. Very exciting was the ability to do AspectJ load-time weaving, meaning you can use the power of AspectJ at runtime without involving the AspectJ compiler. Unfortunately, this isn't available across all appservers. I didn't get a chance to ask and comfirm, but it seems that JBoss (our primary appserver) does not support this. GlassFish, Weblogic, OC4J, and Tomcat were all mentioned as being able to handle it.

The most interesting part of this talk for me was the ability to annotate a class as @Configurable, and then do dependency injection on it even thought it isn't managed by Spring. You could do this in Spring 2.0, but you had to use the AspectJ compiler. Now, with load-time weaving, you can do this at runtime! I really could have used this recently when I wanted to inject a single dependency into a class that was really overkill to manage as a Spring bean. Since I'm using Spring 2.5 in this project, I can go back and try this feature. Exciting!

Pair Programming with the Official Rod Johnson Bobblehead

2007-12-13T20:20:00.001-06:00

As you can see, Rod really likes my Spring MVC configuration. :-)

Improving Application Design with a Rich Domain Model: Chris Richardson

2007-12-13T16:32:00.000-06:00

This was my very first session of the conference. I've really been looking forward to it. I became pretty excited about object-oriented programming when I first really learned it in my computer simulation course at Ole Miss. In that course we built discrete event simulation programs using collaborating Java threads. Each thread implemented an object from the domain model representing a particular simulation problem. Once I got into the "working world," I found that the architecture described by Rod Johnson as the "J2EE stove pipe" had made my OO skills essentially unusable in the projects on which I was required to work on a day-to-day basis. My recent experiences developing in a more POJO-based style, particularly with JPA/Hibernate, have allowed me to get closer to my preferred OO-style, but the business logic still lived in the service-tier. My domain model was still essentially "anemic" to borrow from Martin Fowler.

When I read the description for this session I was elated! Finally I could see that someone was building real enterprise applications using object-oriented techniques! I've never quite been able to articulate what I felt was wrong with the way we're building applications in my group. I was fortunate enough to have breakfast with Chris Richardson prior to the session, and he said that addressing my inability to articulate those problems was one of the goals of his talk. Awesome! On to the session...

Chris began with a tour through his object-based programming experience, beginning in LISP, followed by C++ and then Java. Around 1999 he got into EJB programming, and described his experience as "Applications were still built from objects, but those objects were very different..." Basically the EJB paradigm caused us to abandon object-oriented programming in favor of procedural programming. Why? Well, for all of the pros surrounding EJB, it made writing object-oriented code difficult, and in some cases, impossible. The EJB/procedural style works very well for simple business logic, but it doesn't scale well as business logic becomes more complex. The result is a few monolithic transactional classes containing hundreds to thousands of lines of code embedded in very long methods. Hence, the legacy of EJB (and I quote):

Java is an object-oriented language, AND...
Object-oriented design is a better way to tackle complexity, YET...
Many complex enterprise Java applications are written in a procedural style

Chris then moved on to discuss the rich domain model pattern, which is really nothing new at all. It's just good OO design. Most of your classes (or entities) correspond to real world concepts, and the business logic is spread amongst them. Classes are true objects: they contain state and behavior. The goal is to push as much business logic as possible down into the domain objects, which is exactly where it belongs. What do you get? Better maintainability, better testability, better reusability, and a better shared understanding of your domain. Not only that, but your code is quantifiably simpler! Who doesn't want that? The main drawback to this is that you have to have good OO design skills to make it happen - which is exactly what the EJB programming model has made scarce.

Chris followed this up by discussing the building blocks of domain models, concepts he derived from Eric Evans' book Domain Driven Design. In a nutshell, they are Entities, Value Objects, Aggregates, Services, Factories, and Repositories - the reader can get the book to find out what these are. Interesting notes for me include the fact that Repositories are nearly equivalent to DAO's, especially the way I typically implement them. The concept of a Service is far different from what I'm used to. I "grew up" writing services according to the EJB Session Bean/Facade model, where essentially all of your business logic resides in service methods. Chris defined a service as a class implementing only logic that cannot be put in a single entity. They are actually quite thin!

Next came the discussion of frameworks and their role. In short, frameworks act as an enabler to rich domain models when used properly. Your domain model should be implemented purely as Plain Old Java Objects (POJO's) in that they don't implement any infrastructure interfaces or call infrastructure API's. The jury is still out on annotations - Chris argues that they still violate the POJO concept, I'm not so sure. You then wire your model together using dependency injection, handle crosscutting concerns (transaction management, security, logging, etc.) with Aspect-Oriented Programming (AOP), and use object/relational mapping (ORM) for persistence. What you often run into as obstacles are that many of these frameworks, particularly web and ORM frameworks, force you to introduce "smells" into your code for the framework to use them. Examples include requirements for public default constructors and JavaBean-style setters.

Chris closed with an awesome discussion of common code smells and the refactorings used to eliminate them. I was most interested in Feature Envy, which is where you have methods that are far too interested in data belonging to other classes. This is very common in session facades, and the healing factor is to push that logic down into the appropriate domain classes. Another interesting smell was Primitive Obsession, where code uses built-in types (such as String and Integer) instead of application classes to represent state. The refactoring in this case is to introduce Value Objects, which are immutable, validated objects representing domain concepts (e.g. a shipping address).

Chris closed with the charge to begin refactoring our procedural designs into a rich domain model on MONDAY! Oh, how I can't wait to begin. Good job Chris!

Enterprise Java and the Changing of the Guard

2007-12-13T13:02:00.000-06:00

Greetings from The Spring Experience 2007 in Hollywood, FL. So far this has been a great conference - I'm currently waiting for my third session of the day to start. As much as I enjoy all of the hype and eye candy at JavaOne, I really get a lot more out of these smaller conferences as you're not running around stressed out trying to weave through thousands of geeks as you move from session to session (or more accurately, from session to queue!).

I wanted to post a few insights that I gained from Rod Johnson's keynote last night (the title of this entry). The basis for Rod's presentation was a Gartner report entitled "Trends in Platform Middleware: Disruption Is in Sight." To summarize, there are many converging forces in the enterprise Java space that are causing or will probably cause a great deal of disruption in the way we develop enterprise Java applications. These forces include our collective experience with application servers, the rediscovery of object-oriented or POJO-based programming, open source innovation, non-Java challengers (.NET, RoR), the rise of SOA, and Rich Internet Applications. Rod sees a big movement from the "old guard," which he described as the "J2EE Stovepipe Architecture" which was based primarily around the idea of distributed objects, to a world in which many of the highest volume Java applications don't even use a Java EE application server. An interesting point was the stagnation in job requirements for the big name application servers coupled with the BZ Research statistic that 64% of Java application developers are using Tomcat for production deployment. Yet another force for disruption is the emergence of OSGi, which allows developers to modularize applications and provides facilities for versioned components, fine-grained redeployment, and library conflict resolution - all features that Java EE currently does not and perhaps cannot address. Open source provides yet more disruption, as developers have become participants in rather than spectators of the development of Java enterprise solutions. Innovation is now primarily coming from the open source world. All of this culminated in the rather telegraphed conclusion that Rod (and also the Gartner report apparently) believes that Spring is uniquely positioned to provide the best value for ongoing Enterprise Java development in the face of the current trends. Of course, what would you expect him to say? :-)

I do tend to agree with him. The pace at which Spring is innovating and addressing the Java enterprise pain points far outpaces the pace of the JCP. It just takes too long to design specs by committee. One of the more wise things that Spring does is to learn from and in most cases accommodate the changing landscape of Java EE and integrate the best features directly into the framework. I for one am glad to be developing applications with Spring, as it makes it very easy to do the things I want to do and write quality code that isn't directly dependent on an infrastructure framework. Generally, it stays out of my way.

More to come on the sessions I've attended thus far.

13949712720901ForOSX

2007-11-08T08:22:00.000-06:00

Here's my vote for Java 6 on Mac OS X Leopard!

13949712720901ForOSX

Ajax Construction Kit: Building Plug-and-Play Ajax Applications

2007-10-12T17:03:00.000-05:00

My first book review for Javalobby was published today!

Please support me in the 2007 Walk to Cure Diabetes

2007-09-05T11:00:00.000-05:00

This year, I'll be taking part in JDRF's Walk to Cure Diabetes, along with one-half million other walkers across the country, as we try to reach our goal of raising $90 million.

Type 1, or juvenile, diabetes, is a devastating disease that affects millions of people - a large and growing percentage of them children. One of them is my oldest daughter, Abby, who is three years old.

Since Abby's diagnosis, she's had her fingers pricked over 800 times already. She's received more than 200 shots in her arms, legs, and tummy. Over the course of her life, she'll continue to receive daily insulin injections and finger pricks. She must take insulin to stay alive. We must constantly monitor her glucose levels to ward off complications such as blindness, kidney failure, and stroke. Abby must maintain strict control of her diet every day (even on birthdays and holidays), check her blood sugar at least 6 times a day, and take insulin at least twice a day.

There is some good news, though. For the first time, scientists are predicting that we CAN expect to see a cure well within our lifetime! This is exactly what we're wishing for, so we've formed a team called "Wishing With Abby," and we'd love to have your help.

Please visit my Walk Web page if you would like to donate online or see how close I am to
reaching my personal goal:

http://walk.jdrf.org/walker.cfm?id=86761462

Follow this link to make a donation:

http://walk.jdrf.org/support.cfm?id=86761462

Welcome to Matt's Mac Paradise

2007-08-29T16:11:00.000-05:00

I've been wanting to post a picture of my new work setup for awhile, but I wanted to wait until I finished getting setup over at 160 Shadyac Avenue. Just for fun, I thought I'd go VMWare Fusion crazy and boot up every virtual machine I've got - you're actually looking at 7 OS's booted concurrently between two machines. To the left I've got my 15" MacBook Pro (2.2 GHz Intel Core 2 Duo processor, 4 GB 667 MHz DDR2 SDRAM) running Mac OS 10.4, Windows XP, and Ubuntu. To the right I've got my Mac Pro tower (2 x 2 GHz Dual-Core Intel Xeon processors, 5 GB 66 MHz DDR2 FB-DIMM RAM) driving the dual 19" Dell LCD's, running Mac OS 10.4, Windows XP, Ubuntu, and Solaris Express. Whew - that was a mouthful. Thanks to Matt Raible for blogging about the Griffin Technologies iCurve laptop stand - I picked up its successor, the Elevator, for my MacBook Pro. I've got pictures from my past desktops over the years - I need to dig them up and show the procession of developer technology here. It's been quite a ride from my first system as a junior developer six plus years ago.

Haven't had much time to blog lately....

2007-08-17T15:54:00.000-05:00

....because we've been packing to move on top of all of our regular projects. St. Jude has nicely renovated a new building for us, so we developers are moving. This is where I'm headed on Monday:

I'm both loving it and a little sad - I've been sitting in my desk for nearly my entire career as a software developer. I just know I'm going to park in the garage and come downstairs one morning to find my office gone. :-)

STJUDE-SRM 1.0 Released

2007-07-27T13:59:00.000-05:00

From http://sourceforge.net/forum/forum.php?forum_id=719803:

On July 27, 2007, STJUDE-SRM 1.0 was released.

STJUDE-SRM is a laboratory management system designed to support shared resource facility (or core lab) activities. It was designed and developed by the Hartwell Center for Bioinformatics and Biotechnology at St. Jude Children's Research Hospital.

Shared resources supported include DNA synthesis, Peptide synthesis, DNA sequencing, Functional Genomics (spotted microarray laboratory), and Affymetrix (commercial microarrays) laboratories. STJUDE-SRM was also designed so that it is sufficiently modular and scalable to support other laboratory activities as needed. It could conceivably support all facilities on a campus or at a research organization and provide a single portal for investigators to access these resources, retrieve data, receive invoices for services, and generate reports.

Currently available is a build of STJUDE-SRM which is certified for JBoss 4.2.0.GA running on J2SE 5.0. Builds for JBoss 4.0.5.GA and BEA Weblogic Server 8.1 are forthcoming.

STJUDE-SRM 1.0 can be downloaded here: http://sourceforge.net/project/showfiles.php?group_id=197795

Please report all bugs you find in the STJUDE-SRM bug tracker: http://sourceforge.net/tracker/?group_id=197795&atid=962898

This is a VERY satisfying announcement for me, as I have spent the better part of the last six years working on this project. I was so excited when I learned we would be releasing it to the open source community. Enjoy!

For more information on STJUDE-SRM, please visit: http://stjude-srm.sourceforge.net.

My Professional Development Goals for 2007-2008

2007-07-10T14:14:00.000-05:00

I posted earlier on my desire to become a better programmer. Well, I've since put together a plan of action for the next twelve months. I've based some of these goals on suggestions from The Pragmatic Programmer by Andy Hunt and Dave Thomas.

Learn Groovy and Grails

Andy and Dave suggest learning a new language every year. I had already informally started learning Groovy and Grails after JavaOne 2007. Since I already have a head start on this one, Groovy will be my language for the next year (I'm learning Grails mainly because of my web development background - it will provide me more opportunity to apply my Groovy knowledge). This should be an easy way to get started on the goal of a new language each year since my Java knowledge should transfer easily.
Release HallKeeper v1.0 as part of #1

Several years ago I started an open source project called HallKeeper. HallKeeper is planned to be a web-based management system for university residence halls. Life got in the way of this project so it lay dormant for a few years. I've recently revived it as sort of a "lab" in which to learn Groovy and Grails, and hopefully have a little fun along the way.
Read and LEARN the following books:
- The Definitive Guide to Grails - Rocher
- The Pragmatic Programmer - Hunt, Thomas
- Computer Algorithms: Introduction to Design & Analysis - Baase, Van Gelder
- Concepts of Programming Languages: Sebesta
- Groovy in Action - Konig
When I say LEARN, I mean I don't just want to do a cursory read of these. I want to really engage the concepts presented in each and apply them to my day-to-day work. I already have a head start reading the first two books. The third and fourth books are actually textbooks from my undergraduate education. I could really use a refresher on these concepts, and I think I'm a much more serious student now as a professional than I was when I was actually a student.
Review two books for the JavaLobby/DZone book review team

I joined this team several months ago and was actually assigned to review two books - again, life got in the way (if you have any small children, you'll understand). Things have settled down a bit now and I've asked to rejoin. Hopefully I'll be able to crank out some reviews this time and learn something in the process.
Pass the Sun Certified Programmer for the Java 2 Platform, Standard Edition 5.0 Exam

I want to do this mainly to give myself an excuse to go back over the fundamentals of Java, as well as learn the new features that 5.0 brought to the table in detail (generics, annotations, etc.). I have still basically been living in a Java 1.4 world as I'd say roughly 85% of my daily work is on an application that is still bound to that JDK. So, passing this is mainly just a reason to study, and it is a nice edition to the resume as well.
Write one Java/software development blog article per week

This would be numero uno! I've always stressed about the frequency of my blog writing - I've felt compelled to write every single day, and I usually end up writing a one paragraph synopsis of some other guy's blog entry. Not exactly something that will attract many readers. I'll still post those on a more frequent basis as they keep the content flowing, but I also want to write at least one in-depth article per week to give people something to look forward to. One way I'll do this is to blog about the books I'm reading. The Pragmatic Programmer provides challenges and/or exercises at the end of each chapter - great seeds for entries.
Attend JavaOne 2008 or similar conference

This one depends on the boss - hopefully I'll get to travel again this year. I'd love to go back to JavaOne - I learned a lot, and big geek shows always motivate me to go back and introduce new technology to the group, as well as get more involved in the community. I always feel a surge in my professional development in the 2-3 month period following my attending a conference.
Start a Memphis/Mid-South Area Java User Group

We don't have a JUG in this area and I really think that we could benefit from one. My company has a large number of Java developers, and I know that several others in the area, including FedEx and Autozone do as well. This would be a great way to get some of the good speakers from the conferences I've attended to speak locally, and it may even serve to get us on the map with some of the smaller shows like NFJS. Sun and others really seem to take an interest in supporting JUGS, so I look forward to see what happens. I've started a Google Group for the newborn JUG, and I'll be blogging more in the future about it.

On Agile: Why You Won't Fix It Later

2007-07-09T09:48:00.000-05:00

Ryan Cooper writes a brilliant essay on why quick fixes today turn into tomorrow's code rot. I believe every word of this article. Unfortunately, I'm all too often my own worst enemy when it comes to implementing these ideas. Thanks for the reminder, Ryan!

On Agile: Why You Won't Fix It Later

Graeme Rocher's Blog: 5 More Misconceptions About Grails

2007-07-06T09:28:00.000-05:00

Graeme Rocher, founder of the Grails project, answers five more misconceptions about Groovy/Grails vs. Ruby/Rails. I've grown to be quite fond of both of these languages/frameworks; however, given the amount of investment I've placed into learning and applying Spring and Hibernate to the applications I've developed over the past two years, I have to say that Grails just makes sense for me as the next step toward becoming more "dynamic" in my approach to development projects.

Graeme Rocher's Blog: 5 More Misconceptions About Grails

Help me become a better programmer!

2007-07-02T15:12:00.000-05:00

I have decided to embark upon a quest to become a better programmer. I would really like to improve my understanding of the computer science that underlies my day-to-day tasks, particularly as it relates to programming language design as well as algorithm design and complexity analysis. I would also like to improve my analytical and problem solving skills. I've found that I'm really good at learning new technologies and quickly bringing them to bear on web application development problems, but take me out of that problem space and I get nervous rather quickly.

Who has ideas about the best way to go about this? Please comment!

How to implement form-level validation in JSF

2007-06-27T12:54:00.000-05:00

Recently I was faced with the challenge of implementing form-level (or page-level) validation in a JSF-based application. What I mean by form-level validation is the need to evaluate a subset of a form's fields as a unit, rather than simply validating each field in isolation. An example of this type of validation can be found on a user registration form where one has to select a password in one text field, and then retype the same password in another text field for confirmation. Validating that these two text fields contain the same password is an example of form level validation.

In my case, I had two date selector components on my form, one for a start date/time and one for an end date/time for an event that was being scheduled. The rule I needed to validate was that the end date/time was later than the start date/time.

There are a few ways to implement validation like this, including but not limited to:

Build a custom component that renders selectors for both the start and end date/time, then validate as a unit. This actually is field-level validation and doesn't truly address the form-level problem.

Implement a validator method on a managed bean that will evaluate the data submitted for multiple components.

I'll address the second method in this HOWTO.

First, you'll need to bind at least n-1 of the components that you want to validate to properties on your managed bean. The simplest way is to declare properties of type UIInput:


private UIInput startDateComponent;

public UIInput getStartDateComponent() {
    return startDateComponent;
}

public void setStartDateComponent(UIInput startDateComponent) {  
    this.startDateComponent = startDateComponent;
}

and do the actual binding in the JSP:


<t:inputDate id="eventStart" value="#{orderForm.sampleInfo.requestedStartTime}"
    type="both"
    popupCalendar="true"
    ampm="true" binding="#{dateValidationForm.startDateComponent}"/>

Next, you'll implement the validation method, which can have any name you like, but must share the same signature as this example:


public void validateEndDate(FacesContext context, UIComponent toValidate, Object value) {
    Date endDate = (Date) value;
    Date startDate = (Date) getStartDateComponent().getLocalValue();

    if (startDate == null) {
        context.addMessage(getStartDateComponent().getClientId(context),new FacesMessage("Please specify a valid date and time."));
        throw new ValidatorException(new FacesMessage());
    }

    long endTime = endDate.getTime();
    long startTime = startDate.getTime();

    if (startTime >= endTime) {
        addError("errors.batchOrder.invalidEndDate");
        throw new ValidatorException(new FacesMessage("Event end must be later than event start."));
    }
}

And finally, you'll bind the validation method to the last component in your subset of components that need to be validated together:


<t:inputDate id="eventEnd" value="#{orderForm.sampleInfo.requestedEndTime}" type="both" popupCalendar="true" ampm="true" validator="#{dateValidationForm.validateEndDate}"/>

To understand why I say n-1 components, think of the way the validation phase occurs in JSF. Data is bound to the components in the order that they occur in the JSF component tree, which just so happens to be the order in which they appear in the JSP source. Looking at the validateEndDate method, you'll see that I only reference the startDateComponent from the binding, but I reference the endDate as the Object value reference that was passed into the method. This is why you only need to bind n-1 components, because you get the nth component from the method signature.

If you want to be more uniform and bind all of the components, you could create an extra dummy hidden value component and bind the validator method to it. You could then bind all of the components to your managed bean and access them all from the bindings rather than accessing one from the method signature.

The validateEndDate method itself is rather simple. First you access the data by getting the local value of each component (again, the endDate value is not accessed in this way - in fact, it hasn't been bound yet because it must be validated first, and that's what's happening in this method!). You then apply the business rule. You'll see that first I look to see if the startDate is null. I'm not sure why this is possible, but if the startDate was not submitting a good value on the FIRST submit, the local value was null. So, I catch that here. I add an error message to the startDateComponent and throw a ValidatorException. If the business rule is violated, throw a ValidatorException. (I'm also using the addError method provided by AppFuse to work w/ its message framework as well, but that is not necessary w/ all JSF apps).

Now, for the final problem I encountered. In Weblogic server, which we're still using for the time being, if your session cannot be serialized then it deletes your entire session. Obviously this can cause major problems in any web app. To deal with this, ANY SESSION SCOPED MANAGED BEAN must be fully serializable, meaning it and any objects referenced in its state. Herein lies the problem for JSF. Instances of UIComponent (an ancestor of UIInput) are not serializable, so if we bind our components to UIInput fields on a session-scoped managed bean (the bean backing this form is an Order Form/Shopping Cart style bean), it will not be serializable and Weblogic will kick out your session.

To deal with this problem, realize that there is no reason that you can only have one managed bean backing a form. In fact, you can reference as many managed beans as you need. Since validation is done for each request, there is no need to manage any state there across multiple requests like we need to do with a shopping cart. So, why not declare an additional managed bean that is REQUEST SCOPED, and then put the bindings and validation method there. That is exactly what I did. Here is the entire bean:


public class DateValidationForm extends BasePage {

    private UIInput startDateComponent;

    public UIInput getStartDateComponent() {
        return startDateComponent;
    }
 
    public void setStartDateComponent(UIInput startDateComponent) {
        this.startDateComponent = startDateComponent;
    }

    public void validateEndDate(FacesContext context, UIComponent toValidate, Object value) {
        Date endDate = (Date) value;
        Date startDate = (Date) getStartDateComponent().getLocalValue();

        if (startDate == null) {
            context.addMessage(getStartDateComponent().getClientId(context),new FacesMessage("Please specify a valid date and time."));
            throw new ValidatorException(new FacesMessage());
        }

        long endTime = endDate.getTime();
        long startTime = startDate.getTime();

        if (startTime >= endTime) {
            addError("errors.batchOrder.invalidEndDate");
            throw new ValidatorException(new FacesMessage("Event end must be later than event start."));
        }
    }
}

and the declaration in faces-config.xml:


<managed-bean>
    <managed-bean-name>dateValidationForm</managed-bean-name>
    <managed-bean-class>org.stjude.hc.srmcti.webapp.action.ordering.DateValidationForm</managed-bean-class>
    <managed-bean-scope>request</managed-bean-scope>
</managed-bean>

The added bonus is that you can reuse this bean across all forms where you need this behavior. My application happens to have 2 additional forms where I would have repeated this logic, so I just reference this bean there.

Enjoy!

The Grove Coffee House Rocks!

2007-06-22T21:27:00.001-05:00

It's Friday night, and what am I doing but coding. My wife's night out is spent at the scrapbook store working on her latest layouts - mine is at my new favorite coffee shop, working on open source. I discovered this place on a date with Wendy a couple of months ago. The nice thing about it is the distinctly Christian atmosphere. A good friend of mine and I meet here on Friday mornings for accountability. Well, since they hand out free wireless internet, I thought I'd drop by for my night out as well. Good coding atmosphere - I have a nice corner with a plugin for my laptop, so I'm good to go. Check this place out if you're in DeSoto County, MS or the Memphis metro area anytime soon - http://grovecoffeehouse.com.

Migrated

2007-06-19T16:50:00.001-05:00

I recently migrated all of my Java/Development related posts from http://www.analienandastranger.com. I want to make this a PRIMARILY Java/Development-related blog. When I was splitting my efforts between Christianity and Software Development, I was quickly getting burned out and not writing anything. If you want to read any of my old devotional posts, I will be keeping the other blog alive for awhile. Since the hosting is being provided to me free (as well as the domain), I will in good conscience need to shut it down eventually. I just feel that using Blogger gives me greater visibility - I do want people to actually read this stuff, ya know? :-)

And then it was over...

2007-05-11T22:57:00.000-05:00

I really enjoyed "The Toy Show" this morning. James Gosling went through a flurry of different demos from around the "cool" Java world. I was especially impressed with Project Wonderland (http://lg3d-wonderland.dev.java.net/), a virtual workplace environment, and with the real-time robotics demos. Unfortunately I was so sucked in that I didn't get any good photos.

If anything you could call this my day on the back end. I attended four sessions, two of which were focused on that.

- Comparing the Developer Experience of Java EE 5.0, Ruby on Rails, and Grails: Lessons Learned from Developing One Application
- Implementing Java EE Applications Using Enterprise JavaBeans (EJB) 3 Technology: Real-World Tips, Tricks, and New Design Patterns
- The Top 10 Ways to Botch Enterprise Java Technology-Based Application Scalability and Reliability
- Exploting JRuby: Building Domain-Specific Languages for the Java Virtual Machine

I scheduled the first session because I thought it was be a good way to tie together all that I had learned about Grails and Rails and then compare it to my existing Java EE knowledge. As it turns out, the speaker believed that given tool support, the development experience wasn't all that different between the three. He then gave some performance comparisons, but I wasn't all that sure the analysis was very sound. Java EE came out way on top. I hadn't heard that it outperformed the others by quite as much as he showed. He made a rather dubious statement when he said that Grails and Rails weren't protected by standards. Groovy is a JSR and Grails just sits on top of it. If that isn't standard protection, then what is?

The EJB tips, tricks, and patterns session was quite nice. I learned a few nuances of the platform. The patterns part was the best. They first went through some of the design patterns from the EJB 2.x days and identified which ones were obsolete and which ones were still useful. They then provided several new design patterns. Unfortunately the slides for this talk were not yet available and I just don't feel like combing through my handwritten notes. Definitely check this one out online when it is posted.

Cameron Purdy's "Top 10" talk was both humorous and thought-provoking. I'll never do justice to it. Check it out when the video comes available.

The final session of the conference for me addressed a burning question I had in my mind since Monday - what in the world is a DSL? I heard it thrown around in the Grails and Ruby talks at Java University, but nobody ever defined the acronym. Domain Specific Language - that what it is! I mainly attended this talk because I thought there might be applications for DSL's in our work at St. Jude. A DSL is a custom language designed for a specific purpose. Ruby's Rake language for instrumenting application builds is an example. Rob Harrop gave an impressive demo of how he built two DSL's, one providing a simpler API for JMX, and another for corporate action entitlement calculations. While I can't think of a direct application for DSL's yet, I'm not tossing out the possibility.

JavaOne was a great conference for me. If I didn't hate to leave my family for this long, I'd love to attend every year. It's definitely drinking from a fire hydrant.

Thursday was slow...

2007-05-11T22:17:00.000-05:00

for me, not for JavaOne. Of course I was a good little programmer and used the schedule builder to sign up for all of my sessions. I edited them a bit after the first two keynotes. Even then, I had one lone session scheduled for Thursday morning (that wasn't really directly applicable to my work, it just looked interesting), and then two sessions in the afternoon, the first starting at 4:10. I decided to skip out on the morning session and do a little shopping at Pier 39. The highlight was a "Bucket of Boat Trash" and clam chowder at the Bubba Gump Shrimp Company. And yes, we Ole Miss Rebels are represented as far out as the end of Pier 39:

The two sessions that I attended were:

- RubyTooling: State of the Art
- Using Ajax with POJC (Plain Old JavaServer Faces Components)

I attended the first session simply to get a little more detail on all of the hype surrounding Ruby tooling support in NetBeans 6. What I got was even more than I bargained for. The project leaders actually walked us through not only the features that were available, but how they were implemented. I had never really thought about the problems with providing code completion and refactoring with a dynamically-typed language. It was really cool to see the thought process that went into their solutions. I'd love to hear a similar discussion from the JetBrains guys, as the Ruby support in IntelliJ IDEA is quite good as well.

For me the second session was the best of the conference for me up until that point, and arguably it still is after attending Friday's sessions. Craig McClanahan, of Struts fame, was the main speaker and was joined by his colleagues Matthew Bohm and Jayashri Visvanathan. What made this session so good for me was that they presented a problem - "How can I add Ajax behaviors to my JavaServer™ Faces technology based application, without throwing away my investment in existing component libraries?" - and then provided three different solutions to that problem - low, medium, and high level.

The low level consisted of simply using the HTML event pass-through attributes that are implemented by most standard JSF components (onClick, onBlur, etc.). One could use an existing JavaScript framework such as Dojo to send an XMLHttpRequest and then map that request to a Servlet or JSF handler using a technology such as Shale Remoting. The response could be sent back as JSON data which could then be transformed into the desired UI update.

The medium level consisted of actually extending existing JSF components and adding the desired Ajax behavior. Due to time constraints they didn't cover this solution in detail, but they did provide a link to a detailed discussion in the Java BluePrints catalog: https://blueprints.dev.java.net/bpcatalog/ee5/ajax/extendingRenderFunctionality.html

The high level solutions addressed the following needs (copied directly from the slides):

● Partial page submit—gather up a particular set of
input element values, and send them to a bit of server
side business logic
● Partial page refresh—the business logic needs to
refresh the content of one or more subtrees of the
client side DOM
● Synchronization—the benefits of synchronizing the
server side state
● Don’t repeat yourself (DRY)—reuse existing
components and renderers for partial page updates

To address these issues, the speakers highlighted two add-on frameworks:

● Ajax4JSF (http://labs.jboss.com/portal/jbossajax4jsf)
● Dynamic Faces (https://jsf-extensions.dev.java.net/)

I was quite impressed with both of these frameworks. One of my colleagues is currently implementing Ajax behavior in a Facelets-based application using Ajax4JSF and he is quite happy with it. Dynamic Faces looked really awesome, especially its tooling support in NetBeans (actually I'm quite impressed with the overall JSF support in NetBeans - I'll definitely be adding it to my tool belt). The highlight of the presentation was Matt's video of him building an entire currency trading application in 28 minutes - except it was "fast-played" to finish in 3 1/2 minutes and set to techno music. Matt wowed us with his dancing abilities while we watched true RAD. The crowd went wild!

Wednesday was AJAX Day

2007-05-10T18:49:00.000-05:00

Not officially, but nearly every session I attended had something to do with AJAX:

- Creating Amazing Web Interfaces with Ajax
- jMaki: Web 2.0 App Building Made Easy
- Fast, Beautiful, Easy: Pick Three - Building Web User Interfaces in the Java Programming Language with Google Web Toolkit
- Killer JavaScript Technology Frameworks for Java Platform Developers: An Exploration of Prototype, Script.aculo.us, and Rico

I have to say that I was rather impressed by what I saw.

The first talk was by Ben and Dion, the Ajaxian guys. It was an appropriate way to start, as they gave a quick history overview of Ajax. One nice point they made was that Ajax really isn't about the acronym - it never was - it's about building killer websites. Who cares what the actual technology behind it is. They discussed a couple of what they seemed to consider the better frameworks available - Dojo and ExtJS. They then explored some amazing up and coming features, including offline support and 2D client side graphics manipulation.

I was rather impressed with jMaki - in short it is a wrapper around many of the popular JavaScript frameworks available (Dojo, Yahoo UI, Script.aculo.us, Spry, Google), and makes them accessible to Java, PHP, and Ruby. It has excellent tool support in NetBeans and Eclipse. It provides protection from changes in the API's of all of these projects - you can mix and match frameworks and only be concerned about one API - jMaki's. It does the work of linking all of the widgets together and communicating amongst them and with the server side.

The GWT talk was easily my favorite of the day. I'm extremely impressed with what these guys have done. I hadn't had much opportunity to look at GWT until now, and I really wish I had. I was initially skeptical about writing an entire application in Java and letting it generate HTML and JavaScript. I guess these guys knew that, because they're development philosophy addresses my concerns quite nicely:

To radically improve the web experience for
users by enabling developers to use existing
Java tools to build no-compromise AJAX for
any modern browser

From what I can see, they deliver on their mission. They've optimized their code for speed and for browser specificity (e.g. from what I understand, if your client is using Firefox, you get Firefox optimized JavaScript, same for IE, etc.). You can use all of your favorite IDE features to build the code, including the debugger. I really want to try to make use of this toolkit in the near future.

The final talk was less informative for me, but only because I had experience with most of the technologies already. The killer part of this was how the speaker extended existing JSF components and added Script.aculo.us effects. It really made his version of Yahoo maps shine.

Ajax isn't going anywhere but up. I just left yet another Ajax/JSF session, which for me was the best session of the conference so far. In a later entry I'll tell you why.

It seems to be the year of the dynamic/scripting language

2007-05-08T17:57:00.000-05:00

It has been a whirlwind of a day. I've been to two keynotes (close to 5 hours of information there) and one technical session. Couple that information with what I heard at Java University yesterday, and you find many common themes. One that keeps coming up is the emerging trend of making other languages, particularly dynamic/scripting languages, first-class citizens on the JVM.

According to Wikipedia, "Dynamic programming language is a term used broadly in computer science to describe a class of high level programming languages that execute at runtime many common behaviors that other languages might perform during compilation, if at all. These behaviors could include extension of the program, by adding new code, or by extending objects and definitions, or by modifying the type system, all during program execution. These behaviors can be emulated in nearly any language of sufficient complexity, but dynamic languages provide direct tools to make use of them." This definition seems to fit quite nicely with what I've heard the last two days. A couple of dynamic languages I've heard A LOT about are Groovy and Ruby.

Yes, Ruby and its most popular framework, Ruby on Rails, have survived the initial hype. They are here to stay. Not only that, they seem poised to make a serious impact on the way we will do web application development over the next several years. Sun made a HUGE splash when they decided to hire the core developers of JRuby, the project which in its current pre-1.0 release already runs 98% of Ruby on Rails as a first-class citizen on the JVM. Not only that, you can now create a WAR file from a Ruby on Rails application and deploy it to any Java application server! I'll write more on this in another entry as I attended a full technical session on it.

If you're too uncomfortable getting away from Java, why not try Groovy? After all, it is a JSR (241). All of Java syntax is legal in Groovy, plus a lot more. Groovy is a dynamic scripting language like Ruby and also compiles to bytecode, making it a first-class citizen on the JVM. It has its own MVC framework, Grails (formerly Groovy on Rails), which is a direct competitor to Ruby on Rails. I've already written on Groovy and Grails in an earlier entry.

I plan to attend some additional sessions focused on these dynamic languages, as it seems they will be really important in the years to come.

Java University: Rapid Web Site Development with Groovy and Grails

2007-05-07T16:47:00.000-05:00

I'm currently sitting in this session - Graeme Rocher is the presenter. He is the creator of Grails, which is Groovy's answer to the Ruby on Rails like development experience. He's currently doing Q&A, so I thought I'd take the opportunity to write a short entry. So far this session is awesome! Graeme is a great presenter and has had the perfect balance of slides and live coding. Unfortunately they ran out of slides before I got to the presentation (more on the sometimes laughable logistics at JavaOne later), so I'm having trouble remember details to write about (they've promised to email me the slides). The first part of the session was an introduction to Groovy, Java's "scripting" language. I had NO IDEA just how cool and powerful Groovy was. I am especially impressed with its MetaClass concept, whereby you can override almost every behavior of the Java language that you can imagine - method calling, operator overloading, etc. Imagine being able to do AOP type things without using AOP. Not only that, it has all of my favorite pet features like "everything is an object," closures, dynamic lists, etc. It's an OOP nuts dream. I'll write more later.

Java University: Developing Enterprise Applications with the Spring Framework

2007-05-07T15:09:00.000-05:00

This was the first session that I attended at Java University. You could take either a full-day course or two half-day courses - I elected to do the latter. Keith Donald, project lead for Spring WebFlow, presented. I have quite a bit of Spring experience already through AppFuse, but I was hoping to get a more complete view of Spring as most of what I have learned is from tinkering with existing systems. Keith promised that we'd build a system from the ground up, so it sounded like I'd get what I bargained for.

And build from the ground up we did. I'd say we were almost halfway through the entire session before we even TOUCHED Spring. Up until that point all we had done was do test driven development on all of the business entities and logic. It was very interesting to me that Keith's coding methodology is quite different from what I typically find myself doing. He implemented almost all of the business logic of the application without any regard to the eventual supporting technologies (i.e. ORM frameworks, web frameworks, etc.). It seems like I almost always bind my application to a set of technologies (say Hibernate/Spring/JSF) before I ever write a line of business logic. What did he get from this? Well, his application had fully implemented and tested business logic that would work with nearly any of the available supporting frameworks. Good stuff.

Another thing that was interesting to me is his disdain for packaging classes according to application layer. I can't think of an application that I've built recently where the DAO's weren't in a dao package, the "Manager's" weren't in a manger/service package, and the web classes weren't in a web package. Keith totally changed all of this. Our two main entities in this application were account and restaurant. Anything that had to do with an account (be it a DAO, service bean, web form, etc.) went in the account package. The same went for the restaurant package. I'm not sure if I like this or not, but he seemed convinced of the value.

Overall it was a good session. He incorporated A LOT of live coding, and almost all of it was done from scracth - he had very little pre-made skeleton code. The drawback to that was that he only made it through 6 of the 8 sections of his slides. I wish he had backed down on one or the other.

Siam Thai Restaurant Doesn't Disappoint

2007-05-05T18:31:00.000-05:00

I ended up at the restaurant across the street from the one pictured in my last entry. I found out from reading the reviews that it was the original, and then opened an additional location across the street. Strange, huh? At any rate, the Chicken Satay was definitely a 5-star dish for me. Even better than Bhan Thai back home in Memphis. I followed that up w/ the Thai Fried Rice w/ Beef. Also awesome. I will probably eat here again during the week.

Greetings from San Francisco!

2007-05-05T16:18:00.000-05:00

This is the view from my quaint little hotel room at the Hotel Nikko in downtown San Francisco, California. I arrived here after a long morning of travel. First ~4 hours of flight from Memphis, TN to San Francisco International, followed by traversing the airport maze to find the BART (Bay Area Rapid Transit) train station. Once I found the right station, it was another 15 minutes of waiting on a train followed by a 40 minute train ride. Almost home? Not quite. As I ride the escalator out of the subway, I realize just what a country boy I am. There are literally hundreds of people crawling around on the streets, and here I am, toting a large rolling suitcase, a laptop, and a backpack, and looking totally clueless! Where is my hotel? I was definitely a prime target for predators just looking to make a quick buck. Within seconds I heard, "Where you looking to go? I've got a map." I quickly responds with "I've got it, thanks." Of course, I didn't have it. But I didn't have 20 bucks for the guy either! Not a few more steps up the sidewalk I'm confronted by Indian monks wanting to share their religion with me. I did have a nice conversation with this guy and got him to take one of my pocket Gospels of John (thank you Pocket Testament League!). Finally a nice family pointed me in the right direction. I figured out that if you look like you're on a mission and you know what you're doing, people don't come up to you, so I put on my best serious face and headed for the Hotel Nikko. Now here I am, and from my window I've got a nice view of the pool area which is surrounded by an interesting looking rock garden:

I also can see what looks like a potentially good Thai restaurant on the corner:

The reviews on Google Maps look promising!

On a final note for this entry, I desperately miss my family. Our goodbye at Memphis International was tear-filled, especially by Wendy. I haven't been this far away from them in a LOOOOONG time. In fact, Abby was only about 10 months old the last time I went on a business trip without them. Isabella and Ali Kate weren't even conceived yet! I managed to get a web camera for the trip, so I'm going to send them a video message every day. Check your email sweetheart! I love you all SO MUCH!

Welcome!

2007-04-30T14:38:00.000-05:00

I plan to start posting here on Saturday, May 5, 2007. Look for photos, videos, and session synopses, as well as miscellaneous banter about JavaOne 2007 in San Francisco, CA!

Matt, RTFM! Commons Collections HAS CLOSURES.

2006-08-17T09:46:00.000-05:00

Thanks to everyone who pointed me to Commons Collections and its Functor package yesterday. To me, this is just one step below having closures natively present in the language. FYI, I was able to remove all duplication from my class and reduce the LOC from 211 to 136 - in other words, 75 lines of useless code GONE.

Here is what I did. First, I defined Predicates for each of my conditions. The simplest ones called a boolean method on the User object:

private final Predicate isX = new Predicate() {
  public boolean evaluate(Object object) {
     return ((User) object).isX();
  }
}

Only slightly more complicated ones checked to see if a given Collection was empty on the User object:

private final Predicate isX = new Predicate() {
  public boolean evaluate(Object object) {
     return CollectionUtils.isNotEmpty(((User) object).getItems());
  }
}

Next, I defined a method that would check the delegations for the User to see if any of them were an X:

boolean checkDelegations(User user, Predicate checkPredicate) {
  return CollectionUtils.exists(user.getDelegations(), checkPredicate);
}

Finally, I implemented the security methods:

public boolean canDoThis() {
  return isX.evaluate(loggedInUser) || checkDelegations(loggedInUser, isX);
}

Maybe it isn’t the most elegant or simplest of solutions, but it sure is a lot better than what I posted yesterday!

P.S. Since this is a Christian blog, I must remind you that RTFM stands for Read The FINE Manual!

Java needs closures

2006-08-16T09:45:00.000-05:00

I’m sure everyone is sick of reading this same rant over and over, but I just had to add more fuel to the fire. I’m attempting to implement access privilege delegation in a JSF application - basically, users can delegate their ability to do “stuff” in our application to other users. I have a backing bean that has several methods that are called by the JSF components, returning whether or not to render that component based on security privileges. Well, I now have to make all of those methods aware of delegation! I have something like this in several methods:

boolean notX = (loggedInUser.isX());
if (notX) {
  boolean result = false;
  Set delegations = loggedInUser.getDelegations();
  for (Iterator i = delegations.iterator(); i.hasNext();) {
     User delegator = (User) i.next();
     if (delegator.isX()) {
        result = true;
        break;
     }
  }
  return result;
} else {
  return true;
}

Now, it would be nice if I could extract the contents of that if block into a new method, say “checkDelegations()”. Unfortunately, the isX() that I need to call is different for every method following this pattern. I’d like to be able to pass a function that calls isX() on the delegator into the checkDelegations() method. No dice in Java. Does anyone else have a solution to this problem?

Raible’s Wiki: AppFuseRoadmap

2006-08-15T09:44:00.000-05:00

Raible updated the AppFuseRoadmap yesterday. I’m really excited about where the project is going. XDoclet has been a good friend, but I’m really happy to see its demise in favor of annotations. JDK 5 and JSP 2.0 will also be really helpful - I’ve wanted to leverage these technologies for a long time, but haven’t had an easy way to do so. I think the most interesting thing for me will be the switch over to Maven 2. I have absolutely ZERO experience with Maven, other that seeing the pretty websites that it generates for many of my favorite open source projects. I consider myself to be something of an Ant wizard, so I hope that I’ll be able to leverage that experience in Maven.

It looks like TestNG replacing JUnit is a nice-to-have for 2.0 - I hope this becomes a configuration option. I don’t know anything about TestNG. Perhaps it’s time to learn.

AppFuse 2.2 is where things are really going to start getting cool. Convention over configuration (ala RoR) will really speed development, and features by plugin will make my life really easier. I spend a lot of time stripping things out that I don’t need for particular projects - the time I save by using AppFuse is worth the pain of stripping them out - so this will be yet another way that AppFuse will make Java EE development a pleasure.

It seems that AppFuse has a competitor!

2006-08-15T09:43:00.000-05:00

I found Project Able while reading Raible’s blog this morning. While it doesn’t claim to duplicate everything that AppFuse does (i.e. they pick a framework and stick with it instead of providing choice), they are doing some neat things. I may take a look at it if I ever have time.

Project Able is a full Java-based web development stack designed to make web development painless. In a sense, it is an attempt to bring together quality opensource tools in one cohesive stack, similar to what Rails has done for Ruby, while also encouraging common practices I’ve used in software engineering for a long time.

It is very similar to projects such as Trails, Grails, and AppFuse. However, there are a few key differences:

The stack components are different (WebWork, Spring, iBatis, etc).
In addition to the basic framework, Able also encourages common development techniques and patterns (more below).

Seven simple reasons to use AppFuse

2006-08-09T09:40:00.000-05:00

I’ve wanted for some time now to write a blog entry promoting my favorite open source project - AppFuse. Since I started developing web applications using AppFuse as a base, I can truly say that I’ve rediscovered the joy of software development. I’ve found no other technology or methodology that has allowed me to place as much focus as I now do on solving business problems and not on technology ramp-up or figuring out the eccentricities of “framework X.” In this article, Matt Raible, the founder of the AppFuse project, humbly states very compelling reasons that you should use AppFuse for your J2EE development. To summarize, here are the 7 reaons:

Testing
Integration
Automation
Security Features and Extensibility
Code Generation with AppGen
Documentation
Community

Read the article to get the meat:

Seven simple reasons to use AppFuse

JFreeChart-AppFuse Integration

2006-07-25T09:38:00.000-05:00

I recently finished integrating JFreeChart with AppFuse for a project I'm working on. JFreeChart is a really powerful Java chart library. If your application has any requirements for charts/graphs, I highly recommend it. The user manual and demo code come with a price tag ($39.95 for a single developer), but they are well worth the purchase - especially the demo code. If you don't have the $$$, the support forum is also very helpful.

I plan to put together a tutorial to help anyone interested in using JFreeChart in their AppFuse application. Look for it here and on the appfuse-user mailing list. It will be based on JSF since that's what I'm using right now.

I Made Raible's Blog

2006-07-25T09:37:00.000-05:00

Apparently Matt Raible thought my JSF modifications to the AppFuse-Compass tutorial were good enough to merit a mention on his blog: AppFuse Videos updated for 1.9.3. Check out the bottom of the entry.

Compass really is a nice tool - I was able to provide search capabilities for an app I'm working on right now with about 2 days worth of work (having never worked w/ Compass before), and man is it fast! I can't get a search to exceed 1.5 seconds!

Stiff asks, Matt answers

2006-07-24T09:34:00.000-05:00

I found an interesting article this morning by way of Digg.com Programming: Stiff asks, great programmers answer. The author posed 5 questions to some of the more well-known programmers of today, and their answers made for very interesting reading. Not to say that I'm a great programmer or anything, but I thought it might be a fun thought exercise to answer these questions myself. Here we go:

How did you learn programming? Were any schools of any use? Or maybe you didn't even bother with attending any schools ?

How did I learn programming? There have been several different stages of my development as a programmer. I started out copying BASIC programs from magazines into my Atari 800 and then modifying them to see what would happen. This progressed through the Commodore 64 and Apple II. In the 8th grade I earned the distinction of “Best Programmer,” not that that means very much - I figured out how to make the U.S. flag program run with only a handful of lines of code using loop and control structures vs. typing out the entire graphics display line by line.

In High School I jumped to the exciting world of Quick Basic. I can't remember the exact name of the course I took, but it was not very far above the level of what I did in Middle School/Junior High, nor was it very far below the level of my intro-level course in College. As I recall, we spent a lot of time hacking the machines to see what we could do with them. Of course you couldn't do anything cool like change your class schedule ala Hackers.

At some point I decided I would major in Computer Science at the University of Mississippi. I really enjoyed my time at Ole Miss, and I learned a lot - unfortunately, I also picked up a lot of bad programming habits. You ask were schools of any use? Definitely - one of my favorite professors secured me an internship at St. Jude, which led to my current and only full-time software development job. It wasn't until I started developing real code for real clients that I got truly serious about programming as a profession. It was then that I learned that hacking out quick and dirty scripts that worked most of the time and would get past a graduate assistant's grading wasn't what programming was all about. I think the turning point of my career was when I attended XP/Agile Universe in 2002. It was here that I really started to grasp agility, test-driven development, refactoring, and simple design - principles and practices that I consider essential to developing software of any magnitude.

What do you think is the most important skill every programmer should possess?

I'll answer this question very much like David Heinemeier Hansson answered the 10-100 times question below. I think the ability to quickly view a problem in the abstract and then mentally apply Occam's razor to it until you have what is needed for implementation is essential to programming. When I'm not managing a project team/schedule - i.e. I'm actually doing software development - I would consider this to be the core of what I do every day.

Do you think mathematics and/or physics are important skills for a programmer? Why?

I can't remember ever using any of the physics I've learned. Take that back, the concept of the electromagnetic field was useful when I was trying to understand Mass Spectrometry, which is at the heart of several of my clients' work. Mathematics, on the other hand, is key. The concepts I learned in my discrete mathematics course seem to lie under the surface of many of the problems that I face. Even if I don't directly apply the mathematics on a day-to-day basis, the “way of thinking” that you develop when studying mathematics really sharpens you as a programmer in my opinion.

What do you think will be the next big thing in computer programming? X-oriented programming, Y language, quantum computers, etc?

Like many of those interviewed, I'm not into fortune telling and/or hype. The next big thing always quickly becomes yesterday's news as we cut through the hype to the core value of what product/technique/practice X offers. We then integrate that core value into our regular day-to-day toolset and then go back to business as usual.

If you had three months to learn one relatively new technology, which one would you choose?

THREE MONTHS?!?!? WOW! Although it isn't that new, it's still fairly new to me. I would spend the next three months learning everything I can about the Spring framework.

What do you think makes some programmers 10 or 100 times more productive than others?

This flies in the face of a lot of the agile methodologies out there, but I think solving as many problems as you can without interrupting any of your other team members will turn you into an uber-productive programmer. I taught myself 90% of what I know through self-study and independent troubleshooting. If every time you have an issue with your work you quickly run to someone on your team that “knows that software/technology/issue better,” you'll never advance past infancy as a programmer. Just like babies have to be spoon-fed, so do infant programmers. You have to learn how to feed yourself. The next time you have a problem in code that you're not familiar with, trace the execution, line-by-line. Understand for yourself how the program works. If you run across a technology or API that you're not familiar with, study the available resources related to it. “Google it” for crying out loud. The more you do this, the better you'll get at it. Soon you'll find yourself asking questions of your team members only about 5% of the time, and you'll become the most productive member of your team. Don't believe me? Give it a try.

What are your favorite tools (operating system, programming/scripting language, text editor, version control system, shell, database engine, other tools you can't live without) and why do you like them more than others?

My current tool set includes IntelliJ IDEA (as well as a smattering of Eclipse when I need it), AppFuse - probably the best thing that has ever happened to J2EE development, Cygwin, Tomcat, and MySQL. If I'm doing anything else in a text editor besides coding, vim is my friend. Wiki-wise we're very invested in Confluence - it rocks as a wiki. Of course I really can't live without Firefox - besides my IDE I probably spend more time there than anywhere else.

What is your favorite book related to computer programming?

I think I have to call a tie here between Agile Software Development, Principles, Patterns, and Practices by Robert C. Martin and Test Driven Development: A Practical Guide by David Astels. Both of these books were instrumental in my development as a more agile developer.

What is your favorite book NOT related to computer programming?

This is an easy one - the Bible. My main translation is the English Standard Version.

If I had to choose a book that wasn't the Bible, it would be The Way of the Master by Ray Comfort. This book literally changed my life.

What are your favorite music bands/performers/composers?

Right now my favorite artists include The David Crowder Band, Casting Crowns, and Todd Agnew.

Abby in Costume

2005-11-16T11:13:00.001-06:00

Abby in Costume
Originally uploaded by javasage1978.

I realized I haven't posted any pictures of the girls - here is Abby before the fall fun festival at Bellevue.

Isabella in Costume

2005-11-16T11:13:00.000-06:00

Isabella in Costume
Originally uploaded by javasage1978.

Here's Isabella right before we went in to the fun festival...isn't she cute?

Flickr

2005-11-16T11:10:00.000-06:00

This is a test post from , a fancy photo sharing thing.

My Spiritual Father Goes Home

2005-11-15T13:05:00.000-06:00

This morning, Dr. Adrian Rogers walked into glory. Dr. Rogers was my first pastor. I never had the opportunity to share this with him, but he is ultimately the man who led me to a saving knowledge of Jesus Christ. I experienced false conversion as a child, was never baptized, and never experienced the true change of heart that comes from the new birth. Shortly after our marriage, my wife and I joined Bellevue Baptist Church, where I was then baptized. I realized that I knew very little about the foundations of my faith, so when I learned that Dr. Rogers taught a course on Wednesday nights called "Back to the Basics: What Every Christian Ought to Know," I quickly signed up. It was the second or third week of the class when Dr. Rogers spoke on the subject, "How to Be Saved and Know It." During this class Dr. Rogers revealed that as a young man he had struggled with doubting his salvation.

Quoting from this message, Adrian Rogers said, "One night I looked up into the heavens and said, 'God, I've got to have assurance. I don't know if I'm lost and the Holy Spirit has me under conviction, or I'm saved and the devil is trying to get me to doubt my salvation. But one thing I know: You said if I would believe on You, You would save me. So, Lord, right now, I trust You to save me.'"

I went home that evening and prayed that very prayer, and the rest is spiritual history. Though I didn't become instantly perfect (and I'm still quite far away from perfection), I finally experienced that change of heart and life that comes from salvation. I've since been baptized again (to get it in the right order), as after the self-examination commanded by 2 Corinthians 13:5 I realized that that night was when I was truly saved. So, to Heaven I send a heartfelt thank you to Dr. Adrian Rogers, and I look forward to seeing him again one day.

Besides him leading me to Christ, if that wasn't enough, I've learned a great deal from Dr. Rogers about what it means to be a man of God and a great husband and father. He's taught me from the pulpit, from books, and from personal example. He truly was, and still is, a good and faithful servant of the Lord Jesus Christ.

For more information about the passing of Dr. Rogers, visit http://www.adrianrogers.org.

Ruby on Rails Dev Framework on Track for Growth

2005-11-02T09:06:00.000-06:00

It appears that Ruby on Rails is changing the WORLD of software development - I wasn't aware of just how much influence it was having in the world of other languages. Here Marc Fleury (JBoss CEO) says that it had a huge influence on Seam - JBoss's venture into the Java web framework space. And then the list of RoR clones: Biscuit (PHP), Grails (Java), Monorail (.NET), Turbo Gears (Python), Cake PHP, Subway (Python), Catalyst (Perl).....All I can say is that the RoR guys must have done something right!

Ruby on Rails Dev Framework on Track for Growth

NBC2 News Online - The mystery of the eye

2005-10-31T10:14:00.000-06:00

This is pretty wild....the number 2 appears in the eye of Hurricane Wilma. They insist that the image and video were not altered....in fact you can barely see it at this NOAA link as well: http://www.srh.noaa.gov/data/radar/archive/Tue/kamx/241002.gif.

NBC2 News Online - The mystery of the eye

IT Observer - A Glimpse at the Future of Programming Languages: O'Reilly Releases "Beyond Java"

2005-10-17T09:31:00.000-05:00

The Ruby on Rails hype continues - Bruce Tate considers the possibility that it may be "the next big thing," as well as letting us know that "It's time to start paying attention again. It's time to look at the horizon, beyond Java." I've been thinking about this issue a lot lately - I mean, even 10 years ago none of us could have predicted that we'd be using Java as much and in the way we are now. It was a C/C++ world. Now we don't know what we'd do without Java - or do we. Scripting languages seem to have the momentum right now - even in the Javaspace (see Groovy). Ruby on Rails, as much as I've seen of it, is EXTREMELY impressive. If we can repeatedly solve the BIG problems in a scalable, maintainable way with these languages, plus we get the added benefits of dynamic typing, etc., why wouldn't we transition? I'm excited to check this book out, and also excited to be in the web development space right now. Who knows - 10 years from now we might be looking at "Beyond Rails."

IT Observer - A Glimpse at the Future of Programming Languages: O'Reilly Releases "Beyond Java"

Spurgeon - Morning and Evening

2005-10-14T16:55:00.000-05:00

Spurgeon's evening devotional for today packs a punch. I can't get over the last few sentences:

O professor, too little separated from sinners, you know not what you lose by your conformity to the world. It cuts the tendons of your strength, and makes you creep where you ought to run. Then, for your own comfort's sake, and for the sake of your growth in grace, if you be a Christian, be a Christian, and be a marked and distinct one.

Read Spurgeon's Evening for Oct 14.

FOXNews.com - The O'Reilly Factor - Talking Points - The ACLU Exposed

2005-10-14T16:34:00.000-05:00

Bill O'Reilly slams the ACLU for being what it is - not a defender of Constitutional rights, but a militant organization fighting for its own radical, secular, progressive agenda. BO states:

"The ACLU simply wants a different country, a nation where conduct it approves of, public sexual displays, child molestation literature is allowed. But the ACLU wants to inhibit conduct it disagrees with, like protesting the border and celebrating the birth of Jesus. That's what's going on."

Read more at FOXNews.com - The O'Reilly Factor - Talking Points - The ACLU Exposed.

ONLamp.com: What Is Ruby on Rails

2005-10-14T09:43:00.000-05:00

What Is Ruby on Rails by Curt Hibbs -- Ruby on Rails is an impressive web development framework that will soon reach version 1.0. While there's a lot of buzz, it can sometimes be difficult to discern the steak beneath the sizzle. Curt Hibbs walks through the features and pieces of Ruby on Rails to show how it fits together and where its big benefits come from.

I read this article this morning and I have to say it makes me even more impressed with Rails. I think it has the potential to be a BIG player in the web application development space - if not to replace Java, PHP, etc., with Ruby as many developers' platform of choice, it will definitely challenge the existing framework developers for Java, etc., to scale even bigger heights when it comes to features and ease of development.

Apache iBATIS

2005-10-12T10:04:00.000-05:00

One technology that I picked up on in the last session of the Java In Action conference was Apache iBATIS. It is a really cool framework that maps SQL queries to Java objects. It provides the capability to do really AWESOME things with dynamic SQL, and eliminates the N+1 query problem. I've been playing with it on a project the last couple of days and I'm VERY satisfied with what I've seen so far. It has the potential to really help us out in some application hot spots and places w/ a great deal of dynamic SQL. You should definitely take a peek.

Supernatural Regeneration

2005-10-12T09:51:00.000-05:00

I am about halfway through reading an interview with Ravi Zacharias in the Fall 2005 issue of Just Thinking from Ravi Zacharias International Ministries. The interview was conducted by Major John Carter of the Salvation Army, and concerned Leadership and Calling. I was extremely taken by a quote by RZ in the interview which I'll reproduce below:

I really think that today, as Christian apologists, that the biggest challenge to the faith is not an intellectual question. In fact, I have not heard an intellectual question to the faith that has disturbed me. I am more convinced than ever of the message of the Gospel. But the biggest challenge to the Christian faith is this: If the message that we have lays claim to a supernatural regeneration, then why is it that we do not see that regeneration more often? No other religion claims a supernatural regeneration. They may claim ethics and morality. Hinduism does. But we are the only ones who claim a new birth. Born of the Holy Spirit, our hungers have changed, our disciplines have changed, our behavior has changed. If it is a supernaturally engendered thing, why do we not see it more often? And if that is true of the common person in conversion, how much more true it must be of ones in leadership. So I believe character is essential, and without that, you cannot serve.

To me this really gets to the heart of the matter - how can I or anyone else claim that Jesus Christ has made a difference in my life, that I have been supernaturally changed, if I continue to go on living as I did before I was "converted?" And what's more, how can I position myself as a teacher of God's Word if I don't do the things that Christ has taught us to do - I'm expecting my students to do them, why don't I? It's a matter of being a doer of the Word and not a hearer only. As Christians we all need to check ourselves - are we truly in the faith? And if so, are we daily placing ourselves on the altar of living sacrifice, daily making the decision to leave our desires behind and follow the will of Christ? I'm so thankful for RZ's statement, as it really touched me at a point at which I needed to be touched.

Ruby on Rails

2005-10-10T15:38:00.000-05:00

I've spent quite a bit of time playing with this Ruby on Rails thing. It's amazing that I was able to build such a nice basic CRUD app w/ only 57 lines of code. Now, I know this app didn't do much - just manage an Online Cookbook (i.e. the OnLAMP.com Rolling on Rails tutorial). I'm going to go through "Four Days on Rails" next since it purports to be a tutorial with a "Real App." I'm excited about maybe using Ruby for rapid prototyping for our enterprise-class Java apps...maybe even for production apps. Who knows...Ruby may replace Java? :-)

Post #1

2005-10-10T11:37:00.000-05:00

This is my first post to this blog. I've just returned to work after spending the last week at TheServerSide.com's Java in Action conference in Orlando, FL. Got to take the family with me and spend a day at Magic Kingdom. A good trip, and learned a lot of new technologies.