In order to quickly emulate the same data structure, I was forced to push a bunch of single-element maps into a list! Yuck!

def cars = []
cars << ['Ford':'Taurus'] << ['Ford':'Focus'] << ['Ford':'Mustang']
cars << ['Chevrolet':'Malibu'] << ['Chevrolet':'Impala'] << ['Chevrolet':'Corvette']
cars << ['Dodge':'Charger'] << ['Dodge':'Avenger'] << ['Dodge':'Viper']

But at least I have something I can work with now, albeit not the optimal collection that MultiMap would have provided in this case.

def printModels = { make, pair ->
    if (pair.any{it.key == make})
        println "$make makes ${(pair.values() as List)[0]}"
    make
}
def printMake = { model, pair ->
    if (pair.any{it.value == model})
        println "$model is made by ${(pair.keySet() as List)[0]}"
    model
}
cars.inject('Ford', printModels)
cars.inject('Chevrolet', printModels)
cars.inject('Dodge', printModels)
cars.inject('Impala', printMake)

All the work is done in the closures. If I had the MultiMap’s capabilities, I could have created a map that would store multiple values for each key (see Dan’s initial volley), and I could have just called get() to retrieve a set of those values. But my groovy closures are looking specifically for either the key or value in the list of single-element maps. The closures are meant to be used with the inject method of groovy collections. The first printModels closure expects the make to be injected into it, and then compares it to each map key to find whether the current pair should be printed out. The printMakes closure expects the model to be passed, comparing it to the pair values.

I was disappointed to find out that groovy’s map implementation had no inverse operation. In java, this is not possible, because a key can have only one value, and if you try to inverse, you might possibly have a key with many values, breaking java into tiny pieces. Because the MultiMap allows keys to have multiple values, there is no danger in inversing the positions of keys and values, which is very handy (again, see how Dan used it)

The calls to inject actually execute the closures that print out the strings. The first three print out the models for each make injected into the closure, and the last one injects a model and prints out its make.

So there are some pluses, some minuses to using groovy for this sort of problem. On one hand, my total lines of code are still under 20, which is less than Dan’s example. However, I’m using a Frankensteined collection (a list of single-element maps). Can we get the best of both worlds somehow?

So let’s add Google’s Collections package as see if we can use it with groovy to make our code nicer!

import com.google.common.collect.*

def cars = Multimaps.newHashMultimap()
cars.put('Ford','Taurus')

Ok… let’s stop right there. The groovy programmer in me really wanted to add to the map using cars.’Ford’ = ‘Taurus’, but no dice. This isn’t a groovy map, it is a google map, so I’ve lost all my groovy functionality, which isn’t very groovy. And my script from this point on is going to look suspiciously like Dan’s java program. So what is the point of this experiment? Well, it lets me know that if I run into a situation where I’ll need the functionality of a MultiMap, I can easily import the google jar and whip out an inverse-able MultiMap collection. Only, I won’t be able to use all the sugary groovy syntax with it. It is still better to have the option.

In summary, I think the google java collections package is downright cool. Anything that makes programming simpler and easier is good for our business. Groovy is great, but if I were working in java today, I would love this package. Hell, I might even want to use it with groovy someday. Thanks to Dan Lewis for participating in my challenge and being a good sport.

def boys = ['Paco', 'Sven', 'Roger', 'Emelio']
def girls = ['Julia', 'Prudence', 'Lucy']

Now we have two simple lists, one of boys and one of girls. So what if these are all dancers, and we’d like to know all the combinations of dancers there could be? With groovy, this is extremely easy.

def combos = [boys, girls].combinations()

Could it be any easier? This creates a list of lists, each inner list containing a possible combination:

Now it would be nice if i could split the list up in some way, maybe keying by male or female. Groovy’s groupBy collection method is an easy way to do this. In the closure you provide, you simple return the key that you want to group the collection by, and it will return a map with that key pointing to a list of values. In the following example, because I know the first element of each combination is the boy and the second is the girl, I just specify a key by element position.

def groupedByBoys = combos.groupBy { it[0] }
def groupedByGirls = combos.groupBy { it[1] }

Which returns these two groupings:

Beat that, Google Collections!

Let’s get a sample model and some data first, then we’ll get to the fun and easy Grooviness…

class RockStar {
    def name
    def bands
    def numberOfGroupies
}

def mike = new RockStar(name:"Mike Patton",
                bands:["Faith No More","Mr. Bungle"],
                numberOfGroupies:2214)
def bono = new RockStar(name:"Bono",
                bands:["U2"],
                numberOfGroupies:543582)
def slash = new RockStar(name:"Saul Hudson",
                bands:["Guns N Roses", "Velvet Revolver"],
                numberOfGroupies:32544)
def scott = new RockStar(name:"Scott Weiland",
                bands:["Stone Temple Pilots", "Velvet Revolver"],
                numberOfGroupies:41880)

def rockStarList = [mike, bono, slash, scott]

