Jeffs Groovy Web Log

Today's Loss

2011-08-18T21:33:00.003-05:00

I have all but abandoned this blog. I think it has been over a year since I posted anything here. At this point, writing here reminds me of Forest Whitaker's character in the movie Phenomenon telling his story over a radio that he knows no one is listening to. That is fine.

My parents divorced when I was 10 years old. My Mother was put in a position where she had to take action. She put myself and my 2 sisters in the car and drove across the country to St. Louis where she had grown up and where her family lived. We had made the trip before for summer vacations but this time it was for good. I can only imagine how terrifying this must have been for her. Imagine a 10 year old car, kids 10, 12 and 13, some clothes and nothing else, nothing. I expect many people couldn't do it.

We got to St. Louis where there was lots of family support. My Mother had 2 brothers and a sister all in St. Louis along with her parents. Her sister Brenda took us into her house. She had a great place in a great neighborhood in the suburbs. Brenda was a single Mom with 3 kids of her own but her home was ours. I was young enough that I would not have been involved in financial discussions but I am sure this was a hardship for her take on 4 more people. My Mother had been a housewife and I think she left our home in Virginia with no money. If she had any money, I don't think it could have been very much. 3 kids, no money, no career.

During those first few months when we lived at Aunt Brenda's house, it really was a pretty good time for me. I spent time with my cousins. We had a great place to live. We did a lot of fun things on the weekends. It was tough working out the deal with my Dad no longer being with us but the day to day was good and the reason it was good is that Brenda took us in and made sure we had everything we needed. My grandparents, Uncles and Aunt were all there to provide support in lots of ways but it was Aunt Brenda's house we lived in and she bore a lot of the burden. I doubt she ever gave it a thought.

Aside from my Mother, it may be that Brenda is most responsible for our survival during that time, that of myself my Mother and my sisters. When I think about the time immediately following my parents' divorce, I think about the time I spent living in her house. We weren't living in a crappy motel or worse. Because of her we lived in a fantastic place and had everything we needed.

Today, Brenda's battle with cancer has come to a crushing end. I am crushed. I am crushed as I think about my cousins, her kids who are without her. I am crushed as I think about my Mother who just 2 months ago lost her Mother and now her sister.

Brenda was a tiny woman but a feisty take charge kind of woman. She didn't take any shit from anyone and if I worded it any other way, she might have taken offense.

I thank Brenda for everything she did for us. If I was a poet I would write a tribute to her. If I could paint I would paint a tribute to her. As it is, I will be thinking about her and the rest of the family and will do my best to be inspired by what she did for me and my family.

Switching Versions Of Grails (and other tools)

2010-04-23T11:20:00.004-05:00

I have a little trick that I have used for many years to switch back and forth between versions of development tools. For example, because of the work that I do day to day I often need to switch back and forth between different versions of Grails. Occasionally I will execute this trick while sitting with another developer or during a live coding presentation at a conference without even thinking about it. Often someone will notice and and stop me to ask "what was that?".

I have a directory below my HOME directory called Tools. This Tools directory is where I install development tools like Groovy, Grails, Gradle, Ant etc. For some of those tools, I may want to have numerous versions of the tool available. For example, I have the following subdirectories below Tools...


grails-1.0.5
grails-1.1.1
grails-1.1.2
grails-1.2-M4
grails-1.2.0
grails-1.2.0.RC1
grails-1.2.0.RC2
grails-1.2.1
grails-1.2.2
grails-1.3.0.RC1
grails-1.3.0.RC2

One thing I might do when I need to use a specific version of Grails is something like this...


export GRAILS_HOME=~/Tools/grails-1.2.2
export PATH=$GRAILS_HOME/bin:$PATH

One limitation of that approach is it is a lot of tedious typing. Another is that the change would only apply to the shell where that was executed. Normally if I am working with a particular version of Grails, I want that version to be in play in all open shells.

Instead of pointing GRAILS_HOME at a particular version of Grails, I create a symlink at ~/Tools/grails and that link points to one of the specific Grails version directories. GRAILS_HOME points to that symlink. If I am currently using Grails 1.2.2 and I want to switch to 1.3.0.RC2, I just move the symlink and leave GRAILS_HOME and PATH alone.

Moving the symlink is easy enough but I simplify it further by defining aliases in my ~/.profile. Those look something like this...


alias gr105='rm ~/Tools/grails && ln -s ~/Tools/grails-1.0.5 ~/Tools/grails'
alias gr111='rm ~/Tools/grails && ln -s ~/Tools/grails-1.1.1 ~/Tools/grails'
alias gr112='rm ~/Tools/grails && ln -s ~/Tools/grails-1.1.2 ~/Tools/grails'
alias gr12='rm ~/Tools/grails && ln -s ~/Tools/grails-1.2.0 ~/Tools/grails'
alias gr121='rm ~/Tools/grails && ln -s ~/Tools/grails-1.2.1 ~/Tools/grails'
alias gr122='rm ~/Tools/grails && ln -s ~/Tools/grails-1.2.2 ~/Tools/grails'
alias gr130rc1='rm ~/Tools/grails && ln -s ~/Tools/grails-1.3.0.RC1 ~/Tools/grails'
alias gr130rc2='rm ~/Tools/grails && ln -s ~/Tools/grails-1.3.0.RC2 ~/Tools/grails'
# use my local development copy of Grails
alias grdev='rm ~/Tools/grails && ln -s /Users/jeff/Projects/grails/core ~/Tools/grails'

Now if I want to use Grails 1.2.2 I just open a shell and type "gr122".

I use the exact same approach for other tools that I may want to easily move from version to version.

I do all of this on OS X. The same trick should work on Linux. I don't know enough about cygwin to know if this can work on Windows or not. I expect that it probably would.

That is all I have. It isn't any big deal but is one of those little things that over the years numerous folks have asked me about and then expressed that they liked it well enough that they were going to do the same.

Enjoy!

Grails, SpringSource And Clojure

2009-07-30T16:26:00.008-05:00

I recently developed a Grails plugin which provides support for easily accessing Clojure code in a Grails app. The details of how the plugin works are covered at http://grails.org/plugin/clojure. That page includes a link to a brief video demonstration which is available at http://s3.amazonaws.com/jeffscreencasts/grails_clojure_demo.mov. Check it out.

Shortly after publishing the plugin I posted something about it on Twitter. Not too long after that a couple of other SpringSource folks tweeted about Clojure (here and here). I got a couple of questions (in jest I am sure) about SpringSource and Clojure. "Is SpringSource Moving To Clojure?". Of course not. SpringSource is not moving to Clojure. SpringSource is all about helping folks build serious applications for the JVM and most of that is done in Java. This is not news. I work on Groovy and Grails. Much of what I do is in Groovy. This too is not news. Making it easy for folks to use languages like Scala and Clojure while taking advantage of all the great stuff that Grails has to offer, that is appealing to me and that is why I developed the Clojure plugin.

Clojure is a really interesting language. There are others. The fact that 3 folks from SpringSource have expressed some kind of interest in Clojure shouldn't be all that surprising. There are probably even more folks at SpringSource who have some kind of interest in Clojure but for entertainment, lets focus on the 3 mentioned...

I am honestly not sure how many technologists work for SpringSource but for the sake of having a number to work with, lets say there are 50. Lets also say that Clojure is interesting enough that 15% of JVM developers are interested in learning more about it. I can't back that number up with any research, lets just go with it. If 15% of JVM developers are interested in the language and you take a random group of 50 JVM developers (the 50 in question are certainly not 50 random developers, these are the edge cutters which probably makes them more likely to be interested in keeping an eye on what is new, but work with the idea that they are random)... Do the math. No, really... Do the math. Do the math to figure out the likelihood that 3 of the 50 would be interested in Clojure. I challenge you to do the math in Clojure and post your solution in a comment here. Do it in Scala, Do it in Groovy. Pick a JVM language and do the math.

The simplest solution is probably not very interesting. Prefer a solution that shows off something interesting in your language of choice.

Hmmm... are you more likely to need to refer to the Clojure book, or the high school math book? ;)

Now, you have one more reason to tinker with a new language.

Enjoy.

Grails 1.1 beta3 Is Out!

2009-01-29T19:26:00.002-06:00

We are closing in on the much anticipated release of Grails 1.1. Today beta 3 was released. See the release notes.

A new feature that has not been documented yet involves new validation capabilities. Up to this point, domain classes and command objects within a Grails app have supported really powerful validation capabilities. See section 7 in The User Guide for info on how that works. What is new is now you can apply those same validation capabilities to any class within a Grails app, not just domain classes and command objects. Making a class validateable involves defining a static property called "constraints" and assigning a closure, just like you would in a domain class or a command object.

Second, you have to tell Grails about your validateable class. You have 2 options for doing that. One option is to mark you class with the org.codehaus.groovy.grails.validation.Validateable annotation. Another option is to define your validateable classes in grails-app/conf/Config.groovy by assigning a value to the grails.validateable.classes property. That would look something like this...


grails.validateable.classes = [ com.mycompany.dto.SomeClass, com.mycompany.SomeOtherClass]

An annotated class might look something like this...


// src/groovy/com/companyname/SomeClass.groovy
package com.companyname

import org.codehaus.groovy.grails.validation.Validateable

@Validateable
class SomeClass {
    Integer age
    String name

    static constraints = {
        age range: 16..66
        name blank: false, size: 5..35
    }
}

Note that if you are using the annotation based approach, Grails will search all classes in the app to find all of the @Validateables. While that isn't really a performance problem, you can tune that a bit by specifying some specific packages that Grails should search. To do that, assign a value to grails.validateable.packages in grails-app/conf/Config.groovy like this...


grails.validateable.packages = ['com.companyname.dto', 'com.companyname.someotherpackage']

If the grails.validateable.packages property has a value then Grails will only look in those packages (and packages below those packages) for classes marked with @Validateable.

While this is still beta software, I think the feature will end up being delivered in the final release pretty much like it is described above. If you have any input on that or any other features in Grails. We would love to hear from you. Bring it to the mailing list or file a JIRA issue.

Enjoy!

Getting Groovy With "with"

