CoffeaElectronica

Searching for a New Format

2011-12-19T12:07:00.001-06:00

I have not posted in a while. I have been pretty busy in my work and personal life with little time left over to document and blog. Also, I have run into a bit of an issue. I am not sure the blog format really works for me any more. As I have been going back through my old posts trying to bring them over into this new blog I have found quite a few things that I would do differently or not at all. I need to decide whether I want to keep historical and potentially out-dated content around, or to bring it up to date and keep it fresh. I like the idea of having content that may span versions of a product/API, but not when it does not make sense to do so.

I have toyed with the idea of a monthly format or just a free always up-to-date ebook or a wiki, but I am not sure which way I want to go at this point. My goal is to have more time, and a new direction ready to go after the first of the year.

Enjoy the holidays!

Home Server v2

2011-10-15T12:07:00.000-05:00

Since my last home server was fried by a lightning storm a few months back, I have been serverless, which is an uncomfortable position for a server software developer. I did some good research and decided to try and put together a new box from scratch. My previous server was just a converted "retired" desktop box I had so this would be a fun project.

Lifehacker put out a timely series of articles about how to build your own computer. It was an awesome introduction for someone like myself who had never done more than swap out some RAM or a hard drive. If you are a computer-build noob (like me), I would highly recommend giving the series a read (How to Build a Computer from Scrath: A Complete Guide) if you are thinking of putting together your own box.

For my home server I had only a few requirements:

Low power consumption - this is running at home, I don't want to overly-inflate my electrical bill.
Low price - this is a home server box for my projects and some helpful apps for my wife, it needs to be cheap.
Room to grow - something with some upgrade room would be nice

What I was able to put together fit all those criteria nicely:

LIAN LI PC-A05NA Silver Aluminum ATX Mini Tower Computer Case - I had originally found a cheaper, smaller case; however, the Lifehacker article recommends some brands over others so I spent a few dollars more and I feel that it was worth it. The case has a lot of room for what I have and may want to add in the future. It also has great cooling and even looks nice.
Antec EarthWatts EA-500D Green 500W ATX12V v2.3 / EPS12V 80 PLUS BRONZE Certified Active PFC Power Supply - Again, I had a cheaper one picked out but deferred to a Lifehacker-recommended brand. It's also a "green" model with greater power efficiency and enough available power to allow for future growth.
Intel BOXD525MW Intel Atom D525@ 1.8GHz (Dual Core) BGA559 Intel NM10 Mini ITX Motherboard/CPU Combo - I decided to start with an Intel motherboard with an Atom processor for low power usage and I think it should be enough processor power for my needs (1.8 GHz dual core 64-bit)
Kingston ValueRAM 4GB (2 x 2GB) 204-Pin DDR3 SO-DIMM DDR3 1066 (PC3 8500) Laptop Memory Model KVR1066D3SOK2/4GR - The supported max is 4GB, I bought 4GB.
Western Digital Caviar Blue WD800AAJS 80GB 7200 RPM 8MB Cache SATA 3.0Gb/s 3.5" Internal Hard Drive -Bare Drive - Your standard Western Digital in the smallest size that I could find (80GB) without going into something too old. My storage requirements are small. I had originally wanted to get a SSD but that would have blown the cost up too much.
No optical drive, sound card, video card or network card; the latter three all being integrated on the motherboard, the optical drive was not necessary for a server like this.

I bought everything from NewEgg for a grand total (with extra warranty and shipping) out of pocket of a hair over $300. Not bad at all considering everything I looked at "off the rack" was at least $400, and usually had more or less than what I actually wanted. Maybe someone with more experience building systems could do better since there are probably areas I could have cut corners on where I played it safe.

Boxes of parts.

Once all the parts came in (the following week, damn they ship fast), I put everything together with the help of the Lifehacker articles. With a little help and guidance it was actually a pretty easy and mostly straight-forward process that took about three hours. Once everything was secured and wired together, I fired it up for the first time and was able to get into the BIOS; however, my hard drive was not being recognized. After trying different cables and then trying the drive in my desktop computer the only thing I can figure is that the drive was dead on arrival, great quality control WD! I ran out to BestBuy and bought another of the same drive (well the same brand but larger size) for basically the same price to test my theory and I was correct. Once the new drive was in place everything worked fine. I returned the dead drive to NewEgg and have gotten my refund with no problems.

Secured and wired up.

Next, I moved on to the OS. My server OS of choice is Ubuntu so I downloaded the 64-bit version of Ubuntu 11.04 and followed the instructions to create a USB installer... I have no optical drive, remember. It was down right simple and it booted from the stick with no problem and installed, as always, like a dream.

From there I basically followed along with my previous post to install my shared directories and the applications I wanted. It's been nice having a server up and running again.

I think in a couple years when it's time to upgrade my desktop, I will do a custom build. It's kind of fun and you get exactly what you want.

Determining Overlap Across Multiple Variables

2011-09-05T11:31:00.000-05:00

I have run into two cases now where I have needed to validate that no overlap exists for data across three axes of comparison, each with potentially large value-spaces containing single values and/or ranges of values. An example of such a comparison could be something like a filter rule used to find People based on demographic data.

Say we have a search rule to find males between 15 and 25 years old who weigh 200 to 300 pounds. You could have something like:

People A
Ages: 15-25
Gender: M
Weight: 200-300

Now consider the case when you have other search rules in the same search and that for the sake of efficiency we want to find overlapping rules and merge them into one (we will only consider the overlap determination here). With two other rules:

People B
Ages: 13-20
Gender: M
Weight: 250-400

People C
Ages: 8-10
Gender: M
Weight: 200-300

It's not hard to look at the rules and determine which ones overlap. "People A" overlaps with "People B", while "People C" does not overlap with either of the other two. Programmatically this can be a difficult comparison to do correctly and efficiently. Also, as your number of comparison axes increases, so does the complexity of determining overlap for any given pair of objects.