As you can see, I have created a simple POGO class, loaded some beans, then tossed them into a simple list.

Now what? Well, maybe we need to make a list of all the bands our rock stars are a part of, or better yet, a set. We don’t want the same band listed twice now! So what is the easiest way to make this happen? Let me introduce you to a very useful method in your Groovy toolbox, collect.

Set allBands = rockStarList.collect { rockStar ->
    rockStar.bands
}

The closure you pass to the collect method is used to transform that list item into whatever you want. In this case, I’m taking a list of RockStars and transforming it into a set of string lists, containing band names. When you run this, you will get a Set that contains the Lists within the objects. This is really useful when you have a list of domain classes that you don’t really need, but you need to get at some information inside each of them.

But this is still no good! We want a List of Strings that contain band names, not a List of Lists! But wait! Groovy makes this dead-easy to fix:

Set allBands = rockStarList.collect { rockStar ->
    rockStar.bands
}.flatten()

Using the flatten list method does exactly what we want. It takes all the collections within the top-level collection and adds them recursively to the top-level collection, effectively flattening them all out into one collection.

Perfect. But you want to know the total number of groupies for every rock star? No problem.

def totalGroupies = rockStarList.collect {
    it.numberOfGroupies
}.sum()

Before we call the sum() method, our closure returns a List containing Integer objects. If you call sum() on a list of any objects, this effectively calls the “plus()” method on each of the objects. Because the list is loaded with Integer objects, these all add up nicely.

And there you go:

There will be 620,220 groupies at the show.

Not so much with groovy.

def smallList = [1,3,5]
def bigList = [1,1,1,2,3,4,4,4,5,6,7,7,8,9]

def result = bigList - smallList
println result.class
println result

The result is:

class java.util.ArrayList
[2, 4, 4, 4, 6, 7, 7, 8, 9]

Groovy correctly made the assumption that I was making a List in my snippet above. And it removed any element within the first list where equals() was true for an element in the first list. That means it took away three 1’s and one 3. Keep in mind the original collections are untouched.

But what if I want to compare a List and a Set?

Set mySet = [1,3,5]

List myList = [0,1,2,3,4,0,1,2,3,4,5,6,7,8,9]

def addition = myList + mySet
println addition.class
println addition

addition = mySet + myList
println addition.class
println addition

Now we’re adding a List and a Set together, and the result is different depending on which is the first operand:

class java.util.ArrayList
[0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 3, 5]
class java.util.HashSet
[2, 4, 9, 8, 6, 1, 3, 7, 5, 0]

If the List is the first operand, groovy assumes you want to treat the following operand as a List as well, and it just tacks the values onto the end. But when the Set is first, groovy first converts the second argument into a Set as well before doing its addition. This removes all but unique elements from it before performing the addition.

Set mySet = [1,3,5]

List myList = [0,1,2,3,4,0,1,2,3,4,5,6,7,8,9]

def subtraction = myList - mySet
println subtraction.class
println subtraction

subtraction = mySet - myList
println subtraction.class
println subtraction

We should again see the automatic type conversion as in the above examples depending on which type is the first operand. In the results below, you can see that all elements within the set were removed from the list (there are no 1’s, 3’s, or 5’s). The second subtraction results in 0 elements, because the List (which is converted to a Set) being subtracted contains 1, 3, and 5, so all are removed from the original Set.

class java.util.ArrayList
[0, 2, 4, 0, 2, 4, 6, 7, 8, 9]
class java.util.HashSet
[]

Good stuff. This is just another example of how groovy does away with a lot of the annoying things you have to do with java.

I was thinking of “Focal Points” as any inputs into a system. For humans, they would be our senses, but for a computer system, it could be any number of inputs. My main point was that intelligence is all about near-instantaneous pattern recognition, and the way our neocortex stores our memories allows our unconscious mind to be touching millions of stored patterns at once. Someday we’ll be able to replicate this storage/retrieval algorithm, enabling a processor to have data access to many data locations at once. That is the way our brain works. There are multiple parallel asynchronous retrievals occurring, yet slower than a computer processor retrieves data synchronously. But this benefits pattern recognition greatly because of the breadth of incoming data.

This is what happens when you read The Singularity is Near and On Intelligence simultaneously. I continue to have a deep fascination for the human brain and software, and I believe that we will eventually crack the intelligence algorithm. I just wish I had more time to pursue such trivial pursuits. But the individual development of my children’s brains is more important than working toward the singularity at this point in my life.

This week I’m attending Brian Button’s course on Test Driven Development. As someone who has considered himself an agile programmer for a while now, I’m finding myself more and more enlightened by the core techniques of Martin Fowler’s book, Refactoring. It is one of the texts of this course, and I can’t believe I’ve been coding without this book for so long.

At almost every job I’ve worked here in St. Louis, I’ve seen this book on someone’s desk or in a library area, but I’ve never bothered to pick it up. But after this course, it will be a staple of my (annoyingly ostentatious) desktop bookshelf.