2008-11-13T21:39:00.006-06:00

UPDATE 12/15/2008: I committed a change yesterday that changes the behavior of the .with method to use DELEGATE_FIRST as the resolveStrategy instead of OWNER_FIRST. If you are not sure what that means, you should by the end of this post.

Strange enough title.

Let's start with a hypothetical conversation between a geeky developer and his much less geeky wife:


Jeff: Betsy, how are you?

Betsy: I am fine thanks.  How are you?

Jeff: Betsy, I am fine thank you.

Betsy: Great.

Jeff: Betsy, you know my birthday is the day after tomorrow right?

Betsy: Yes, I haven't forgotten.  You mention it about 9 times a day you know.

Jeff: Betsy, yes I know.  Are we going to have an ice cream cake?

Betsy: Yes, I think that would be good.

Jeff: Betsy, are you going to buy me the new Opeth DVD?

Betsy: I will get it for you but that music sucks big time.

Jeff: Betsy, that is awesome.  Thank you.

Betsy: Why do you keep saying "Betsy" at the beginning of every sentence?

Jeff: Betsy, I guess I am used to inflexible languages which aren't very expressive.

Um, what does any of that have to do with Groovy? Well, lets talk about the problem with this conversation (aside from the lady's lack of appreciation for Swedish heavy metal). What is wrong is Jeff begins each sentence with "Betsy". Why might he do that? One reason is so Betsy knows that he is talking to her. Clearly this isn't necessary. It isn't necessary because she already knows he is talking to her. A context has been established which makes the addressing unnecessary. Jeff began the conversation by addressing Betsy, they probably made eye contact and were in close proximity. Once the conversation started, there isn't much question about who each sentence is being directed to.

Again, what does any of that have to do with Groovy? Lets press on...

Consider the following Java code which prints out a specific date.


// PrintIndependenceDay.java

import java.util.Calendar;
import java.util.Date;

public class PrintIndependenceDay {

  public static void main(String[] args) {
    Calendar calendar = Calendar.getInstance();
    calendar.clear();
    calendar.set(Calendar.MONTH, Calendar.JULY);
    calendar.set(Calendar.DATE, 4);
    calendar.set(Calendar.YEAR, 1776);
    Date time = calendar.getTime();
    System.out.println(time);
  }
}

Groovy developers can look at that and find quite a bit of noise that doesn't really have anything to do with what the code is trying to do but I want to focus on one specific thing. That one thing is all of the interaction with the calendar variable. Notice that we call clear() on the calendar, then call set() several times and later call getTime() on that same variable. All of those calls are prefixed with "calendar." so the compiler knows what we want to do. If we called "clear()" instead of "calendar.clear()", what would that mean? Are we calling the clear() method in this class? If that was our intent, it would not work because there is no clear() method. We have to prefix the call with an object reference so the compiler knows where to send the request. That seems to make sense. However, if we are going to do a bunch of things "with" the same object, wouldn't it be kind of nice if we could somehow do all of those things without all the repetition. Specifically, it might be nice if we could get rid of all of those "calendar." prefixes.

On to Groovy...

The following Groovy code does the same thing that the Java code above does.


// PrintIndependenceDay.groovy

def calendar = Calendar.instance
calendar.with {
  clear()
  set MONTH, JULY
  set DATE, 4
  set YEAR, 1776
  println time
}

Wow. That is a good bit cleaner than what we started with. Part of the reason for that is we were able to get rid of all of those "calendar." prefixes. What allowed us to do that is calling the "with" method on the calendar object and passing a closure as an argument. What we have done there is establish a context that says "do all of this stuff with this calendar object". When the closure executes, the calendar is given an opportunity to respond to method calls like clear() and set() and the implicit call to getTime() when referring to the "time" property which is being passed to println. Likewise, the references to MONTH, JULY, DATE and YEAR properties are also being handled by the calendar object.

That is pretty slick. Lets dig just a little deeper to get a little better understanding of what is really going on.

Groovy closures have a delegate associated with them. The delegate is given an opportunity to respond to method calls which happen inside of the closure. Here is a simple example:


// define a closure
def myClosure = {
  // call a method that does not exist
  append 'Jeff'
  append ' was here.'
}

// assign a delegate to the closure
def sb = new StringBuffer()
myClosure.delegate = sb

// execute the closure
myClosure()

assert 'Jeff was here.' == sb.toString()

When the closure is executed, those calls to append() in the closure end up being sent to the delegate, the StringBuffer in this case.

Something similar is happening in the Groovy calendar code above. A closure is being passed to the with() method. That closure is calling methods like set() and getTime() which don't really exist in that context. The reason those calls don't fail is the with() method is assigning a delegate to the closure before it is executed. The delegate being assigned is the object that the with() method was invoked on. In the calendar example, the delegate is the calendar object. Something like this is happening...


def closure = {
  clear()
  set MONTH, JULY
  set DATE, 4
  set YEAR, 1776
  println time
}
def calendar = Calendar.instance
closure.delegate = calendar
closure()

This code does the same thing as the first Groovy example. Obviously the first one is cleaner.

I sort of lied a bit, or at least left out a detail that may be significant. The closure that is being passed to the with() method is really being cloned and it is the clone that is assigned the delegate and executed. This is a safer approach than monkeying with the original closure. If the reasons for that aren't clear, the explanation is another story.

Another bit of info that is missing here is the strategy that a closure uses to decide when to send method calls to the delegate. Each Groovy closure has a resolveStrategy associated with it. This property determines how/if the delegate comes in to play. The 4 possible values for the resolveStrategy are OWNER_FIRST, DELEGATE_FIRST, OWNER_ONLY and DELEGATE_ONLY (all constants defined in groovy.lang.Closure). The default is OWNER_FIRST. Consider the owner to be the "this" wherever the closure is defined. Here is a simple example...


class ResolutionTest {
    
    def append(arg) {
        println "you called the append method and passed ${arg}"
    }
    
    def doIt() {
        def closure = {
            append 'Jeff was here.'
        }
        
        def buffer = new StringBuffer()
        
        closure.delegate = buffer
        
        // the append method in this ResolutionTest
        // will be called because resolveStrategy is
        // OWNER_FIRST (the default)
        closure()
        
        // give the delegate first crack at method
        // calls made inside the closure
        closure.resolveStrategy = Closure.DELEGATE_FIRST
        
        // the append method on buffer will
        // be called because the delegate gets
        // first crack at the call to append()
        closure()
    }
    
    static void main(String[] a) {
        new ResolutionTest().doIt()
    }
}

So you see how the with() method helps establish a context where a bunch of things may happen "with" a specific object without having to refer to that object over and over. This can help clean up code like the Java code we started with. This approach can also be really useful when building a domain specific language in Groovy, a topic for another time.

Enjoy! :)

Grails Training In Chicago

2008-08-04T11:39:00.001-05:00

We are really excited to have a 3 day Groovy/Grails training event coming up in Chicago later this month. The training dates are August 26-28. The training will be held at the Hotel Indigo in Palatine.

This is 3 days of lecture and reinforcing lab work. Attendees should expect to write a lot of Groovy and Grails code with your training expert. There is no better way to quickly get your team up to speed on the technology, well beyond the basics.

As with all G2One training events, students will receive a free 12 month license to use IntelliJ IDEA. The IntelliJ guys have done a fantastic job of building first class Groovy and Grails support for the IDE.

For a full course outline and more information, please visit http://g2one.com/training/. Any questions may be directed to training@g2one.com.

G2One QuickCast Site Launched!

2008-07-30T09:56:00.002-05:00

G2One have launched the G2One QuickCast site. A G2One QuickCast is fast and furious little movie demonstrating something interesting about the Groovy language and/or the Grails framework.

The first movie available there demonstrates how powerful tools like Grails and Git can work together to support a really really agile development process. Watch this movie and try to do something like this with your web framework and your VCS. If you can't, your tools are not flexible enough. :)

Enjoy!

G2One Groovy Grails Training In North America

2008-07-14T08:04:00.002-05:00

G2One have announced our Groovy/Grails North American public training schedule for the rest of the year. The schedule is available at http://www.g2one.com/training/.

Our training events are a fantastic experience. G2One are the folks who lead and sustain the development of both Groovy and Grails. No one understands the technology better than the people who build it. G2One training events give developers an opportunity to spend several days with a technology expert covering everything from fundamentals to advanced language and framework features. The sessions include a perfect mix of lecture and reinforcing lab work. That hands on approach is a great way for developers to internalize the details. There is no better way to quickly get a team up and running with the technology.

Grails Plugin For Hudson

2008-06-19T21:32:00.006-05:00

I am pleased to announce that we have worked up a Grails plugin for Hudson. Hudson is a really slick continuous integration server. Check out their site for more info on the engine itself.

It has always been possible to build Grails apps from Hudson but in the past this has involved writing shell scripts that are triggered by Hudson. This works but is not the slickest solution. What you really want is for the CI server to have knowledge of the fact that the project you are building is a Grails app and that knowledge will allow the tool to be more efficient about carrying out the build and also allow the CI server to provide Grails specific options for the build. This is where the new Grails plugin is heading.

Right now the plugin is very basic. In the system configuration screen you may configure as many Grails installations as you like. This is useful for situations where the same CI server may be building multiple projects with different version of Grails or maybe even building multiple copies of the same project with multiple versions of Grails. Below is a screenshot of the system configuration screen:

Notice that there is built in validation to make sure you have entered a valid path to your Grails installation.

When configuring a project in Hudson you have a lot of options for what should happen at build time. The Grails plugin adds a "Build With Grails" option and if that option is selected you can select from a list of common build targets to execute as well as type in any arbitrary targets you may want to execute. This is useful for executing Grails commands that are not in the list of checkboxes and for executing your own custom Grail scripts that may be part of your project. Below is a screenshot of the project configuration screen:

The first version of the plugin has not been released yet but will be soon. In the meantime, I would be happy to hear what kinds of capabilities you would like to see the plugin provide. Even in its current very basic state, the plugin is very useful as it makes configuring a Grails project in Hudson drop dead simple.

St. Louis Dynamic Language Interest Group