What is needed is a simple means of determining the overlap of two objects and the best way I have found to do that is to break each object down into its overlap-comparison components, each of which I will call a "Lobe" from here on out. I chose the term lobe because it is defined as:

"any rounded projection forming part of a larger structure"

Also, terms like element and node are used far too much already in programming.

When you break each object down into it's lobes, you will have one lobe for Gender, one for Ages, and one for weights. Now you can build your overlap determination based on whether or not each lobe overlaps with its corresponding lobe on the other object. If all of the lobes overlap those of the other object, then the two objects are considered overlapping, otherwise they are not. This allows for a fail-fast comparison since if the comparison of any given lobe fails, you cannot have an overlapping object and no further comparison is necessary.

Programmatically a lobe can be defined by interface as:

interface Lobe {
    boolean overlaps( Lobe other )
}

Each lobe implementation defines what it means to overlap another Lobe of the same type. Using Groovy and some generic logic we can easily come up with a ComparableLobe which is based on single values and ranges of Comparable objects such as numbers, strings and ranges. This allows us to do things like:

new ComparableLobe( 10..20, 50, 75 )
new ComparableLobe( 'a', 'h'..'j', 'm' )

lobeA.overlaps( lobeB )

which can make the overlap determination very flexible.

Note: All of the source code from this article is available in my GitHub repo called Overlap.

Now we can create Lobes for each of the overlap-comparable parts of our People, using "People A" as an example:

def genderLobe = new ComparableLobe( 'M' )
def agesLobe = new ComparableLobe( 15..25 )
def weightsLobe = new ComparableLobe( 200..300 )

The next thing we need is a way of comparing these lobes in a simple and repeatable manner and that's where the Overlappable interface comes in:

interface Overlappable {
    boolean overlaps ( Overlappable other )
}

The Overlappable interface defines an object that can be compared for overlap. The required method is basically the same as that of the Lobe; however, this interface is for the parent object itself. By providing an abstract implementation of this interface we have a nice clean way of providing overlap detection functionality for an object type. The AbstractOverlappable provides an implementation of the overlaps() method using the OverlapBuilder, which we will talk about in a minute. What the abstract class also provides is a simple way of emitting the Lobes for the given object in a simple manner, as an array. You can use this with our example above to create a simple Overlappable Person object:

class People extends AbstractOverlappable {
    String gender
    IntRange ages
    IntRange weights
	
    @Override
    Lobe[] lobes() {
        [
            new ComparableLobe(gender), 
            new ComparableLobe(ages), 
            new ComparableLobe(weights) 
        ]
    }
}

The overlaps() method uses the provided Lobes to popualte an OverlapBuilder, which is basically a helper class for performing the actual Lobe-to-Lobe comparison of a given set of Lobes. The OverlapBuilder is inspired by the builder in the Apache Commons - Lang API, such as EqualsBuilder and HashCodeBuilder. You create an instance and append your Lobes to it, then execute the overlap() method to perform the comparison.

new OverlapBuilder()
    .appendLobe(new ComparableLobe(1..10), new ComparableLobe(5..15))
    .overlap()

It also provides an append method for simple comparable cases:

overlapBuilder.appendComparable( 20..25, 15..30 )

which just wraps each value in a ComparableLobe. Now, given a list of People objects, you can determine if any of them overlap any of the others simply by iterating over the list and comparing each element with the others:

def list = [
    new Person( gender:'M', ages:15..25, weights:200..300 ),
    new Person( gender:'M', ages:13..20, weights:250..400 ),
    new Person( gender:'M', ages:8..10, weights:200..300 )
]

list[0..-2].eachWithIndex { self, idx->
    list[(idx+1)..(-1)].each { other->
        if( self.overlaps( other ) ){
            println "$self overlaps $other"
        }
    }
}

As a final little bonus feature, I have added a ComparableLobe.ANY object which denotes a Lobe that will always be considered to overlap, no matter what the other value is.

This kind of multi-variable overlap-checking scenario may not come up all that often, but when it does, it can give you a lot of grief, especially if the fields being compared are numerous and complex. I have had to create a couple additional Lobe implementations but am also using the ComparableLobe quite a bit. This library has been a real time-saver. And, once broken down into component parts, the overlap determination becomes simple to implement and test, which makes it much more stable over time.

I Want My GoogleTV...

2011-08-01T08:33:00.001-05:00

...to be usable.

A few months ago my wife and I purchased a Logitech Revue (Google TV) mainly for my wife, since she has medical issues that make it difficult for her to use a desktop or laptop computer.

Overall, it's a great product. It provides a much better interface for watching web video content. You can surf the web with a full version of Chrome (with flash) and you can run various apps, which soon will be augmented by the Android Market (supposedly coming this year).

The downside comes in when you start finding the holes in the product. My wife wants to be able to view our photos and then share them on facebook or email them. We have our photos on a DLNA-enabled NAS so it should be easy. The Media Player app was able to see the server but was never able to get the content. Unable to find any error information or details we decided to try just putting our photos on PicasaWeb and then viewing them through the Gallery app.

The Gallery App worked for viewing and it did it quite nicely, very similar to the Gallery app found on Android phones. The problem we had was that when you try to "share" a photo, you have only one option, Twitter. My wife is not on Twitter, has no friends on Twitter and does not really want to sign up. This was my first WTF moment with GoogleTV. The second was when I realized that the depth of the problem. There is no Facebook app, there is no GMail app, there are very few apps at all. As it stands, it is a very anti-social product.

Putting that problem aside, I thought well, she could share photos with Facebook via PicasaWeb. Wrong. PicasaWeb only shares via email.

