Clamberry Blog

Several years ago, I was working on an internal application called Tracking. Between releases, we were given an “innovation week” during which we could explore new technical ideas. A consultant was brought in to help us explore Grails as a new technology platform for the application. I wrote this ode to the effort.

(Composed, 2012, inspired by the opening verses of Genesis)

And in 5 days, the Tracking team recreated itself in Grails’ image
In the beginning of our innovation week, when there was just the darkness of the
existing Tracking application and the promise of a new approach called Grails…

On the first day
There was nothing and we said, “Let us recreate Tracking in Grails’ Form”
And we said, “Grails create-app, create-domain …”
And it was so.
And we said, “Now use a real database”
And we created objects, persisted them and said “It is good”

On the second day
We said “It is not good to have our objects live in isolation.
Let us integrate them with the database such that all of Tracking can see them
And their data should be seen by us.”
And just as we said it, it was so.
But not only our data should be shared but even our new application should appear
side by side with the old.
And so we added a new tab with Nexus, linked it to our Tracking app and so it appeared.
And we looked at each other and said, “It is good”

On the third day
We noted that our application, though it live within Tracking, may still be seen by others.
And that it is not how it should be.
So we added a security filter that allowed the Tracking login to be recognized and verified
within our new tab’s code so that strangers may not enter.
And so, seemless but also correct, integration was truly achieved.
But that is not enough.
For then we said “Let us not have just our own objects but let our creation
create for our objects, new properties.”
And so, we integrated OCF, so that new properties can be added and,
even as they are added, so are they available.
And we looked around and said, “It is good”

On the fourth day
We noted that the database contained no audit attributes but did not want
our code to be bothered with it.
So we modified our filter and added a hibernate AuditEventListener so that, via aspects,
all database updates would be given audit attributes, though they not know it.
And we said “It is not enough that our code appear to function correctly.
Let us add testing so that though the code may appear correct so may it be verified.”
And so we added unit and integration tests.
And we said, “Yes, that is good”

On the fifth day
We asked “Though it may be good, the task is not yet complete.
What will we need and how long will it take to complete our creation?”
And though the answer be not yet truly known, we rested.

And the voices in our heads smiled.