When I first started in the eCommerce department back in 1997, the site was re-done by a company called Proxima (they later changed their name to the much more internety Proxicom). As I was browsing around the date code, I noticed a function called getMonthOptions(), which had a similar implementation:

function getMonthOptions(fieldName,currentMonth) {
   monthOptions = "";
   if ( currentMonth == 1) {
      monthOptions += "<option name=\"" +
      fieldName +
      "\" value=\"1\"" +
      " selected="true">January</option>";
   } else {
      monthOptions += "<option name=\""  +
        fieldName + "\" value=\"1\"" +
        ">January</option>";
   }
   if ( currentMonth == 2 ){
      monthOptions += "<option name=\""
         + fieldName + "\" value=\"2\"" +
         " selected="true">February</option>";
   } else {
      monthOptions += "<option name=\"" +
     fieldName + "\" value=\"2\"" +
     ">February</option>";
   }

….and on and on.

So, I replaced that code with something like:

function getMonthOptions(currentMonth) {
   var months = ",January,February,March," +
     "April,May,June,July,August," +
     "September,October,November,December".split(",");
   monthOptions = "";
   for(var i=1; i < months.length; i++) {
       monthOptions += "<option  value=\"" +
          months[i] + "\" ";
      if ( i == parseInt(currentMonth)) {
        monthOptions += " selected=\"true\"";
      }
      monthOptions += ">" + months[i] + "</option>";

   }
return monthOptions;
}

…and that was that.

Still, it struck me as odd that seasoned consultants would write such verbose code. However, After reading the daily WTF it appears that those consultants were actually pretty good.

The code is good for a laugh or two, but to find what’s really interesting about the site, you have to pull back the covers a little bit. First off, there are a lot of people who totally miss the WTF moment and instead post something like “he names the variables poorly”. That leads me to believe that they probably implemented something like the WTF in the past. Also interesting is the total commitment the administrator has to Microsoft. A while back, the site had a few performance problems, but he couldn’t afford to upgrade the site to Windows Server 2003 with SQL server. The upgrade would have cost him $2500, but he refused to entertain running on open source software. “Dirty hippie software” he derisively called it. What’s amusing is that he’s running some vanilla discussion software and that going open source would have saved him all that grief –someone eventually donated Windows Server Small Business Edition to him, but only after a couple of weeks of protracted whining. Furthermore, his coding skills aren’t that great; At one point, he had to ask how to serialize a HashTable (it’s C#, note the funny capitalization) to a byte array –not really challenging stuff.

Still, it’s a good read and allows me to re-live those days when I would marvel at the ways of the consultants. I might not like every line of code at work but none if it is even remotely as bad as a daily WTF.

First off, I love the terseness of the language. It’s amazing what you can do with one line of code, compare:
Java:

  Iterator i = list.iterator();
  while ( i.hasNext()) {
      Object o = i.next();
      if ( o == null ) {
         i.remove();
      }
  }
 

Ruby:

list.compact


Granted, that might not be the best example, since compact is built in to arrays in ruby, however, this does the same thing

list.reject{|element| element.nil?}

And the amazing part is that you get this type of reduction in total lines of code everywhere. Since we’re developing a web based application, we’ve been using Rails as well. Rails brings Ruby’s speed of development to the web. Coming from a Struts based application, it’s really shocking how quickly you can create a model, view and controller. This speed benefits your architecture as well –if it’s easy to make a new MVC, then you’re more apt to do it, rather than adding additional code to one that’s already there.

Rails does have its faults, and they impact both the speed at which you develop, and the Object Oriented nature of the code you write.

First off, ActiveRecord, Rails’s persistence mechanism, uses single table inheritance. This doesn’t seem to be such a bad thing at first –after all, Hibernate, OJB and just about every other O/R layer offer this feature as well. Where ActiveRecord breaks down is that it doesn’t have a mapping layer. Instead, all objects are built directly from database metadata. Most of the time, this works very well, as O/R layers generally map an object directly on to a database table, and ActiveRecord saves you this tedious and error prone step. However, if you use single table inheritance, that database table has the superset of all methods available for all objects in the inheritance hierarchy. This means that objects gain methods that they shouldn’t have, and there is no way to prevent them from having these extra methods. This is truly bad for object orientation, as you can’t define exactly what methods your objects expose. Sure, you can ‘know’ what method each type exposes, but that’s akin to sticking your fingers in your ears and screaming “I’m using OO programming techniques!!! LA LA LA!!!”, which, as we all know, doesn’t mean you’re programming in an OO manner. I’d suggest being able to tell ActiveRecord which methods an object should receive, like this:

   class Article
      methods :title,:description,:text
   end
   class NewspaperArtice <Article
      methods :byline, :run_date
   end
   class MagazineArticle < Article
     methods :author,:magazine_title,:issue_date
   end

In this example, the database would have the colums title, description, text, byline, run_data, author, magazine_title and issue_date.

Second, the documentation is atrocious. Being a java programmer, I’m used to excellent documentation. JavaDoc is a godsend for programming, and Java’s documentation is thorough, complete and correct. Even the open source Java projects have continued this tradition. Sadly, it’s not so in the Ruby world. Part of this comes from Ruby’s dynamism, it’s impossible to tell exactly how objects have been changed in any execution environment. How, for instance do you communicate that Ruby on rails added several methods to numeric objects? However, most of the documentation is just inadequate. I’ve looked extensively at the rails docs, and have yet to find a good explanation of how exactly I can configure routes.rb. this is no help. Where’s the documentation for the rails request object? Where is the testing documentation? Sadly, Google is more of a help for figuring out what to do in rails than any of their documentation. However, docs are an easily fixable problem, and I expect them to improve rapidly, now that rails has a high profile.

Still, ruby and rails are extremely valuable tools to have in your belt, and even with the above flaws, are worth using. The productivity increases are amazing. I’ve developed two projects in rails so far, one for work and one for a family friend. The project for work went as smoothly as any I’ve ever been on, and –get this– the one for the family friend was completed in the two week window that I was waiting for a design firm to re-do the mockups to use CSS. The original java implementation took months.
Yeah, it’s nice to be able to code a web app in the same amount of time it takes brain dead designers to do CSS.

This actually wasn’t that bad of a description. When I typed the URL she gave me, the browser just spun and didn’t download anything. Stranger still, it didn’t time out after 60 seconds. If the server is doing what I think it’s doing, this could be used to DOS the web site. As it turns out, I can replicate the behavior on any of their pages, simply by adding characters to the end of the URL. I’ve sent them a note, but if I know large corporations should land in an inbox somewhere about 3,000 miles away from the person that can actually do something about it.

Here’s hoping it’s not serious.

Anyway, go grab it while it’s hot.

Since Java isn’t free software (free as in free speech, it costs nothing to download) most Linux distributions don’t include it by default. However, they’ve started including a free version of Java called GIJ/GCJ. GIJ/GCJ are front ends for GCC, the venerable C/C++ compiler and they’re fantastic projects, but GCJ/GIJ are not mature enough for distribution. There are huge swaths of the standard Java API that they don’t provide, including support for saving and loading application preferences. The end result is that when a user tries my application under this system, it just doesn’t work.

Java currently suffers from a reputation of sluggish performance, funny looking UIs and strange error messages, and GIJ just adds to these perceptions. It’s no small feat to write an application that runs unmodified on three separate operating systems unless you use Java. It’s sad that the free software umbrella –which brought you jUploadr, and all of the libraries that it uses– also makes that more difficult.

The problem arises when you actually go to deploy this code. You see, in Linux, the transforms rely on having the Cairo graphics engine, which is only included on the most bleeding edge systems. Thankfully, it worked on my system, having upgraded to the Cairo capable Fedora Core 4 only a week before. Had I tried this prior to the upgrade, jUploadr would have crashed. Similarly, the transforms require GDI+ on windows. As far as I know, GDI+ is only included by default on WindowsXP and Server 2003.

So, I was faced with a dilemma, either I use the SWT transforms and drastically reduce the number of people that could use jUploadr, or write my own transforms and maintain compatibility. For me, it’s not really a good choice, so I went ahead and wrote my own rotation code.

I don’t know why the SWT people bound their transforms to such cutting edge graphics libraries, but that decision severely limits their use. It’s kind of baffling as well that they don’t have some sort of fallback mechanism. I’m really disappointed that instead of gracefully degrading (perhaps sacrificing speed or image quality) they just blow up if the library isn’t there. As I demonstrated, the transforms can be implemented rather easily in Java, so there’s really no excuse for this.

However, I am happy that their API allowed for me to implement the transformations on my own, and in the end, this means that jUploadr users will just get another useful feature, even if I had to work a little harder to give it to them.

In addition, I’m pleased to say that jUploadr got its first donation this week. I thank you, anonymous donor. Here’s to many more uploads.

I’ve been very impressed with the response I’ve received from the SWT team. They’ve knocked out several bugs in very little time, and enabled me to ship an application that works well on three very different platforms. Granted, Swing would allow me to do the same thing, but SWT allows cross platform GUIs with the native widget toolkits and native speed.

I’ll put together a release for Mac when a nightly SWT release is made available and I have a couple days to test it.

How can you not love the guy? He’s still so excited by technology that his friends call him google. Vardhman kind of reminds me of me in a round about way. We both like software, we’re both writing flickr uploader applications and we both ride motorcycles –though my VFR will stomp his Bajaj Pulsar. So, I wish him luck with Qlickr (how exactly do you prounounce that? ‘Clicker’?), he’s got a lot of work ahead of him. Still, it’s worth it for the sense of satisfaction that you get when a user emails you and thanks you for the great application. With a lot of work, I’m sure Vardhman will get similar praise.

Oh, one more thing. Vardhman alerted me to my failed WordPress upgrade. Thanks!