Okay, Facebook might have a work-around for the problem. We tried to share a photo from Facebook (web) and they have no "Upload photo via URL" so the best she could do is share a link to the photo on PicasaWeb.

My wife, who is not a techie, found this all very frustrating and annoying, while I was very disappointed in Google's release of an unfinished product. These Google TV units have been out for a couple years now, they really should have better apps and more social interaction available by default. I know that Google keeps stating that the Android Market will be available soon, but they need to start giving more details before the users give up and sell the unit.

My wife's other main complaint was that it seems to expect too much from the user; basically, if she didn't have me she would be lost. There are a few tutorials that she has found, but she had to dig around for them.

Overall, it's a great product and we love it and the entertainment that it has opened up for us, but there are some really frustrating points that need to be addressed. I will say though, that if the Android Market update does not address these issues and start polishing up the system, Google TV will be nothing more than a niche product like its WebTV ancestor, and that would be really sad.

A Groovy Year

2011-07-09T09:05:00.001-05:00

It's been just over a year now that I have been working full time with Groovy and Grails so I figured it was a good time for a retrospective. I will go over general thoughts and lessons learned here and then I plan on covering some of the topics in greater detail in separate postings.

In the company I work for we do all of our web application development work using Grails, which is all done using Groovy. We also have quite a few external projects that feed into our Grails applications; these are written mostly in Groovy and Java. Ask three different developers in the company how they feel about our technology choices and you will get three different answers. Personally, these technologies are perfectly suited for what we are doing, but there are always pros and cons with any environment and that's what I want to address here.

Groovy

Groovy is a great language. Its flexible, expressive and concise. It really does wipe away all the development fluff and leave you to do actual coding work.

The problem with Groovy is that it is deceptively simple and at times too "magic" for under-skilled developers. It has no real compile time checking, limited analysis tools and IDE support can be spotty depending on which one you are working with. In the hands of a less-seasoned developer Groovy can lead to a free-for-all of odd constructs and bad coding practices that can be difficult to refactor away. Refactoring in Groovy can be a painful undertaking due to its dynamic nature and limited IDE support.

Some suggestions I have for a team starting out with Groovy:

Unit testing is a requirement as are higher coverage targets, and I mean like 90-100% coverage. Since you don't have any compile-time checking and its very easy to have hidden runtime issues with Groovy, you need to enforce a high level of unit testing and unit test coverage.
Coding standards should be determined and enforced. Just because Groovy will let you do something doesn't mean you should do it.
Code reviews. With Groovy, especially starting out, you should do code reviews on pretty much everything you check in. Code reviews are always a good practice, but even more so when starting out with a dynamic language. The more eyes looking at the code, the better. This also helps to enforce coding standards.
Embrace Groovy, but don't get crazy about it. Groovy has some great time-saving and keystroke-saving features... use them, but remember what Uncle Ben said, "with great power comes great responsibility".
Use a code analysis tool like CodeNarc on your code to point out standards violations and possible bugs.

Grails

Grails is one of those life-changing frameworks that come along and change the way you do everything. I have done web application development with Servlet/JSP, Struts, Spring MVC (xml and annotations) and I can say that once you give Grails a try, it's hard to turn to anything else. It does so much of the boilerplate work for you that you are left to write the actual working code rather than all the bindings and plumbing. It has a strong plugin system and an active plugin community so it's easy to find what you need or to build it yourself.

The biggest downside I have seen with Grails, is that it seems overly difficult to pull your domain objects out into separate projects rather than having them in the Grails project itself.

My Grails recommendations:

Break your application up into projects appropriately. Just because you are using Grails doesn't mean everything has to be in your Grails project. GORM does seem to have issues outside of Grails but there are other things you can externalize and then provide as maven dependencies or as Grails plugins.
Follow Grails recommendations. If you do things the "Grails way" you will have a more simple experience and get the most out of grails.
Keep your Grails version as current as possible. I am not saying you have to live on the cutting edge of each release, but as the Grails versions progress, so should the version that you use. If you get too far behind, it will only be more painful than doing it incrementally.

IDE Support

IDE support has been slow coming and generally spotty. During this past year I have tried all of the "big three", Eclipse, NetBeans and IntelliJ with varried results.

I started with the IDE I had been using for years, Eclipse, which I quickly found out had terrible Groovy support and no Grails support. I switched to SpringSource Tool Suite (Eclipse + Spring), which had better Groovy support and some Grails support. I did run into a problem with our projects since most of our Grails projects at work are Grails 1.1.1, which is not well supported by the tool and as of the most current version of STS has no support.

I decided to give NetBeans a try. It has good Groovy and Grails support, even with our outdated version of Grails. I used NetBeans for a while but was not very happy with its other features. It's SVN support seemed lacking and some of its other editors were not up to the tasks I was working on. Things like running our Grails projects, unit tests and debugging stuff in the IDE did not really work.

I decided to break down and give IntelliJ a try. It has great Groovy and Grails support. I am able to debug internally and externally and run unit tests in the IDE. It has smart useful code suggestions and good Groovy DSL support. I have made IntelliJ my IDE of choice, though it does have a price tag associated with it.

My IDE recommendation would be IntelliJ if you or your company is willing to pay for it, or NetBeans if you are on your own, or have no IDE budget.

Conclusion

Groovy and Grails are a great combination. You just have to realize that as a developer you still have to pay attention to what you are doing and how you are doing it. As far as coding goes, this past year with these tools has been the most enjoyable that I have had in a long time.

A New (Free) Home

2011-07-07T19:40:00.000-05:00

If you are one of the few followers of CoffeaElectronica, you will be happy to know that I have found a new home for my blog. I had looked into Blogger years ago when I was first setting up the site, but it seemed very sketchy, like it might not be around much longer. But, it's still here and I think it will be here for a while to come.