2008-06-07T10:01:00.002-05:00

I have created the St. Louis Dynamic Language Interest Group at LinkedIn. If you have a special interest in dynamic languages and are in the St. Louis area or are close enough to the St. Louis area that you would like to be involved with the group, please take a minute to visit the group at LinkedIn and join us.

More information is coming regarding the goals of the group and what sorts of activities we may engage in. I want to give the group some time to populate before moving forward with those details.

If you have any questions about the group in the meantime, please don't hesitate to let me know.

Jeff Brown
Director - North American Operations
http://www.g2one.com/

New Grails Mail Plugin

2008-06-04T13:34:00.002-05:00

The new Grails Mail Plugin is really slick stuff. Very little effort has gone in to the thing so far and there is more to come but even in its current state this is really nice. More details are available at http://grails.org/Mail+Plugin but basically you get a method called 'sendMail' added to your controllers (or you could use an autowired mailService) that accepts a closure and the contents of the closure express the details of the message being sent. A simple example looks like this...


sendMail {     
  to 'fred@g2one.com'
  subject 'Hello Fred'   
  body 'How are you?' 
}

Take a look at the docs for more information. This is good stuff already. I think the simplicity of sending a message like this is pretty impressive but more impressive is how easy it is to build support for something like that in a dynamic language like Groovy. More and more folks are taking advantage of the Grails Plugin System to easily add capabilities like this to their web apps.

Enjoy!

Groovy Grails Training From G2One and Callista Enterprise

2008-05-21T14:26:00.002-05:00

G2One, Inc. and Callista Enterprise AB have announced a partnership to support Advanced Groovy and Grails training in Scandinavia.

Göteborg 2008-09-08
Stockholm 2008-09-15
Malmö 2008-09-22

The 3 day comprehensive course covers details from intro to advanced for both the Groovy language and the Grails framework. The course description may be found here.

As with all G2One training events, students will receive a free 12 month license for IntelliJ IDEA. IDEA's JetGroovy brings fantastic support for both Groovy and Grails to the IDE.

Please contact us at training at g2one dot com with any training related inquiries.

North American dates coming soon...

Pre JavaOne Groovy/Grails Meetup Next Monday

2008-04-30T20:20:00.002-05:00

We have been busy preparing for JavaOne and it is finally almost here. Yay!

We hope to see you at the G2One / NFJS Meetup Monday night. Click the link for all of the details and be sure to click the "register" link. Registration is free and the event promises to be a load of fun. Come hear the latest Groovy and Grails news from G2One, the latest word from the respected NFJS tour and finally a great expert panel discussion. Author signed copies of Scott Davis' Groovy Recipes book and Venkat Subramaniam's Programming Groovy book will be raffled off.

Don't miss it.

Between now and then, I hope to see some of you in Denver this weekend. :)

Another Big Week For Groovy And Grails

2008-02-18T09:45:00.002-06:00

This is definitely going to be another big week for Groovy and Grails. The Grails 1.0.1 point release was published today. This release contains over 40 enhancements over the 1.0 release from just a couple of weeks ago. The Grails community has been buzzing at full steam since the 1.0 release. This is fantastic stuff!

This Wednesday I am heading to the great New York City to speak at their JUG about Groovy. That is going to be a lot of fun. Immediately after that is the event that so many people (including myself) have been looking forward to for a long time. That of course is The Groovy Grails Experience in Reston Virginia, starting on Thursday Feb. 21 and running through Saturday the 23rd. It will be a while before this many of the key players in the Groovy/Grails community get together in one spot to talk shop. I can't wait!

Jeff Brown Interview At Groovy Zone

2008-02-09T14:54:00.001-06:00

I had the great pleasure of doing an interview recently with Steven Devijver for The Groovy Zone. Today, that interview was published. Check it out at http://groovy.dzone.com/news/jeff-brown-grails-10-and-beyon. In the interview we discussed the Grails 1.0 release, the great plugin story that Grails has to offer, the upcoming Groovy Grails Experience and more. I want to thank Steven for the opportunity.

The Groovy And Grails Communities Continue To Buzz

2008-02-07T11:05:00.001-06:00

A lot of things are going on right now in the Groovy and Grails communities. I have been really busy myself and have a lot of exciting things coming up. I am very excited about my role as Director of North American Operations with G2One and that is really keeping me busy.

I spent the first part of this week out in Silicon Valley with Graeme Rocher and Peter Ledbrook working on some really exciting Grails stuff. It was great to be out there with Graeme on the day that Grails 1.0 was released. The whole development team and user community have done an incredible amount of work on Grails to get to this point but I think Graeme himself deserves the props. Graeme conceived the thing and has been driving it very hard from the beginning with the focus and vision necessary to get the framework to this point. Well done Graeme!

Later this month I am going to have the pleasure of speaking at The New York Java SIG about Groovy. I speak at JUGs all the time but this one in particular I am looking forward to. A few months ago I was on the schedule to speak out there and due to an incredible string of bad luck, I wasn't able to make it. My flight was cancelled. My replacement flight was delayed. Once my delayed flight took off we ended up circling in the air for a long time waiting for some weather to settle down. Once I got to New York we found it near impossible to get in to Manhattan because it just happened this was the day of the huge water main explosion. I ended up spending the entire day on airplanes and in terminals just so I could get to my hotel, sleep and then fly home the next day. This time, things will no doubt go much more smoothly. I can't wait to get out there.

When I leave the New York Java SIG I will be heading straight to the airport to get to the event that I am even more excited about. That is The Groovy Grails Experience in Reston VA beginning on Feb. 21. The event is being put on by the same folks who have been putting on the hugely successful No Fluff Just Stuff symposiums for years now so I know it is going to be a great event. This is 3 days packed with talks all about Groovy and Grails. Of all the shows I do this year, this is probably going to end up being the one that is most exciting for me personally. All of my friends from the Groovy and Grails communities are going to be there and I know everyone is going to have a great time. This is the biggest Groovy/Grails event ever to be put together. It isn't often that we get an opportunity like this to get together so many players in the Groovy/Grails communities to talk about the technology. For folks who are interested in the power of Groovy and Grails and the vast possibilities that dynamic languages bring to the JVM, I can't think of a better way to spend 3 days. I am completely pumped about this event.

The Groovy Grails Experience

2007-12-12T19:35:00.000-06:00

The first major Groovy / Grails conference in North America is just around the corner. The Groovy Grails Experience is going to be in Reston Virginia on Feb 21-23, 2008. The event is bringing key players in the Groovy and Grails community together from all over the globe to put on what is sure to be a really exciting event.

Check out the speaker list. Graeme Rocher! Jason Rudolph! Dierk Koenig! Scott Davis! Andy Glover! Venkat Subranamium! Neal Ford! Brian Sletten! The list goes on and on... This really promises to be a fantastic event. I am really looking forward to it.

The event is coming along at a great time. Groovy is finishing up a really really exciting year that started with the release of 1.0 and ran right up to the release of 1.5 last week. We have seen a bunch of new public facing Grails sites go live this year as well as lots of internal application development being done with Grails. Grails is closing in on the very much anticipated 1.0 release.

Good times continue!

Grails 1.0 RC1 Has Been Released

2007-10-16T08:49:00.000-05:00

Grails 1.0 RC1 has been released! See the release notes for details about many of the new features.

This is fantastic news for the Groovy and Grails community.

In a few hours I am getting on a plane to London to speak at The Grails eXchange. I am really looking forward to finally meeting in person some of the folks I have been working with for so long now.

Maverick On Rails

2007-09-09T16:06:00.000-05:00

Mark Cuban says...

"I'm such an exciting guy, I downloaded Ruby on Rails and read the documentation as well. That's what Saturday Nights are for."

Maybe Mark will come out to the upcoming NFJS show in Dallas and learn about Grails. :)

Interesting Groovy Loops Detail

2007-08-07T21:15:00.000-05:00

While fixing a bug in Grails last night I came across something that I found interesting. At first I was really puzzled but now that I know what is going on, it all makes perfect sense.

A unit test that had been passing for some time just started failing. I isolated a specific revision of a specific file that seemed to be causing the test to fail. The test passes with version X of the file and the test fails with version X+1 of that file. I spent some time diffing the 2 revisions and couldn't find anything that seemed relevant. Eventually I figured out the specific change that was causing the failure. There was code that looked something like this...


someCollection.each { someElement ->
  // do something with someElement
}

That code had been changed to look something like this...


for(someElement in someCollection) {
  // do something with someElement
}

The code inside the loop was exactly the same for both versions. The only difference is the original code was using "each" to iterate over the collection and the new code was using a "for" loop to do the same thing. I puzzled over that for a bit trying to figure out what was going wrong and after discussing with my co-developers the problem eventually became clear. Code inside the loop was making use of someElement inside of a closure and later that closure was being executed. Consider this...


def listOfClosures = []
def numbers = [1, 2, 3]
numbers.each { number ->
  listOfClosures[number] = { println "number is $number" }
}
listOfClosures[1]()
listOfClosures[2]()
listOfClosures[3]()

As you might guess, the output from that looks like this...


number is 1
number is 2
number is 3

Now consider this...


def listOfClosures = []
def numbers = [1, 2, 3]
for (number in numbers) {
  listOfClosures[number] = { println "number is $number" }
}
listOfClosures[1]()
listOfClosures[2]()
listOfClosures[3]()

The output from that looks like this...


number is 3
number is 3
number is 3

With the "for" loop approach, the same "number" variable is used each time through the loop so by the time the loop completes, the value of "number" is 3 which is what is used by the time the closures execute. With the "each" approach, a separate variable is used for each iteration so each closure accesses the "number" that was around when the closure was declared. None of that is broken or a bug. I believe it is all working as it should.

Thanks to Charles Nutter and Graeme Rocher for helping with that.

My Apologies To The New York City SIG

2007-07-20T17:55:00.000-05:00

This past Wednesday night Andy Glover and I were scheduled to co-present at The New York Java Special Interest Group. Andy was going to give a 90 minute session on Groovy and I was going to give a 90 minute session on Grails.