Now to pop up a new Outlook email message, it’s as easy as typing “Alt-Space newmail”.

Finding new uses for Launchy is wonderful.

A Simple Example

I have a Beer object that corresponds directly to a BEER table in a database. The Beer object can wither be an “Ale” or a “Lager”, and there may be more types in the future. So the database schema looks like this:

+--------------------+
| BEER               |
+--------------------+           +----------------+
| NUMBER  | ID       |           | BEER_TYPE      |
| VARCHAR | BRAND    |           +----------------+
| NUMBER  | TYPE     | FK------- | NUMBER  | ID   |
| NUMBER  | VOLUME   |           | VARCHAR | NAME |
+--------------------+           +----------------+

It is pretty straightforward how to create a java class to represent this data. Ideally, I would like to use a java 5 enum object to keep track of the beer type, so I use it within my data object to specify type:

public class Beer {
    private BeerType type;
    private String brand;
    private double volume;

    public BeerType getType() {
        return type;
    }

    public void setType(BeerType type) {
        this.type = type;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public double getVolume() {
        return volume;
    }

    public void setVolume(double volume) {
        this.volume = volume;
    }
}

The BeerType enum will simply specify the type of beer for each Beer object. This enum is going to map directly to the BEER_TYPE table. So I’ve given each beer type its own id through the private internal enum constructor. There is an accessor method for hibernate to retrieve the id when it needs to do the mapping.

One of the first things I found when I started searching the internet for ways to map Java 5 enums to a database using Hibernate was this article on the Hibernate page. It shows an implementation of the Hibernate UserType in a way that will allow an enum to be used within a hibernate key mapping. So if I create a custom type definition in the key-mapping that uses the GenericEnumUserType class as the class, and passes in the actual BeerType enum classpath as a parameter, I can do the work to break out the enum details in the GenericEnumUserType implementation.

<hibernate-mapping>
    <typedef class="net.dangertree.GenericEnumUserType" name="beerType">
        <param name="enumClassName">net.dangertree.BeerType</param>
        <param name="identifierMethod">getId</param>
    </typedef>

    <class name="net.dangertree.Beer" table="BEER">
        <id name="id" type="int" column="ID">
            <generator class="native"/>
        </id>
        <property name="type" type="beerType" column="TYPE"/>
        <property name="brand" type="string" column="BRAND"/>
        <property name="volumn" type="double" column="VOLUME"/>
    </class>
</hibernate-mapping>

Here is the full code for the GenericEnumUserType class that I used to help map my enums into Hibernate. Reflection is used to find an “identifier” method in the enum that will get the id for each value. I have specified in the type-def in my key mapping that I’m going to use the getId() method of my enum to get an identifying attribute. By default, the class will look for the inherent name method of enum, but I’m using ids as my identifier.

The two method objects are grabbed and saved, then called in the null-safe setter and getter deeper within the Hibernate workings.

Ok, there is only one problem now. The DEFAULT_VALUE_OF_METHOD_NAME method is specified by default to be valueOf, and I have not provided a parameter to override that in the type-def. So in order for my enum to match this, I need to add a valueOf method to my enum. And when the nullSafeGet method calls the “valueOfMethod“, it sends it an identifier as a parameter, so our valueOf method needs to take an int id as a parameter.

Now I have my data object, the enum it is using, my key-mapping, and an implementation of UserType that provides a way to access the enum through a type-def element in the key-mapping.

It’s all working for me now! Does anyone have any questions or comments? This is the very first time that I have interacted with hibernate, so I’m a little bit shaky with the details (especially the UserType implementation).

Edit: correction of mapping file pointed out by commenters.

Changing jobs

I like the feeling of being an independent in this field right now, so I haven’t attached myself solely to one employment agency. In fact, of the three jobs I have taken in the St. Louis area, they have all been through different agencies. I’m sure that this has frustrated some of the recruiters in ways, but I’m still fulfilling my part of the deal and making them money.

My last position was really nice, but I was not in a place to get the experience I needed to further my career. So I started another job at Monsanto about a month ago. This job is very, very different than the previous one. I can’t say “better” or “worse” at this point, but definitely different. It will be harder, that’s for sure.

Having kids

My wife and I recently had our 2nd child, and I am have just finished two weeks of vacation to stay home and help out around the house while we adjust to this change. It has been really nice, and I’ve been spending a lot of my free time helping to take care of our new baby girl. Everything is going great with the baby, and our family feels like it’s filling out.

Moonlighting

Tripos, the first company I worked for in St. Louis after leaving the defense industry, recently contacted me to moonlight with them in my off-hours. So I have been working directly for them under a 1099, providing around 10 hours a week to support the same project I was working on there before. So far, it has been a really nice experience, although my time management skills are in constant need of sharpening.

So you might not expect me to update my blog very regularly for a little while. I just have a lot of stuff going on in different areas of my life right now. Thanks to all of you who are keeping up with me.