I am still considering what to do about my older posts. You can find the raw source code for the posts at https://github.com/cjstehno/cjstehno.github.com, or you can view them (thought in a not so pretty format) at http://cjstehno.github.com. I am considering importing them into this blog, thought I am also thinking about taking a new approach and maybe rewriting/updating some of my older posts or providing them in a more updated format.

Time and level of interest will help decide.

From Junk Box to Jukebox in a Couple Hours

2010-10-17T08:41:00.000-05:00

I finally got tired of griping about not having enough space on my phone to store all of my music, and not wanting to pay for one of the music cloud storage services... so I decided to bite the bullet and setup my own using Ubuntu Server, SubSonic Music Streamer and its Android app. It only took a couple hours, most of which was baby-sitting installations, and now I am able to listen to any/all of my music whenever and wherever I want; it's quite nice.

The steps are pretty straight forward, but going into this process I must make it clear that I am not an expert network/server administrator, I am a developer, therefore if this process causes you or your equipment any harm in any way, sorry, but it's not my fault. Continue at your own risk.

First, you need a computer to work with. I had an old Dell desktop that is about four or five years old and it is working nicely. Hook up a keyboard, mouse and monitor to the box... if it's an old desktop box you should have all the connections you need. You will also need to connect the box to your network.

It almost goes without saying that you will need internet access of at least DSL, but really I would not do this with anything less than a high-speed cable internet connection.

Download Ubuntu 10.10 Server (or whatever the most current version is when you read this). Make sure that you are downloading the server version, not the desktop. Also make sure that you download the appropriate version for your system, 32- or 64-bit. I had to use 32-bit since it was an old desktop box.