Wednesday turned out to be crazy day in New York. Weather made it difficult for air travelers to make their way in to JFK Airport. The huge steam pipe explosion that happened in mid-town Manhattan made it very difficult to drive in to Manhattan. The whole story is a very long one but the short of it is that Andy's flight was canceled and so was mine. We couldn't get a second flight booked for Andy but we were able to get one booked for me. Unfortunately mine was an indirect flight and the second leg was delayed numerous times and I finally got to JFK to find that because of the steam pipe explosion in the city, the trip from JFK to the meeting location was well over an hour and by the time I got into the city, there was no point. I think the meeting was scheduled to run until about 8:00 and I think I got into Manhattan shortly after 8:00.

I was really disappointed myself as I have never had the opportunity to work with Andy before this event and I was really looking forward to it but mostly I felt bad for all of the developers in New York who made it to the show only to find out that there were no speakers. The New York developer community is really enthusiastic about Groovy and Grails and the large audience that turned up to see the show represents that. I am sorry that they were left to look at an empty stage Wednesday night. I promise all of them that we were scrambling all day to work it out and each time we came up with a solution another problem came up, mostly related to shut downs at JFK. I hope that many of the folks who came out to the SIG meeting will make it to the NFJS show in Princeton New Jersey the weekend of August 10th. I will not be there myself but my friends Jason Rudolph, Scott Davis and Venkat Subramanium will all be there with Groovy and Grails sessions.

Again, I offer my apologies to everyone who came out to the show Wednesday evening and I hope that you will invite us again.

Alternate Syntax For URL Mapping In Grails

2007-05-19T22:53:00.000-05:00

One of the cool new features that was introduced with Grails 0.5 is Custom URL Mapping. The syntax for declaring the mapping looks something like this...


class MyUrlMappings {
  static mappings = {
    "/product/$id" {
       controller = "product"
       action = "show"
    }

     "/$blog/$year/$month/$id" {
          controller = "blog"
          action = "show"
          constraints {
               year(matches:/\d{4}/)
               month(matches:/\d{2}/)
          }
     }
  }
}

Since the release we have added support for an alternate syntax (which I happen to like) that looks like this...


class MyUrlMappings {
  static mappings = {
    "/product/$id" (controller:"product", action:"show")

     "/$blog/$year/$month/$id" (controller:"blog", action:"show"){
          constraints {
               year(matches:/\d{4}/)
               month(matches:/\d{2}/)
          }
     }
  }
}

Dynamic languages like Groovy make these sorts of things really easy to support. Behind the scenes of this url mapping there there is no grammar file and no tangly parser to manage. The configuration file is plain old groovy code. Blurring the line between code and configuration files by using a DSL like this is so much easier in Groovy that it might be in a language like C++ or Java. You have got to love it. :)

Autism Visibility Continues To Increase

2007-05-19T22:40:00.000-05:00

Dover Speedway has announced that the NEXTEL Cup race coming up there in June will be named “The Autism Speaks 400 presented by Visa”. NEXTEL Cup racing is huge here in North America and has a very large fan base. Autism Speaks is one of the largest foundations in the world that is dedicated to autism. I am happy to see them get their name on the marquee of an event like this. That can only help with awareness.

This is not the first time that autism and automobile racing have crossed paths. Jamie McMurray has an autistic niece and partnered with The Autism Society of American in 2004 when he drove the “Drive For A Cure” car. Tony Renna drove the “Cure Autism Now” car in 2003. There have been others.

It has been almost exactly 5 years since my youngest son Jake was diagnosed autistic. In those 5 years I have learned a number of things about autism and one of those things that I have learned is that there are not a lot of people who know much about autism. Awareness is increasing. That isn't because more people are reading medical journals in their free time. Aside from a dramatic increase in the number of kids being diagnosed autistic, the biggest reason that awareness is increasing is that more and more autism is showing up in the mainstream media. Recently some actors and other celebrities have been criticized for jumping on the “autism bandwagon”. These criticisms often refer to autism as the disease du jour. I don't have much to say about that except to say that raising awareness is an important part of this fight and when I see people going out of their way to help with awareness, I am happy to see that.

Cool New Features In Grails 0.5

2007-05-01T19:30:00.000-05:00

Grails 0.5 was released today and this release is one of the most exciting releases yet. This release has closed the gap on a number of key features that needed to be knocked out before the coming 1.0 release. Some of the new features will be more appealing to some projects and other features more appealing to other pojects. For me some of the coolest new features added in 0.5 are Command Objects, List and Map Support in GORM and Custom URL Mappings. Hundres of JIRA issues have been addressed in this release and significant performance enhancements have been made. The development team got a whole lot done during this iteration. See the release notes for a more complete list of new features.

With the recent release of the first beta of Groovy 1.1, things continue to heat up in the Groovy and Grails communities.

This year I have been speaking at Java User Groups, internal training events and on the No Fluff Just Stuff Tour about Groovy and Grails and I am finding that folks in the Java community are really excited about both Groovy and Grails and the possibilities that these technologies bring to their projects. After a bit of time that really seemed kind of dull for the JVM, Groovy and Grails are making it all fun again and at the same time adding a lot of value to the enterprise by increasing productivity and expanding the possibilities. For example, defining a DSL using Antlr or similar technologies may not have been a realistic possibility for many applications but dynamic technologies like Groovy make things like that not only possible but simple to build. There are many many examples just like that which represent ways Groovy can help developers get their jobs done faster and more simply. Frankly, I don't think Grails would be anywhere near as compelling as it is if it weren't for all of the coolness made possible by Groovy. Grails has taken the possibilities that Groovy provides and leveraged them all over the framework to provide simple concise techniques for web application developers to use to build powerful web applications very quickly.

Grails has earned a lot of respect in the community by getting very far along in a short amount of time. While Grails applications are already being deployed in production environments, both private and public facing sites, the coming 1.0 release is going to push Grails right out there to the front of the pack. This is exciting stuff!

More to come... :)

I Have Been Tagged (Twice)

2007-04-06T11:33:00.000-05:00

I have been tagged twice recently. First by Jason and now by James. I suppose I need to be a good citizen and play along. :)

I am not really sure what the rules are here. I know that I am supposed to list several things that you probably don't know about me. I don't know if these things are supposed to be funny, embarrassing, personal, impressive, inspiring or what. I don't know if knowing the rules would help me figure out what to write anyway so I am just going to jot out some facts and hope that I don't suffer some sort of penalty for any violation I might commit. :)

I am a member of The American Go Association. I love playing Go, although I am not able to make as much time for it as I might like. My commitment to Go seems to come and go with periods when I will play a lot and periods when I don't play much at all. My friend Lianzhou Yu moved out of state a couple of years ago and that has affected my playing time. Lianzhou is one of the top players in The United States and was a great mentor to have access to. A few years ago my friend Brian Gilstrap and I got together in his wood shop (which I am envious of) to build a couple of Go boards. I am pretty happy with the way my board turned out. I wish I played on it more often. As it is, most games I play these days are played on my laptop against GNU Go.

I won the first large poker tournament I ever played in. The tournament was a charity event to benefit The National Alliance For Autism Research (now Autism Speaks). Having an autistic son, I was happy to contribute and participate in the tournament. There were about 130 entrants. When I heard about this event I gathered up the group of guys that I played cards with regularly and we ended up with 11 of us in the tournament. The final table at the tournament (final 10 players) included 4 guys from our group. In one of the final hands I made a mistake and then ended up getting pretty lucky to beat my friend Paul Jensen out of a big pot and that piece of luck put me in a position to win the tournament.

My name is Jeff, and I am a metal head. There, I said it. I am a fan of heavy metal music. Black Sabbath, Iron Maiden, Slayer, Sepultura, Opeth, Lamb Of God... all guilty pleasures.

I enjoy fly fishing. I tie all of my own flies. I fish mostly for trout in the cold water streams and rivers in Missouri. My late father-in-law introduced me to fly fishing more than 10 years ago. I find less time for fly fishing these days but I really enjoy myself when I do make time to get out in the water.

There was a time long ago when I really, really, really needed a haircut. Why didn't anyone approach me and say something like “friends don't let friends have mullets”?

Now I am going to throw to Dean, Lance, Brian, Eric and Nate.

My Mac OS X Bling

2007-02-17T09:43:00.000-06:00

I am now about 2.5 weeks in to my MacBook Pro owning experience. I will say that I am really really happy with the experience so far. I have tinkered with the idea since OS X was introduced and finally decided to give it a go. I am going to provide a rundown of apps I have installed and use. This is everything (I think) that I use that isn't part of the standard OS X install that came with the hardware. If you are an OS X user then at least some of these you already know about but maybe there will be a couple new ones here for you.

Firefox
To be honest, I didn't even give Safari a shot. One of the first things I did was download Firefox. Maybe I should look at Safari, but I probably won't unless at some point I hear/read something that gives me some specific reason to do so.

Desktop Manager
This is a virtual desktop switcher with nice effects (bling) when switching desktops like the rotating cube and others. VirtueDesktops has some nice features but it crashed more than once for me. I may look again when the next release comes about.

TextMate
TextMate is The Full Schizzle. If you edit text (xml, java, c, ruby, groovy, screenplays, etc...) TextMate is for you. If you aren't familiar with TM, visit the site and watch some of the screencasts.

SnapZ Pro X
This is really nice software for recording screencasts.

Adium
Adium is an IM client that allows me to connect to MSN, Yahoo, AIM, Google Talk, ICQ, Jabber and others.

Skype
Skype is another messaging client. The only reason I have this in addition to Adium is that I have a meeting once a week with some folks overseas and we do that over Skype using its group voice capabilities.

NeoOffice
OpenOffice for the Mac. I haven't used it enough to say for sure if I really like it, but so far it is fine.

iRed Lite
iRed Lite is a utility that lets me use the standard MacBook remote control to control more applications than it otherwise does, like NeoOffice, PowerPoint and others.

QuickSilver
A slick utility similar to the built in Spotlight but a little nicer to use, at least for some things.

Spanning Sync
This lets me sync my desktop iCal with my public Google calendar, which I really like. The main site says "coming soon" but betas are available now.

Goban
I don't play computer games, except for Go. This is a nice Go client.