Burn the .iso file you downloaded to a CD (I recommend ImgBurn if you don't have a favorite image buring application).

Once you have the CD created, pop it into the box you are building and boot from it. You may have to fiddle with your boot order in your bios, but the CD is bootable.Once the Ubuntu installation menu comes up, just follow the instructions.

A couple items to be aware of: You will want to enable the automatic security updates so that you don't have to bother with it yourself. Also, you will come to a server installation screen (after the restart I think)... at this point I selected LAMP server, Tomcat server and OpenSSH server. The SSH server is required for this, though the others are not; I plan on adding more to this box so I wanted to have the servers ready to go.

Once the installation is done, disconnect the keyboard, mouse and monitor, but leave the box running. You now have a nice clean Linux web server to play with.I recommend giving the new server box a dedicated IP address on your network so that you don't need to keep track of it. This is gererally very specific to your router, so I can't really go into it here.

From your desktop box, laptop, whatever, connect to the new server using your favorite SSH client (for windows you can use Cygwin or Putty).

All of my music is on a NAS on my local network, so I had to create a mount of the music directory on the server box. There is a nice wiki article about how to do this, Mount Windows Shares Permanently so that's easy enough.

Now download the deb installer file from SubSonic and follow the installation instructions. There are also some additional packages they recommend installing. I did.I eventually want to have SubSonic use the default servers on the box, but this installation method seemed to be the fastest one to get a server up and running.

Once you have SubSonic installed you will need to create a directory for your playlists, "/var/playlists" by default.Now that the server is running, go ahead and login and change the admin password and set the music and playlist locations. I created a second user to user for myself that did not have admin permissions. Make sure that you can see a list of your music artists down the left hand side and you are ready to go... at least for access on your own network.

In order to have access to SubSonic from the outside world, you need to setup port forwarding on your router to map one of the external ports to the server and port that your SubSonic instance is running on. Again, this is router-specific, but Lifehacker has a good overview in the article "How to Access a Home Server Behind a Router Firewall".

Once you have access from the outside world, you can install the Android or iPhone apps for SubSonic and play your music while you are away from home. The Android app is quite good. I created two profiles, one for home when I can use my local wireless network, and another for access when I am away from my network... helps to keep the bandwidth down. Using the phone is also a nice way to test out the external interface. Turn off your wifi antenna and connect via 3G.

One concern I have about running my own server is power consumption. The box I am using was a desktop box and not really made to conserve energy. I am looking into ways of setting up smart power usage, sleeping, etc, but that will come in another posting. For now I am going to test out the actual power consuption using one of those Killawatt plug-in wattage meters so that I can see what I am doing to my monthly power bill.One thought I had is that if the power consumption is too high, I might look into building a really low-power box with an atom processor and solid-state drive or something else really bare bones and cheap.I have a few other projects in mind for this now that I have a server running, though I don't think I will be moving my blog hosting there any time soon, but you never know.

If any of this is too vague, please let me know and I can add more detail. This is intended for users with minimal Linux, networking, and hardware experience, but sometimes I take more for granted than I realize.

Good luck and have fun!

Follow-up

After about six days for power monitoring, the server used 6.38 kilowatt-hours of power. With a little groovy calculating:

def kwh = 6.38, kwhcost = 0.12
def duration /* days */ = (((time('10/22/2010 06:54') - time('10/16/2010 10:10')) / 1000) / 3600) / 24
def costPerDay = (kwh * kwhcost)/duration
def costPerMonth = costPerDay * 30
def time( d ){ new java.text.SimpleDateFormat('MM/dd/yyyy HH:mm').parse( d ).getTime()}
def money( m ){ new java.text.DecimalFormat('$0.00').format( m )}
println "${money(costPerDay)}/day ==> ${money(costPerMonth)}/month"

I found that the server uses roughly $0.13/day or $3.93/month on average based on the time duration I tested in which the server was under normal usage. Obviously, this number is very dependent on the system you build your server with. Given some of the new Atom-based boxes that are available, you could probably really cut that cost down even more.If you consider that most hosting with any useful functionality is at least $3-5 per month, and a lot of the cloud-based services that are coming out are in the range of $5-10 per month... $3-5 per month for your own server with unlimited possibilities is not bad at all. Also there is one cost-cutting measure you can do with your own server that you cannot do with hosting... turn it off.

Finally, I also found a useful tool for working with the server. If you have an Android phone you can install ConnectBot which gives you SSH shell access to your server. I don't have my SSH port forwarded from the router so this only works inside my home network via wireless, but ConnectBot makes it very easy to check on the status of the box, do a shutdown or restart the web server without having to fire up your desktop box.

Rendering Calendars

2008-05-31T10:21:00.000-05:00

I am poking around with an idea I had to generate desktop background images with little calendars embedded in them and I realized that there is no really easy method of rendering your standard square text calendar display. I decided to play around with it a bit. The basic algorithm to generate the weeks and their associated days is nothing too complicated:

Figure out what day of the week the first day of the month falls on.
Subtract from that the value for Sunday (the start of the week), which assumes that the day of the week field values are sequential (which they are).
Iterate through the day of the month keeping track of the week breaks.

I created a factory class, MonthFactory and a couple helper model objects, Month and Week to make things a little easier. Month and Week are pretty simple data objects used to store the month and week data in a meaningful structure.

public class Week {
    private final String[] days = new String[7];
    private int index = 0;

    public Iterable<string> days(){
        return Arrays.asList(days);
    }

    boolean append(final String day){
        days[index++] = day;
        return index != 7;
    }

    void padding(final int size){
        index = size;
    }

    @Override
    public String toString(){
        return Arrays.toString(days);
    }
}

I used strings to store the day values, you could also use ints.

public class Month {
    private final List<week> weeks = new LinkedList<week>();
    private final String name;
    private final int year;
    
    Month(final String name, final int year){
        this.name = name;
        this.year = year;
    }
    
    public Iterable<week> weeks(){
        return weeks;
    }
    
    public String getName(){return name;}
   
    public int getYear(){return year;}
    
    void append(final Week week){
        weeks.add(week);
    }
    
    @Override
    public String toString() {
        return "{" + name + " " + year + ": weeks=" + weeks.toString();
    }
}

Both of these classes have very limited public interfaces. They exist in the same package as the MonthFactory class which is used tobuild them. External client classes should really only be accessing them as read-only. The MonthFactory is also pretty simple, but it does contain the algorithm I mentioned earlier so it is the meat of the whole example:

public class MonthFactory {
    
    public static Month create(final int calendarMonth, final int year) throws Exception {
        validate(calendarMonth,year);
    
        final Calendar cal = Calendar.getInstance();
        cal.set(Calendar.MONTH, calendarMonth);
        cal.set(Calendar.DAY_OF_MONTH, 1);
        cal.set(Calendar.YEAR, year);
  
        final int daysInMonth = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
        final String name = cal.getDisplayName(Calendar.MONTH,Calendar.LONG,Locale.getDefault());
        final Month month = new Month(name,year);
   
        Week week = new Week();
        week.padding(cal.get(Calendar.DAY_OF_WEEK) - Calendar.SUNDAY);
    
        for(int i=1; i<=daysInMonth; i++){
            if(!week.append(String.valueOf(i))){
                month.append(week);
                week = new Week();
            }
        }
        month.append(week);
  
        return month;
    }
    
    private static void validate(final int calMon,final int year){
        if(calMon < Calendar.JANUARY || calMon > Calendar.DECEMBER){
            throw new IllegalArgumentException("Invalid Calendar Month specified: " + calMon);
        }
        if(year < 0){
            throw new IllegalArgumentException("Year must be non-negative: " + year);
        }
    }
}

I even threw in some simple input validation for free. Now for a simple use of this code I created a TextCalendar class that simply generates a text calendar which will look right if it's rendered in a fixed-width font.

public class TextCalendar {
    
    public static void main(final String[] args) throws Exception {
        final Month month = MonthFactory.create(Calendar.JULY,2008);
            
        final StringBuilder str = new StringBuilder();
    
        final String header = month.getName() + " " + String.valueOf(month.getYear());
        str.append(padding(10 - header.length()/2,' ')).append(header).append('\n');
    
        for(final Week week : month.weeks()){
            for(final String day : week.days()){
                if(day == null){
                    str.append("  ");
                } else {
                    str.append(day.length() == 2 ? day : " " + day);
                }
                str.append(" ");
            }
            str.append('\n');
        }
   
        System.out.println(str.toString());
 
    }
  
    private static String padding(final int size, final char val){
        final char[] pad = new char[size];
        Arrays.fill(pad, val);
        return new String(pad);
    }
}

This just serves to show how easy this makes calendar rendering. Upon running this little application you will get the following nicely formatted calendar (I even centered the header):

          July 2008
           1  2  3  4  5 
     6  7  8  9 10 11 12 
    13 14 15 16 17 18 19 
    20 21 22 23 24 25 26 
    27 28 29 30 31

If there are existing libraries to do this, I would love to hear about them. I could not find anything. Obviously this example corresponds to the standard US display of the Gregorian Calendar. I would think that it could be made to work for other calendars as well, but I have never actually seen any other calendars displayed... I guess I need to travel the world more.I provide these as examples only; there may be better ways to accomplish this and there are definitely code modifications and improvements that could be made. I am not currently using this code anywhere... it was just an experiment. Use at your own risk. :-)

Custom Spring Editors

2007-11-01T12:39:00.000-05:00

I had the need recently to inject an array of strings (java.lang.String[]) into a bean property and I was curious about whether or not I could inject the strings as comma-separated values (CSV). With a little poking around in the Spring API I found that the supporting PropertyEditor is already there, but not configured by default. My next question was about how you go about configuring custom property editors.Configuring custom property editors is quite easy, you add a CustomEditorConfigurer bean to your context which will register itself with the bean factory at load-time. By mapping your custom editors to the CustomEditorConfigurer, you register them with the enclosing bean factory... pretty simple:

<bean id="customEditorConfigurer" 
         class="org.springframework.beans.factory.config.CustomEditorConfigurer">
    <property name="customEditors">
        <map>
            <entry key="java.lang.String[]">
                <bean class="org.springframework.beans.propertyeditors.StringArrayPropertyEditor">
                    <constructor-arg value=":" />
                </bean>
            </entry>
        </map>
    </property>>
</bean>

Note that the value of the entry key attribute is the full class name of the property type to be handled by the editor. Only one editor can be registered for a given type. The StringArrayPropertyEditor is available with the core Spring API and it will convert a delimited string into a string array. The delimiter is configurable as a constructor argument; it defaults to comma, but I have overridden it here to use a colon in this case as an example. Once you have this in place, the added configuration work is done.Let's create a simple test bean to ensure that the editor is registered properly:

public class SomeBean {
    private String[] array;

    public void setArray(String[] array) {this.array = array;}
    public String[] getArray() {return array;}
}

Add it to the spring context:

<bean id="someBean" class="SomeBean">
    <property name="array" value="one:two:three:four" />
</bean>

Now if you load the context and pull the bean out you will find that the array property contains four elements, with values of "one", "two", "three", and "four" respectively. It's just that easy!Just to verify that we have not lost any pre-existing functionality, you can add another bean that loads the array using the spring list tag:

<bean id="someBean2" class="SomeBean">
    <property name="array">
       <list>
          <value>alpha</value>
          <value>bravo</value>
          <value>charlie</value>
       </list>
    </property>
</bean>

You will notice that this method still works fine as well.There are a few other custom editors that spring provides in the org.springframework.bean.propertyeditors package, and it is also quite easy to implement your own, but I will save that for another day.

More Information

SpringFramework: Chapter 5: Validation, Data-binding, the BeanWrapper, and PropertyEditors

Recursion vs Iteration

2007-09-28T12:20:00.000-05:00

Say you have a directory under which there can be multiple sub-directories of infinite depth each with any number of files. If you wanted to walk down the directory tree and do some sort of processing of the files the first thing that always came to my mind was recursion. Write a little recursive method to iterate over the files and call the method again on directories, performing the processing as you go. Something like this:


void walk(File dir){
    for(File item : dir.listFiles()){
        if(item.isDirectory()){
            walk(item);
        } else {
            // process file
        }
    }
}

Now, this works fine and I have never run into problems with the approach; however, the iterative approach can be a useful and often more efficient alternative. Rather than recursively calling the walk() method, perform the looping and use a Stack object to maintain the set of directories to be searched. Here is what I mean:


void walk(File dir){
    Stack stack = new Stack();
    stack.push(dir);

    while(!stack.isEmpty()){
        for(File item : stack.pop().listFiles()){
            if(item.isDirectory()){
                stack.push(item);
            } else {
                // process file
            }
        }
    }
}

This method does the same thing but without recursion. I would like to do some profiling of the two approaches to see how each performs for various directory structures.

Map Iteration Tip

2007-09-27T12:25:00.000-05:00

Say you have a Map and that you need to iterate over its contents and do something with both the key and the value for each mapping. I have often seen the following code used:

Iterator i = map.keySet().iterator();
while(i.hasNext()){
    Object key = i.next();
    Object val = map.get(key);
    // do something with them
}

While this is correct and generally there is nothing wrong with it, you are doing an extra get() call into the map; however, if you iterate over the entry Set you can remove that extra call:

Iterator i = map.entrySet().iterator();
while(i.hasNext()){
    Entry entry = (Entry)i.next();
    Object key = entry.getKey();
    Object val = entry.getValue();
    // do something with them
}

Also, as a side note, with Java 5 and above you can use the new foreach loop to simplify things even more:

for(Entry<object,object> entry : map.entrySet()){
    Object key = entry.getKey();
    Object val = entry.getValue();
    // do something
}

It's not going to double your processing speed or anything, but it is a little more efficient, especially when you are iterating over a large map of items.

Dynamic JavaScript Loading

2005-06-15T09:38:00.000-05:00

I figured out a way to dynamically load JavaScript files at runtime. There are times when you may not always need to import all of your external JavaScripts, or maybe you are using Ajax to load content into a div and you also need to import some script that the content needs. Here is the solution and it works in IE and FireFox:

function loadLibrary(path){
    var headElt = document.getElementsByTagName("head").item(0);
    var scriptElt = headElt.appendChild(document.createElement("script"));
    scriptElt.setAttribute("type","text/javascript");
    scriptElt.setAttribute("src",path);
}

Pretty simple, and all you have to do to use it is:

loadLibrary("scripts/myscript.js");

This works for dynamically loading stylesheet too if you add a link element instead of a script element:

function loadStylesheet(path){
    var headElt = document.getElementsByTagName("head").item(0);
    var scriptElt = headElt.appendChild(document.createElement("link"));
    scriptElt.setAttribute("type","text/css");
    scriptElt.setAttribute("rel","stylesheet");
    scriptElt.setAttribute("href",path);
}

End of Time, Well Date Anyway

2005-02-18T07:59:00.010-06:00

I have run across this issue before you need to specify a "far-off" expiration date for something using the java.util.Date class. Generally I have specified something 100 years in the future like 1/1/2100 or something like that using the old deprecated Date constructors... but that is not really a good practice or habit to get into. I came up with two better solutions.

First, in the case where you want to specify a static date, you could run a quick test to determine the long time value for the date you create using the deprecated constructors. You then modify your code to use the long value in the constructor, which is the only remaining non-empty constructor.

The second options is useful if you just want a date sometime in the unreachable future (avoiding any reasonable y2k-like issues) you can use the following:

Date expiration = new Date(Long.MAX_VALUE);