Blender
An awesome 3D animation tool. The movie Elephant's Dream was created with Blender. The entire movie is distributed under a Creative Commons license so you can get all of the production files for free and monkey with the movie if you want to.

StuffIt Expander
I don't have much to say about this one but I use it and include it here for completeness.

Standard dev tools that really aren't peculiar to OS X but I happen to use on my MacBook Pro...

Eclipse, NetBeans and IntelliJ IDEA
I have installed all 3 IDEs. I use Eclipse primarily. I installed NetBeans because I am about to start doing NetBeans Platform development and need to get familiar with the environment. I installed IntelliJ for no particular reason other than I have a license for open source development, though I haven't used it in a couple of years.

I also use Groovy, Grails, JRuby, Ant and the Subversion Client.

I would be happy to hear about your favorite OS X applications.

Groovy And Others Continue To Expand The JVM Horizon

2007-01-20T08:50:00.000-06:00

We have had the JVM for over a decade now. There are a whole lot of languages out there that allow developers to build applications for the JVM. The most popular of course is Java. The alternative languages cover the whole spectrum including Lisp, Scheme, Logo, Tcl, Cobol, Ada, Python, Forth, Fortran, Pascal and on and on and on. Why would so many people spend so much effort developing new languages for the JVM or bindings for existing languages to run on the JVM when Sun already went to the trouble of developing the Java language? That is a fair question. The answer varies from case to case. Many of the languages built for the JVM were academic exercises but certainly not all of them. Part of the answer is the fact that the JVM is a fantastic platform for deploying applications but the Java language is not always the best solution for the job at hand.

Among the wide array of languages for the JVM, a few languages have poked their heads up as key players lately. In particular, dynamic languages are getting a lot of attention, for good reason. Of those dynamic languages at this point Groovy and JRuby are among the most popular.

JRuby is a pure Java implementation of the Ruby programming language bringing the power and flexibility of Ruby to the Java platform. One of the significant contributors to Ruby's success is the Ruby On Rails web application framework. JRuby promises to bring that power and flexibility to the JVM. JRuby is a great tool for folks who want to write Ruby code for the JVM but JRuby is not what I want to talk about today. I want to talk about Groovy...

Groovy is a dynamic language written specifically for the JVM. Groovy has a syntax that in many areas is going to be really familiar to Java programmers. Like Ruby has Ruby On Rails, Groovy also has a framework for agile web development and that framework is Grails. Grails has taken a whole lot of inspiration from Ruby on Rails and is a really powerful and fun way to build web applications for the JVM. Grails is bringing the "coding by convention" paradigm to Groovy web programming in a way that is really appealing to developers already familiar with Java's syntax and the rich capabilities of the JVM.

So What Is Happening With Groovy And Grails?

So much is going on with Groovy and Grails right now. The Groovy community has been on track for a long time now knowing that 2007 was going to be a big year. Now that 2007 is here, Groovy and Grails are really in their groove. ;)

Here are some of the things stirring in that community right now:

- Groovy has just released version 1.0. The Groovy community has known that this was coming and having 1.0 out there on the shelves now is a big win for Groovy.