which will yield a date so far in the future that you would be proud to have your code exist that long and happy to fix it (at least your descendants should be happy to fix it). The date it represents is:

Sun Aug 17 00:12:55 MST 292278994

I think that should suffice.

Worker Bean Pattern

2004-05-28T12:01:00.000-05:00

I stumbled upon something that I thought would make a good design pattern, if no one else has already come up with it. The only name I could think of for it was the "Worker Bean Pattern". If this is not new, someone please let me know.

Basically the pattern consists of two classes, the Manager class and the Worker class. The Manager class is used to create semi-transient Worker classes as required for use by client objects. The example I will use to help me describe this pattern is a web-based wizard-style input form.

The Manager class is basically a loose combination of the Factory Pattern and the Singleton Pattern. There should be only one instance of a particular Manager object in the system. For my example, let's call the Manager class FormManager and say that it is an object stored in the application scope of the server context (so that there will be only one instance per server context). The Manager class' function is to "manage" the Worker instances. It creates them, populates their data, and destroys them with no external objects acting directly on the Worker classes in a fashion other than read-only. We can stub out the methods of our FormManager as the following:



public class FormManager {

        public FormWorker createFormWorker(){}

        public void postFormData(FormWorker fw, String name, String[] values){}

        public void destroyFormWorker(FormWorker fw){}

}

where FormWorker is the Worker. The createFormWorker() method is used to create a FormWorker or use by the client when they first enter the wizard form set. This Worker could be pulled from a pool of available workers or created as needed. The client puts the FormWorker the session scope. As the pages of the wizard form are submitted, each posts its data to the postFormData() method, which processes the data and modifies the FormWorker as necessary. Once the final wizard page has been submitted and the client has no more use for the FormWorker, it is passed to the destroyFormWorker() method so that it can be disposed of, or returned to the pool.

The Worker is basically an encapsulation of data required to perform an operation in the Manager that requires more than a single step. In our example that FormWorker is stored in the user's session so that the current state of the wizard form is maintained between pages. The Worker's data should not be accessible outside of the Manager. It exists only as a temporary extension of the Manager. Once the client has finished with a Worker it should be disposed of by the Manager. In our example, FormWorkers could be pooled within the FormManager to minimize new object creation and increase efficiency. Our FormWorker would look something like this:



public class FormWorker {

        FormWorker(){}



        void addData(String name, String[] value){}

        String[] getData(String name){}

      

        void setUserId(String userId){}

      

        public String getUserId(){}

}

You'll notice that most of the methods have the default access, accessible to only other classes in the same package. You would want to place the FormManager and FormWorker in the same package for this to work. Another interesting means of achieving this association, if you prefer, would be to nest the FormWorker inside the FormManager as a static nested class; with a nested class, you can enforce the isolation of the worker using private methods. Let's do that for our example and flesh out the methods a bit more for the final stub:



// Manager

public class FormManager {



        public FormWorker createFormWorker(String userId){

                FormWorker fw = checkoutWorker();

                if(fw != null){fw.setUserId(userId);}

                return(fw);

        }



        public void postFormData(FormWorker fw,String name,String[] values){

                fw.addData(name,values);

        }



        public void destroyFormWorker(FormWorker fw){

                fw.clearData();

                fw.setUserId(null);

                checkinWorker(fw);

        }



        // Worker

        public static class FormWorker {

                private String userId;

                private HashMap data;



                private FormWorker(){this.data = new HashMap();}



                private void addData(String name,String[] value){

                        data.put(name,value);

                }



                private String[] getData(String name){

                        return((String[])data.get(name));

                }



                private void clearData(){data.clear();}



                private void setUserId(String userId){

                        this.userId = userId;

                }



                public String getUserId(){return(userId);}

        }

}

Obviously this is still missing some code and does not really do anything interesting; however, it should give you the basic feel of my idea. I used something similar to this in a project recently (actually, a wizard web form set) and it worked very nicely. Of course there are other ways to skin this cat. You could even simply put the "working" data into the session itself, though I tend to like things neat and tidy without having to keep track of a lot of session variables.

This may or may not already be a pattern on someone's list or in a book somewhere, but I did not find it. I present it in the hope that it will be useful to someone, and as I said, I am always open for comments or suggestions.

Proper Care and Feeding of Your JDBC Code

2004-05-28T10:27:00.000-05:00

If you've been developing very long, you have probably run across this numerous times, but for those of you that are new to JDBC, here is a quick tip that will help you greatly in the long run (I have seen it done wrong many times). When you perform your connection retrieval (directly or from a pool - use a pool as often as possible), make sure that you clean up your resources when you are done.

Connection conn = null;
Statement st = null;
ResultSet rs = null;
try {
    conn = getConnection();
    st = conn.createStatement();
    rs = st.executeQuery(sql);
    while(rs.next()){
        // ... work it
    }
    // minimize code here to free conn ASAP.
} catch(Exception ex){
    // log this or something
} finally {
    if(rs != null){
        try {rs.close();} catch(Exception e){}
    }
    if(st != null){
        try {st.close();} catch(Exception e){}
    }
    if(conn != null){
        try {conn.close();} catch(Exception e){}
    }
}

If you follow this format as a general rule, you will end up with fewer database related problems, especially if you use connection pooling. Connections that are not disposed of properly can cause very bad things to happen in your application. Also, note that I mention minimizing the code within the try/catch block. You want to use your connection and clean it up as soon as possible (again, especially if you are pooling) so that the resources are not hanging around needlessly. Another interesting point is the set of empty catch blocks. We have all been told that empty catch blocks are a bad thing; however, I have seen this style used in pretty much every description of this code. The JDBC developers (in their infinite wisdom) decided that every method should throw a SQLException, even though there is little you can really do about it when you are trying to close up the connection. That is why you just ignore them; though here I ignore them separately so that one does not affect the others.You can clean up this code even more if you use the Jakarta Commons - DbUtils API:

Connection conn = null;
Statement st = null;
ResultSet rs = null;
try {
    conn = getConnection();
    st = conn.createStatement();
    rs = st.executeQuery(sql);
    while(rs.next()){
            // ... work it
    }
    // minimize code here to free conn ASAP.
} catch(Exception ex){
    // log this or something
} finally {
    DbUtils.closeQuietly(rs);
    DbUtils.closeQuietly(st);
    DbUtils.closeQuietly(conn);
}

You are not really required to close the ResultSet, and the Statement if you close the Connection properly; however, it adds an extra level of assurance especially when you are using a driver that may not be fully compliant or properly implemented.The Spring Framework also provides some very useful APIs for working with JDBC such as template methods, row mappers, and callback closure-like structures, an example would be:

new ConnectionCallback(){
    public Object doInConnection(Connection conn) throws SQLException, DataAccessException {
        st = conn.createStatement();
        rs = st.executeQuery(sql);
        while(rs.next()){
            // ... work it
        }
        // minimize code here to free conn ASAP.
    }
}

There are quite a few helpful constructs in the Spring JDBC API to make JDBC interaction easier to work with.

Proxy Method Logging

2004-02-11T06:00:00.000-06:00

Here's an interesting spin on logging. Say you have a service of some kind that loads in other classes dynamically such as modules or plug-ins and you want to provide a seamless debugging mode no matter what kind of logging the module developer has done. You can use a java.lang.reflect.Proxy to do your method call logging. Basically, you build a wrapper around your module that does the logging for any module.

First off, you need an interface to do this, any interface that your modules implement will work.

public interface SomeInterface {
    public void doSomethingA(String p1, int p2);
    public String[] doSomethingB(Map map);
}

Second, you will need an implementation of that interface, your module or plug-in class. This is the actual object doing the work whose method calls will be logged.

public class SomeImplnterfaceImpl implements SomeInterface {
    public SomeImplnterfaceImpl(){}

    public void doSomethingA(String p1, int p2){
            System.out.println("doSomethingA with ("+p1+" and "+p2+")");
    }

    public String[] doSomethingB(Map map){
            System.out.println("doSomethingB with a Map: " + map);
            return((String[])map.values().toArray(new String[0]));
    }
}

Both of the above items you should already have in your system. If not, in most cases, they can be easily added. Now we get into the good stuff. The Proxy class is an interesting little creature. It allows you to give it an array of interfaces that it is to "implement" by passing method calls to an instance of the InvocationHandler interface, which determines how the method calls are to be processed. Our proxy will simply log the method call and pass it along to the real implementation.We'll make a factory class to create our logging proxy. It will have one method with two arguments. The first is the interface that is to be logged, SomeInterface in our example, and the second is the implementation of that interface, SomeInterfaceImpl for our example.

public final class LoggingProxyFactory {
    private LoggingProxyFactory(){}

    public static final Object create(Class interfc,Object impl) throws Exception {
            LoggingHandler handler = new LoggingHandler(impl);
            return(Proxy.newProxyInstance(
                    impl.getClass().getClassLoader(),
                    new Class[]{interfc},
                    handler)
            );
    }
}

You see that creating a proxy is pretty simple. You create a proxy instance using your interfaces, your class loader and your invocation handler. The invocation handler is where the action happens. Our InvocationHandler implementation is going to be a static inner class of the LoggingProxyFactory class. What it needs to do is logs the method calls as they come in and then pass along the call to the real implementation. Here is the code for the inner class.

private static final class LoggingHandler implements InvocationHandler {
    private Log log;
    private Object impl;

    private LoggingHandler(Object impl){
            this.impl = impl;
            this.log = LogFactory.getLog(impl.getClass());
    }

    public Object invoke(Object obj,Method method,Object[] params) throws Throwable{
            if(log.isInfoEnabled()) log.info("Entering: "+method.getName();

            if(log.isDebugEnabled()){
                    for(int p=0; p&tl;params.length;p++){
                            log.debug(method.getName() + " Param[" + p + "]: " +
                                    params[p].toString());
                    }
            }

            Object ret = null;

            try {ret = method.invoke(impl, params);}
            catch(Exception ex){
                    if(log.isErrorEnabled()){
                            log.error(method.getName()+" Exception: "+
                                    ex.getMessage(),ex);
                    }
                    throw ex;
            }

            if(log.isDebugEnabled()) log.debug(method.getName()+" Returned: "+ret);

            if(log.isInfoEnabled()) log.info("Leaving");

            return(ret);
    }
}

I am using the Jakarta Logging API for the logging in this case; however, you could use any logging API or simple standard out statements as you see fit. The main thing to notice in the code above is the invocation of the method on the implementation object.

ret = method.invoke(impl, params);

It is this line that passes on the method call to the real implementation. The rest of the method is logging of the entering and leaving, parameters and return value. Exceptions are also logged. To test out the proxy and see it in action, you can run the following tester app:

public class Tester {

    public static void main(String[] args){
            try {
                    Object obj = LoggingProxyFactory.create(
                            SomeInterface.class,
                            new SomeImplnterfaceImpl()
                    );
                    SomeInterface siObj = (SomeInterface)obj;
                    siObj.doSomethingA("Hello",31);

                    Map map = new HashMap();
                    map.put("a", "Some data 1");
                    map.put("b", "Some data 2");
                    map.put("c", "Some data 3");
                    map.put("d", "Some data 4");
                    siObj.doSomethingB(map);

            } catch(Exception ex){ex.printStackTrace();}
    }
}

Which yields the method call results and their logging information. This was an interesting idea I have tossed around for a while now. It does work, though it has not been rigorously tested. If nothing else, it is a description of how to use the proxy class.