- Manning has recently published Groovy In Action, known as GINA. GINA is being referred to as "Groovy's Pick Axe Book" (a reference to Dave Thomas' definitive guide to Ruby, Programming Ruby). That is not because GINA was the first major book published on Groovy. This has more to do with GINA's clear, direct and thorough coverage of the language.

- Apress has recently published The Definitive Guide To Grails. In The Definitive Guide, Graeme Rocher presents Grails with a real nuts-and-bolts feel that takes developers through comprehensive coverage of the Grails framework.

- Morgan Kaufmann has recently published Groovy Programmers: An Introduction for Java Developers. I have not had time to read Kaufmann's book yet but I think having another general coverage book out there is probably a good thing.

- Jay Zimmerman and Scott Davis have gone live with http://www.aboutgrooy.com/, a great one stop shopping portal for all things Groovy and Grails.

- InfoQ recently published Jason Rudolph's minibook Getting Started with Grails, providing another source of Grails coverage and bringing Grails to the attention of more folks.

- The 2007 No Fluff Just Stuff Symposium Tour is dedicating significant track time to both Groovy and Grails. NFJS has always responded to the community by presenting what developers know is going to be important and the timing is just right this year for the tour to bring Groovy and Grails to the forefront.

- Skills Matter has announced the first 3 day Grails eXchange 2007 event. Grails eXchange focuses on Groovy and Grails in addition to providing tracks dedicated to Java Entperise Edition (JEE) and Ajax/Web 2.0.

- Sven Haiges has announced that his series of Grails podcasts is going to expand to include general Groovy coverage. Sven's podcasts have been a great asset to the Grails community and opening that up to include more Groovy coverage is going to be great for the community.

- Some recent podcasts of interest include Scott Davis' interview with Guillaume Laforge, an interview with Jay Zimmerman and an interview I did with Sven Haiges for the Grails Podcast series.

Developers and Enterprises that are interested in building applications for the JVM are going to find that Groovy solves a lot of their problems really well. All of those Java developers out there will find that learning "The Groovy Way" is not a difficult task and the benefits are fantastic. Combine all of that with the fact that writing Groovy code is just plain fun and you have got a recipe for success.

If you don't already know why so many people are getting excited about Groovy, pickup a copy of GINA and start tinkering. As you start developing your Groovy Kung Fu you will start to question many aspects of "the old way" that have been taken for granted for so long now. Many things about Groovy "just make sense".

Have Fun!

Next Grails Release Coming Soon

2007-01-10T21:40:00.000-06:00

After a bit of a development slowdown around the holidays the Grails development team is back at full throttle working on the next release. Version 0.4 is probably going to be ready to ship within the next few weeks. Version 0.3 was a really significant release in terms of new functionality and addressing some key issues that had been lingering. I feel like 0.4 is even more significant. The team is working hard to add new functionality and also filling in a lot of those little nuisance gaps.

Things are really ramping up in the Grails community. We are seeing folks coming up with interesting plugins. The mailing lists are very active. If you haven't taken a look yet, give Grails a spin. The Quick Start Guide doesn't even scratch the surface of capabilities but is a good first step. Following that guide will take about 10 minutes and you will have a simple CRUD application up and running.

Stay tuned for exciting things from Grails in the coming months.

Groovy 1.0 Has Been Released!

2007-01-02T17:35:00.000-06:00

Finally, after a lot of waiting and a lot of work from the Groovy dev team, Groovy 1.0 has been released.

Thanks to the Groovy dev team for working through all of the challenges, hassles, debates, hard work etc. that were all part of getting to 1.0.

2007 is going to be a big year for both Groovy and Grails. I am proud to be a member of the Grails development team and I am looking forward to what 2007 holds in store for us.

As one of my mentors is fond of saying... Press On!

Groovy 1.0 RC2 Released

2006-12-23T14:48:00.000-06:00

Groovy 1.0 RC2 was released today. If all goes well over the next few days the 1.0 release should be available by year's end. The community has been waiting a long time for this. All of the hard work and patience from the Groovy development team is about to pay off. Thanks Guys!

Have A Groovy Christmas!

The Definitive Guide To Grails

2006-11-25T09:03:00.000-06:00

The Definitive Guide To Grails is finally available from Apress. The book is a well written easy read that provides a great foundation for Grails developers.

Manning's Groovy In Action (GINA) has been available through their Early Access Program for several months now. The final version of GINA will be available in the next month or so.

Things are heating up in the Groovy and Grails communities. Look for a lot of exciting things to be happening around Grails soon.

Grails 0.3 Released

2006-11-09T21:34:00.000-06:00

Grails 0.3 was released today. A lot of work went in to this release which addresses over 100 bugs and feature requests. In my opinion, the fact that Grails is currently at 0.3 is a little misleading. The framework is very powerful and stable. There is a lot on the horizon but the tool is very powerful in its current state. Give it a spin.

I have recently joined the Grails development team and I am looking forward to what the future has in store for Grails.

Grails Support For HTTP Method Restrictions

2006-11-04T10:57:00.000-06:00

I have committed code to Grails to support a declarative syntax for imposing restrictions on which controller actions may be invoked using which http request methods. See the docs for details.

Grails Enhancement Submitted

2006-10-21T15:24:00.000-05:00

I have worked up an enhancement to Grails recently that provides an easy declarative way for application authors to limit access to certain controller actions based on the http request method (PUT, POST, GET, etc...). Generally speaking, applications should not allow destructive operations to be initiated in response to a GET. That isn't the only reason to want to impose restrictions, but it is a common one. With Grails, the only way to deal with this is to put code in your controller to inspect the request object and figure out if the request was a GET, POST or whatever. For the common case where all I want to do is prevent certain actions from being invoked via a GET, I don't want to have to do that. I just want to tell the framework not to allow it. The patch I have worked up does just that. The patch allows code like this in your controller...


class EmployeeController {

  // action1 may be invoked via a POST
  // action2 has no restrictions
  // action3 may be invoked via a POST or DELETE
  def httpMethodRestrictions = [action1:'POST',
                                action3:['POST', 'DELETE']]

  def = action1 { ... }
  
  def = action2 { ... }

  def = action3 { ... }

}

The patch has been attached to http://jira.codehaus.org/browse/GRAILS-379.

Grails Presentation Thursday Evening

2006-09-16T09:02:00.000-05:00

My Grails presentation Thursday evening went very well. Weiqi Gao blogged about the presentation in real time.

The presentation slides are available at http://www.ociweb.com/javasig/knowledgebase/2006-09/. The tone of the whole session was very light and fun. You will see in the notes that I included quotes about Grails from famous people such as John Lennon, Mr. T, Batman and Robin and even Elvis Presley. Each time a celebrity came up in the slides I asked a trivia question about that celebrity and the first person to shout out the correct answer was given a copy of the Groovy In Action MEAP, courtesy of Manning Publishing. Thanks to Manning for those.

There are not many code samples in the presentation slides. During the presentation I built a simple application and along the way applied the concepts that are mentioned in the notes.

Before the presentation there was some discussion among the group about the future of Java and a lot of people in the group agreed that dynamic languages are going to be an important part of what we do in the future.

Learning New Languages, Like Haskell (not Eddie)

2006-09-06T20:19:00.000-05:00

There are a number of reasons for developers to learn new programming languages. One reason is to keep their skills current. Another reason is that many developers simply find learning new languages to be fun. Another reason is that learning new languages forces developers to think about problems differently. That is what I want to discuss.

Learning new spoken languages changes the way people think about problems. Learning new programming languages is no different. When a C++ developer learns Java they can't do pointer arithmetic any more. They can't use multiple inheritance in the same way. What about Ruby and Groovy? The fire marshall is going to shut down the Ruby bandwagon because it is way over capacity right now. I don't think there are any Java developers left who haven't at least tinkered with Ruby. Java developers learn Ruby and then realize things about Java that start to seem fundamentally wrong. Why isn't there a simple syntax in Java for declaring properties like you can in Ruby or Groovy? Why are there so many 1 line getters and setters in the Java world? What about that dynamic typing? That takes some getting used to. On and on... More languages... More examples...

Languages like C++, Java, Ruby and Groovy are all very different languages but at the same time, are all pretty much the same. They are all object oriented. When you write a program in one of those languages you model the business objects, encapsulate logic, pass references around and all of these objects collaborate to solve a problem. OO has been around for a pretty long time now and is an effective way to build systems. If learning different OO languages is beneficial (and it is), what about learning fundamentally different languages? That ought to be valuable as well. I say it is anyway.

I recently spent a little time playing with BF. That is interesting stuff but no sane person is every going to propose that is a good way to write anything. However, learning BF is an interesting exercise. Try to write a simple calculator in BF and you will be forced to think about things differently. Learning BF is strictly an academic exercise.

On a more practical front I have been playing with Haskell lately and am finding it very interesting. Haskell is a functional programming language. Functional programming languages are all about the function. Haskell is a real programming language that is used to build real systems, not just a goofy language to play around with (like BF). At first the language may seem prohibitively useless for its lack of things imperative programmers are used to. For example, there is no destructive assignment in a pure functional language. That means there is no such thing as "x = x + 1". What? How can I write software without basic functionality like that? You can. This "feature" isn't missing from the language (or whole class of languages), it just isn't necessary.

My Haskell Kung Fu is nowhere near sharp enough to provide any kind of tutorial but I will tempt your curiosity with some very basic hello world kind of examples. Take a look at this...


fac 1 = 1
fac x = x * fac(x - 1)

That is a way to write a function in Haskell to calculate factorials. The first line says "factorial 1 is equal to 1". The second line says "factorial of any other number is that number multiplied by the factorial of 1 less than that number". That seems pretty straightforward, doesn't it? If you read those 2 lines of code out loud, it reads almost like you would describe what a factorial is.

If you can follow the factorial example, the fibonacci example below shouldn't be difficult to understand...


fib 0 = 0
fib 1 = 1
fib x = fib(x - 1) + fib(x - 2)

I don't know how functional programmers really think about that but my OO mind thinks of that as 3 overloaded versions of the "fib" function. One takes a 0 as an argument, one takes a 1 as an argument and the other takes any other number as an argument. This could be written in haskell with just 1 function and some "if" blocks but the code above is "the functional way".

A slightly more complicated example is a sort routine like this...


my_sort [] = []
my_sort (x:xs) = my_sort less_than_x ++ [x] ++ my_sort greater_than_x
 where
  less_than_x = filter (<x) xs
  greater_than_x = filter (>=x) xs

The first line there says that the result of sorting an empty list is an empty list. That seems reasonable to me. The rest is another "overloaded" (probably not the terminology the functional crowd would use) version of the same function. This version accepts a list as an argument where x is the first element in the list and xs is the rest of the list. That little syntax turns out to be useful a lot. The result of sorting that list is achieved by concatenating (++) 3 things. The first thing is a sorted copy of everything that is less than x. The second thing in the concatenation is x. The third thing in the concatenation is a sorted copy of everything that is greater than x (actually greater than or equal to x, as we'll see shortly). The labels "less_than_x" and "greather_than_x" are just that, labels. There is no Haskell magic at play there. The lines after the "where" clause define what those labels refer to. "less_than_x" is defined to be everything in xs that is less than x. "greater_than_x" is defined to be everything in xs that is greater than or equal to x. Since "less_than_x" and "greater_than_x" need to be sorted before the concatenation takes place, recursion is taking place.

Some may look at that code and immediately conclude that it is confusing to look at and can't possibly be a good way to write code. However, once you understand how each of those pieces work, this is really a pretty direct expression of what is being accomplished.

Maybe you will take some time to look at Haskell and find a lot of interesting things about it. If you are really feeling funky and want to explore functional programming constructs in Java, take a look at FunctionalJ. That is interesting to think about but I think from the perspective of tweaking your brain a bit, for a lot of folks learning Haskell is probably a more interesting and more valuable experience.

Enjoy!

Obscure Programming Language

2006-08-20T18:40:00.000-05:00

I was doing some research on quines this weekend and while doing so I stumbled across several obscure programming languages that I was not previously familiar with. The following is actual code I wrote that will compile and run (it isn't a quine)...


>++++++++++[>+++++++>+++++++++++>+++++++
+++>++++++++++++>+++>++++++++[<]>-]>-.>+
++++.>-.+++++.---.>-.>++.>-.<<<---.++++.
<++.--.>---.--.<+.>++++++++.<-----.-.>>>+.

Do you know what language that is? A few hints...

The language is composed of just 8 commands, each expressed with a single character (7 are used in the program above)

Whitespace is insignificant

The language is "Turing-Complete"

The language has a colorful name (if you reply to this, you may use the initials to avoid the offensive word)

db4o and Groovy

2006-07-08T21:42:00.000-05:00

I want to say thanks to Christof and the rest of the gang at db4o as they were kind enough to send me a hardcover copy of The Definitive Guide to db4o. The book showed up this week. I have not had time to read all of it at this point but at a glance it looks like the authors have covered a lot of interesting territory inlcuding replication with Hibernate, which I expect is going to be a big win for db4o in the eyes of a lot of folks.

I have worked up some interesting Groovy integration capabilities for db4o. As soon as I have some time to clean some of that up and get it documented I will be sharing that.

I wish continued success to all of the guys at db4o.

New Groovy Spec Lead

2006-06-14T21:11:00.000-05:00

Today the official announcement was made that Guillaume Laforge is the new Groovy JSR-241 Spec lead.

The whole Groovy community is anxious about the next few months hoping that 1.0 will be finished up. Congrats and good luck to Guillaume!

Groovy And JScience

2006-06-04T16:42:00.000-05:00

I have been spending a lot of time investigating Groovy lately. I wanted to dig in to writing a Groovy Category so I started writing some code to support things like this...


def duration = 30.minutes + 2.hours

Before I got too far along there I discovered that John Wilson had already implemented a lot of that in his TimeCategory which is part of Google Data Support.

I had recently read a JNB article that Lance Finney had written on JScience and that gave me another idea. I decided to write a Groovy Category that would use JScience to support things like this...


def len = 2.kilometers + 500.meters

Since I wanted to do this as an exercise I decided to not even do any research to find out if anyone had already implemented something like this. I wanted to build this for my own benefit as a learning exercise. I started by expressing some of my own requirements in the form of a Groovy Unit Test like this...


class JScienceTest extends GroovyTestCase {

  void testConversions() {
    use(JScienceCategory) {
      def len = 2.kilometers
      assertEquals 2.0,    len.kilometers,  0.00001
      assertEquals 2.0E3,  len.meters,      0.00001
      assertEquals 2.0E5,  len.centimeters, 0.00001
      assertEquals 2.0E6,  len.millimeters, 0.00001
      assertEquals 2.0E9,  len.micrometers, 0.00001
      assertEquals 2.0E12, len.nanometers,  0.00001
      
      def len2 = 400.centimeters
      assertEquals 4.0E-3, len2.kilometers,  0.00001
      assertEquals 4.0,    len2.meters,      0.00001
      assertEquals 4.0E2,  len2.centimeters, 0.00001
      assertEquals 4.0E3,  len2.millimeters, 0.00001
      assertEquals 4.0E6,  len2.micrometers, 0.00001
      assertEquals 4.0E9,  len2.nanometers,  0.00001
    }
  }
  
  void testAddition() {
    use(JScienceCategory) {
      def len = 2.kilometers + 500.meters
      assertEquals 2.5, len.kilometers, 0.00001
    }
  }
  
  void testSubtraction() {
    use(JScienceCategory) {
      def len = 3.kilometers - 500.meters
      assertEquals 2.5, len.kilometers, 0.00001
    }
  }
  
  void testMultiplication() {
    use(JScienceCategory) {
      def len = 3.kilometers * 2
      assertEquals 6.0, len.kilometers, 0.00001
    }
  }
  
  void testDivision() {
    use(JScienceCategory) {
      def len = 42.meters / 3
      assertEquals 14.0, len.meters, 0.00001
    }
  }
}

My Groovy Kung Fu is still developing and I had not done anything at all with JScience before this. Even with those limitations I was able to get all of those tests passing in about an an hour.

Would you rather do this in Java...


Measure length = Measure.valueOf(50, SI.CENTI(SI.METER)).plus(Measure.valueOf(25.0, SI.METER));
Measure lengthInCentimeters = length.to(SI.CENTI(SI.METER));
System.out.println("length in centimeters is " + lengthInCentimeters.getEstimatedValue());

Or do this in Groovy...


def length = 50.centimeters + 25.meters
println "length in centimeters is ${length.centimeters}"

Isn't Groovy fun? :)

Operator Overloading In Groovy

2006-05-30T21:08:00.000-05:00

I have been doing some Groovy development lately. I just spent a few minutes spinning around a quirky behavior that makes perfect sense to me now but at first had me scratching my head. Take a look at this...


def sqlDate = new java.sql.Date(System.currentTimeMillis())
sqlDate += 2

That code is creating an instance of java.sql.Date and adding 2 days to it. My moment of confusion comes from the fact that after adding the 2 days the sqlDate reference no longer points to a java.sql.Date object but instead points to a java.util.Date object. Hmm... What is going on?

The operator overloading is being inherited into java.sql.Date from java.util.Date. The plus method in java.util.Date is returning a java.util.Date, which makes perfect sense. Since that method is inherited into java.sql.Date and not overridden then when it is invoked it returns a java.util.Date.

Try this...


def sqlDate = new java.sql.Date(System.currentTimeMillis())
println sqlDate.class
sqlDate += 2
println sqlDate.class

db4o is pretty interesting

2005-12-05T20:30:00.000-06:00

I have done a lot of work with a number of Java persistence solutions including JDBC, JDO, Hibernate, JSR-220 Persistence and Prevayler (have just tinkered with Prevayler... no real work). Just recently I started investigating yet another persistence solution called db4objects (db4o). db4o has versions for Java, .NET and Mono. I have only investigated the Java version. In the time that I have spent investigating db4o I have found some pretty interesting stuff.

One thing that stands out is that db4o allows you to persist plain 'ol Java objects as plain 'ol Java objects. POJOs need not extend any magic base class or implement any special interface. POJOs need not have any special id field. POJOs need not have any special constructor. There is no requirement for a no-arg constructor or even a public constructor. db4o doesn't require any object descriptors (XML or otherwise) and doesn't require you to mark persistent classes up with annotations. db4o does not require that persistent fields have Java Bean compliant getters and setters. db4o pretty much will take your objects as they come.

db4o can run in embedded mode which means that all of db4o is inside of your applications process. There doesn't need to be a separate db4o process running somewhere. There can be if that suits your deployment needs, but there doesn't need to be.

db4o has some pretty robust schema evolution capabilities that allow fields to be added, removed and renamed. There is support for moving classes to new packages.

db4o is an OO database. db4o is not an object to relational mapping tool, the db is an OO db.

One of the issues I initially had concerns about was performance once the database accumulated large numbers of objects. To test some of this, I created a fairly simple object model to represent music cds. The classes look something like this...


public class CDArtist {
  private String name;
  private List<CD> cds = new ArrayList<CD>();
  // constructor and methods snipped...
}


public class CD {
  private String title;
  private List<CDTrack> tracks = new ArrayList<CDTrack>();
  // constructor and methods snipped...
}

public class CDTrack {
  private String title;
  private int trackNumber;
  private CD cd;
  // constructor and methods snipped...
}

I downloaded a gaboodle of data from freedb.org and wrote a simple parser to turn that data into instances of my classes and started dropping those into my db4o database. At present I have about 75,000 artists, 185,000 cds and over 2,000,000 tracks in the database. I realize that for a lot of situations even those 2,000,000+ tracks don't really amount to a lot of data but that is what I am currently working with. It is enough data to exercise some of the things I wanted to look at.

db4o supports 3 query techniques...

Query By Example

Native Query

S.O.D.A.

I will show a simple example of each of these here and include some performance figures.

Query By Example (QBE)

The following code uses QBE to retrieve all CDs in the database that contain a track with the name "The Trooper".


Db4o.configure().objectClass(CDTrack.class).maximumActivationDepth(0);
Db4o.configure().objectClass(CDTrack.class).objectField("title").indexed(true);

// my custom factory
ObjectContainer db = ObjectContainerFactory.get().createObjectContainer();

CDTrack myCandidateTrack = new CDTrack(null, 0, "The Trooper");
List<CDTrack> results = db.get(myCandidateTrack);
for (CDTrack track : results) {
  CD theCD = track.getCd();
  System.out.println(theCD);
}

db.close();

That query completes in less than 300-400 milliseconds. That is querying over 2,000,000 tracks, identifying the ones that match the name "The Trooper" and retrieving the cd that the track belongs to (note the call to track.getCd() inside of the loop).

S.O.D.A.


Db4o.configure().objectClass(CDTrack.class).maximumActivationDepth(0);
Db4o.configure().objectClass(CDTrack.class).objectField("title").indexed(true);

// my custom factory
ObjectContainer db = ObjectContainerFactory.get().createObjectContainer();

Query query = db.query();
query.constrain(CDTrack.class);
query.descend("title").constrain("The Trooper");
ObjectSet<CDTrack> results = query.execute();
for (CDTrack track : results) {
  CD theCD = track.getCd();
  System.out.println(theCD);
}

db.close();

That S.O.D.A. query executes in about 100 milliseconds. Again querying over 2,000,000 tracks and retrieving the matching tracks and their containing cds.

Native Query

This is what a native query might look like in db4o.


Db4o.configure().objectClass(CDTrack.class).maximumActivationDepth(0);
Db4o.configure().objectClass(CDTrack.class).objectField("title").indexed(true);

// my custom factory
ObjectContainer db = ObjectContainerFactory.get().createObjectContainer();

List<CDTrack> results = db.query(new Predicate<CDTrack>() {
  public boolean match(CDTrack candidate) {
    return candidate.getTitle().equals("The Trooper");
  }
});
for (CDTrack track : results) {
  CD theCD = track.getCd();
  System.out.println(theCD);
}

db.close();

This approach has some nice benefits. One is that you get real compile time type safety. The query isn't some arbitrary string that might or might not be legal at runtime. The query is real Java code that gets compiled. That is nice. However, that Predicate looks a little suspect to me. Judging from looking at the code it seems that the db4o engine is going to have to create all of my CDTrack objects and pass each of them one a time to my match(CDTrack) method so I can decide which of them match my criteria. Since I have over 2,000,000 tracks that can't be efficient. The code above executes in about 100-150 milliseconds. I am still querying those 2,000,000+ tracks and retrieving all the same stuff I was retrieving in the previous examples. What is going on here at runtime is that db4o is doing some slick class loading voodoo and figuring out what my Predicate would do, then it optimizes all of that away by turning my Predicate into a S.O.D.A. query. Run the code in a debugger and find that my match(CDTrack) method never actually gets called. There are limits here. The optimizer does a good job of figuring out what you intended to do but you can do things in your Predicate that the optimizer can't figure out in which case the Predicate cannot be optimized away and then the engine will have to create all of those CDTracks and pass them to the match method. This is easy enough to sort out at development time if you need to make sure the Predicate will be optimized. While experimenting with this don't try to put a System.out.println call or logging calls in your Predicate to monitor if your Predicate is getting called or not. Those fall in the category of things that the optimizer can't handle and a side effect of them being there is that the method will not get optimized away. There is a callback mechanism you can hookup to retrieve notifications that indicate when a Predicate is optimized and when it isn't.


ObjectContainer db = ObjectContainerFactory.get().createObjectContainer();

((YapStream)db).getNativeQueryHandler().addListener(new Db4oQueryExecutionListener() {
  public void notifyQueryExecuted(Predicate filter, String msg) {
  }
});

That callback will be notified when db4o first deals with any particular Predicate. The msg argument will by "DYNOPTIMIZED" if the query has been dynamicallly optimized. msg will be "UNOPTIMIZED" if the query could not be optimized. msg will be "PREOPTIMIZED" if the query had been pre optimized. db4o has some bytecode manipulation tools to preoptimize Predicates but I have not investigated that.

They are working on some Hibernate replication modules that will allow a db4o database to be kept in synch with a relational database via Hibernate. That code is still in development and I haven't looked at any of that.

The discussion forums are pretty active and as far as I can tell there is a lot of momentum behind the effort right now.

db4o is distributed under a couple of different license. There is a GPL version available for open source projects, experimenting and internal projects. There is also a commercial license available for commercial, non-open source applications. As far as I know, the GPL version is the same software as the commercial version. The restrictions have to do with distribution, not the software itself.

No reasonable person is going to claim that db4o is the silver bullet of persistence but it is interesting stuff and probably makes a lot of sense for a lot of applications. If nothing else, it is a good thing to be aware of.

Is Sun Pimping The Java Name?

2005-04-29T09:46:00.000-05:00

Does the name "Java" really belong on these products?

Sun Java Desktop System

Sun Java Workstation W1100z

Sun Java Workstation W2100z

Free IntelliJ IDEA License

2005-03-03T13:16:00.000-06:00

A few weeks ago the guys at JetBrains/IntelliJ announced the availability of IntelliJ IDEA licenses that they were making available free of charge to qualifying open source developers. See http://www.jetbrains.com/idea/opensource/ for details.

I already own a current license for IntelliJ IDEA and that license allows me to do whatever development I like (personal, commercial, open source, whatever). I can even install that license on as many machines as I like as long as I am the only person using them. Contrast that with the more limited open source license which is only allowed to be used for open source development and may be limited further to only being used on development of open source projects that the guys at IntelliJ approve. I am not exactly sure about that last part, but the license is limited to open source work. Anyway, because I already own a less restrictive license, the free license doesn't really buy me anything, but I wanted to participate in their program, so I submitted a request based on my involvement with JarSpy. Shortly after sending the request I got an email response letting me know that they have received lots of requests and that each one needs to be evaluated individually and that will be time consuming. I wasn't too worried about it so I saved the email and went on with my business.

Fast forward to today. Today I received an email from them letting me know that they have approved my request and are issuing me a free license. Whooo Hoo! In a way, this is of absolutely no consequence whatsoever. In another way, I am still glad that they are extending this offer and that they are not being overly restrictive about it.

I hope that this helps IntelliJ IDEA continue to grow in its popularity and subsequently leads to its continued life of innovation.

JDO 2.0 Has Been Approved!

2005-03-01T11:01:00.000-06:00

I am pleased to report that JDO 2.0 has been approved! This is great news for the JDO community. The initial public review ballot was voted down back in January with a vote of 10 against, 5 for and 1 abstainer. The reconsideration ballot passed with a vote of 0 against, 12 for, 1 no vote and 3 abstainers.

I don't think this vote hurts the JSR 220 effort but I think it does a lot of good for JDO users and JDO vendors.

Free IntelliJ IDEA License

2005-02-08T10:04:00.000-06:00

The guys at IntelliJ are giving away free licenses for IDEA to open source projects. I haven't read all of the details, but at a glance this looks awesome.

Details available here.

Bad News For JDO

2005-01-19T20:20:00.000-06:00

I am very disappointed to see the results of the JSR 243 public review ballot. I believe this means that the Expert Group has 30 days to submit an updated draft for a revote. If a revised draft is not submitted in that timeframe or if the revote fails, the JSR will be closed. If anyone thinks that is not correct, please share what you understand about the process.

I knew that JSR 220 was eventually going to succeed JDO 2.0 but as I understand it, there won't be anything "real" coming from JSR 220 until 2006.

Given the vote count and some of the comments submitted by the voters, it doesn't to me look very likely that the draft will be revised in such a way to change voter's minds. I think that if the vote is going to turn around it would have to be in response to community feedback but I don't know how much of that there will be.

I really am disappointed in this whole thing. ;(

Someone say it ain't so...

Already I am seeing talk of org.jdo.* popping up.

JarSpy Plugin For IntelliJ

2005-01-11T20:44:00.000-06:00

Tonight I was looking for the IntelliJ Plugin Wiki but I couldn't remember the url so I did the obvious; I put "intellij plugin" into google. To my surprise, the first link in the search results referred to my JarSpy Plugin For IntelliJ. I can't say that I had forgotten ever having written that, but I can say that I haven't had any reason to think about it for a long time. A couple of years ago I got an email from one of the billions of JarSpy fans out there and the email was asking me for a JarSpy plugin for IntelliJ. I was an IntelliJ user at the time (I still am) and I was interested in taking a look at their plugin API so I went at it. It didn't take long to write the plugin (although I do remember wishing there was better documentation for their API, maybe that has improved since then).

JarSpy has turned out to be one of those little things that continues to popup for me from time to time. Just a couple of weeks ago at my regular poker game one of my friends, who I had never had any reason to discuss JarSpy with, said something like "hey, I was using JarSpy today and...".

It has probably been more than a year since I made any code changes to JarSpy. I have some interesting ideas that I would like to add. Maybe I will get some time to play with that soon.

Ant Docbook Styler Suite

2004-12-30T21:45:00.000-06:00

If you do any publishing with Docbook you should take a look at the Ant and Docbook Styler Suite. I recently stumbled across that and have so far been very impressed. Installation is as simple as executing a target in the build file provided with the distribution and using the library is as simple as adding a task in your Ant build file to execute a target in their build file. You have to provide a handful of property values so their task knows where to find your docbook source, what to generate, etc. but it really is a snap to use. Their 3 or 4 page instructions (included in the distribution of course) are very clear and got me up and running within 10 minutes or so.

I have looked at other Ant + Docbook solutions and they are all a wirey mess of dependencies and you have to download Docbook stylesheets separately and plugging in FO support is another twisted mess, and on and on. The Styler Suite was much much simpler and seems to do a very nice job.

If you are a docbook author but not a Java developer, this may turn out being more headache than it is worth but if you already have Ant and Java installed, using this is a cinch.

Thanks to Dawid Weiss for the slick tool!

Code Cracker Lives On

2004-12-30T13:20:00.000-06:00

I bought my first Palm Pilot back when the Palm IV series first came out. I think it was 1998. Soon after I bought the device I was interested in writing software to run on the thing. I picked up a copy of OReilly's Palm Programming: The Developer's Guide, and I was on the ground running. I remember spending a weekend just playing around with the API and I built a very simple little game that played like the old MasterMind game that most of us played as a kid. It wasn't that I wanted to write a MasterMind game, that was just something simple that I could use to help learn the PalmOS API. I expected to just throw the thing away when I was done but I found myself enjoying playing the game when I had a minute or 2 to kill (like standing around in front of the microwave at work waiting for my lunch to cook) so I held on to it. I gave the application a proper name, CodeCracker, created a very simple web page that explained a little about the game and I put it on my personal web site and made the game available for download. I remember being surprised at how many people found the page and even more surprised at how many people bothered to take time to send a thank you note to me. A couple of years later I was cleaning up a hard drive and stumbled across the source code. I decided to put the source code on SourceForge for safe keeping and it has been there ever since.

Just today I received an email from a guy in Italy saying thanks for the game and offering some suggestions for how to improve the game.

I spent a weekend 6 or 7 years ago playing around with writing something for the PalmOS and a very simple game evolved. It is sort of interesting how these little things linger on.

CodeCracker Lives On! ;)

Hostility Directed At Prevayler

2004-12-27T10:35:00.000-06:00

Prevayler seems to be getting a lot of blog attention all of a sudden. I don't know what kicked off the spike in attention, but something seems to have done just that.

Prevayler is yet another framework for POJO persistence. What makes Prevayler unique is the fact that it takes an approach that your entire data model is in memory all of the time. Because it is always reading from RAM, performance benefits are touted as high as 9000 times faster than Oracle and 3000 times faster than MySQL (I won't go into all of the details behind those numbers, see their site for more details). One of the costs of this approach is directly related to RAM limitations. If everything is loaded into RAM all of the time then the amount of RAM is an obvious potential road block.

Some of the blogging rants I have seen go to great lengths to elaborate on the flaws of this approach. This guy rants with some hostility for several pages about Prevayler's shortcomings while this guy seems to take a more calm pragmattic look. Some of the attacks I have read are really pointed at the idea that Prevayler is a ridiculous idea that could never replace our relational databases. I don't think Prevayler is proposing that they are really a threat to Oracle or any other DB vendor. I think they are proposing a solution that makes sense for some systems but not all. I don't know if they are right or not, but I think that is what they are proposing.

I am not a Prevayler proponent and I am not taking a position to defend Prevayler. I have played around with their tool a little and it is interesting but I am really not a Prevayler evangalist. What I find interesting about the attacks on Prevayler is that a lot of them seem to be very passionate and fired up. If Prevayler was really a totally insane ridiculous idea I don't think anyone would even pay attention. Maybe this is just another manifestation of the idea of how emotionally connected Enterprises (that means people) get to their databases and even the idea that it might not be right is enough to launch the missiles.

Naughty Or Nice?

2004-12-25T01:59:00.000-06:00

Apparently, this guy sold his kids' Christmas presents on eBay because the kids were naughty. My wife and I sometimes joke about selling our boys on eBay when they misbehave (that is right, the boys... not their toys.). I never considered selling their stuff. ;)

As I type this post I am looking out over a sea of toys and schtuff all wrapped up and spread around our family room. In about 6 hours from now I expect a certain 7 year old boy to be jumping up and down on my bed yelling something about Santa Clause having been in our house. I better get to bed.

Happy Holidays To All!

JDO 2.0

2004-12-19T21:10:00.000-06:00

The Public Draft of JSR-243 is available for download at http://jcp.org/en/jsr/detail?id=243. This JSR is defining the JDO 2.0 spec.

There is a lot of new and cool stuff being proposed for 2.0. One item in particular that I am interested in is the whole detachment idea. The idea is that we would be able to detach a persistent object from the data store, modify the object and then later re-attach that object and commit the changes. The changes could be commited by a different PersistenceManager and could even be committed in an entirely different VM.

Another nicety proposed for 2.0 is the formalization of O/R metadata for defining indexes, foreign keys and constraints. Some JDO implementations already support this sort of thing via vendor extensions in the meta data. ObjectDB uses this approach. Other implementations suggest that you let their tool create the tables and columns and then you go in after the fact and define your indexes, constraints etc. in the database yourself. TJDO takes this approach. It will be nice to have this formalized in the metadata for portability.

J2SE 6.0 Snapshots Available

2004-12-16T15:32:00.000-06:00

I just noticed that it looks like J2SE 6.0 snapshot releases are being made available at https://j2se.dev.java.net/. Have I finished upgrading to J2SE 5.0 yet??? ;)

What Is Wrong With Our Web Apps?

2004-12-10T09:50:00.000-06:00

Last night Rob Smith gave a great presentation on Tapestry at the St. Louis Java SIG. I liked a lot of the things that I learned about Tapestry but as I listened and learned I was thinking about what sorts of problems does Tapestry really solve for me. Then I started thinking about how that relates to many other web app frameworks that are out there. Just off the top of my head without spending too much time thinking about it or Googling or anything like that, I came up with this list of tools that help us build web apps...

Servlet

Java Server Faces

Velocity

Tapestry

Struts

Spring

Tiles

Several of those can be thought of as being direct competitors of each other.

These technologies all try to help improve our web apps by making it easy to do things like separate the presentation layer from the data. Some provide tools to help with state management. Some help with scalability. Those are all important things to address and sometimes are difficult to address. If the tools can help solve those problems that is a good thing of course.

Web apps are hard to build. Few would still entertain fantasies about some magic web tool that solves all of the Enterprise's problems, is easy for everyone in the Enterprise to use and doesn't call for much development time. We all know that can't happen. If we didn't know that in the beginning, we know it now.

I believe that a lot of things are well suited as web apps and for the purposes of this conversation I am using the term "web app" to mean an application that uses a web browser as its primary front end. However, I am wondering if a lot of us are spending a lot of time and effort (that sounds like money to me) building web apps that really shouldn't be web apps. At last year's No Fluff Just Stuff Java Symposium in St. Louis I remember a comment that Bob Lee made during one of the expert panels. Bob said something very close to "Can we all just agree to stop building browser based apps?".

I don't think that web apps are bad. I think a lot of things work very well as web apps. In addition, as a Software Engineer I find working with a lot of the web app frameworks to be a lot of fun. I am just wondering if we are collectively trying to push pegs into the wrong shaped holes too often.

More and more I am feeling like we really need a fundamentally different (and better) way to build distributed systems. I can't exactly put my finger on it, but somewhow I feel like we are solving a lot of the wrong problems and that in 6 months or 6 years or however long it takes us to come up with this next generation of ideas we are going to look back and wonder how we ever managed to operate our businesses any other way.

What do you think about any of that? Let me throw out some specific questions for thought.

What problems do you have in building web apps that are not solved very well by the existing frameworks?

What types of projects have you been involved with that were architected as web apps that should not have been and what made them poor candidates to be built as a web app?

What types of projects have you been involved in that were not architected as web apps that should have been and what made them so well suited to be web apps?

What do you think is next?