CoffeeScript is happening…

…whether you like it or not. Personally, I’m psyched — it looks like it solves a lot of the annoyances I’ve had with Javascript syntax, and I got a sweet deal on CoffeeScript: Accelerated JavaScript Development during the conference, which I hope to put to good use starting this week.

The Rails Community is Awesome

My wife’s response after she read my tweets upon my return:

“Just wondered, who is this guy? Dinner anyone? Share a cab? You became an extrovert on your mothership.”

It’s true, I did. It’s weird. I’ve never been to Baltimore before (save time spent between flights at BWI), but among my fellow Rails coders, I’ve never felt more “at home.”

As I thought about all of the people I finally got to thank in person for all they’ve done to make my time in the Rails community more enjoyable, it really drove home what an awesome community we have. It’s easy to lose sight of this while working away in Louisville, my little corner of Kentucky.

Aside from this, getting a chance to put a real face to a name, make and receive thank-yous for all the hard work we put in on Rails patches, plugins, and the like, has the effect of re-energizing a developer. I’d go on and list all of the awesome people I got to meet in person here, but I think it’d just make @casron more jealous.

I would like to say, however, that Emilio Tagua (@miloops) has got to be one of the friendliest guys I’ve ever met. I’d hoped to catch up with him to thank him for helping me get commits added to ARel back in the 1.x days that were needed for MetaSearch and MetaWhere. Instead, he ended up two seats over from me at Ignite, noticed I was hacking on a Squeel bug, and introduced himself first. Every time I saw him during the remainder of the conference, he had a smile and a kind word. Just an all-around great guy to have met.

PostgreSQL is awesome, too!

Now, I should have known this. I had started out using MySQL many years ago, when it had solid speed advantages over PostgreSQL, but far fewer features. Somewhere along the line, that balance shifted, but I stuck with MySQL due to familiarity. Nick Gauthier’s KnowSQL presentation has made a believer out of me. I’ll be using PostgreSQL as my RDBMS of choice from here on, and making sure that Squeel works as well as possible with it, too.

The Fundamentals are ALWAYS Relevant

There were tons of talks on design patterns, best practices, and so on, and even as long as I’ve been doing this whole coding thing, there are plenty of areas in which I can improve. In particular, Avdi Grimm’s talk, Confident Code, José Valim’s talk about the design principles behind the Rails 3 refactoring, and the talk on Building Bulletproof Views by John Athayde and Bruce Williams all challenged me to elevate my game in these areas.

HTML5 is sooooo much more than semantic tags

LocalStorage, audio, video, canvas drawing, web sockets, web workers — this stuff is all crazy cool and I can’t wait until more browsers support it. Mike Subelsky’s HTML5 tutorial was a real eye-opener.

That’s about it, for now. What were some of your takeaways from RailsConf this year?

What’s celebt.ag, you ask? It’s a mobile-friendly website that combs Twitter to collect photos of celebs and let’s you see who’s been seen. We wanted to make it super simple – no commitment, no log in or username to remember – or forget, no hassle. Simple fun in three steps:

1. Snap a photo of a celeb
2. Upload your photo to twitpic, yfrog, tweetphoto or ow.ly
3. Tweet about your pic and use the hashtag #celebtag in your tweet, and see your photo appear on the site.

We developed celebt.ag, as a fun, whimsical way to explore and interact with the mobile web. We also explored the use of responsive design to format the layout of the site for use on nearly any browser with one set of code. See who the top celebs are, who the top spotters are and where you fit in the picture.

The concept came about as senior architect, Ernie Miller and creative director Todd Budnikas were planning for SXSW. “What we need is a way to share just our contact info, and nothing more. Without requiring us to carry stacks of business cards, or make goofy hand gestures with everyone we bump into, like we’re back in college again,” said Miller, “We looked, but we couldn’t find that solution. So we decided to build it.”

We hope you find this application as useful as we do. If you have any suggestions or comments please reach out to us on Twitter.

Screen capture of the Intrepid Bioinformatics website.

Ok, bad paraphrasing aside, for one moment, put on your best “Gordon Gekko” suit, and loosely consider this:

In finance, a portfolio is a collection of investments held by an institution or an individual. Holding a portfolio is a part of an investment and risk-limiting strategy called diversification – by owning several assets, or “things with value”, certain types of risk can be reduced. In building up an investment portfolio, a financial institution will typically conduct investment analysis, while a private individual may make use of a financial advisor/institution’s portfolio management services.

Now ask yourself this – what if there were a way to do this with, oh I don’t know: your genetic data? Enter Intrepid Bioinformatics.

Intrepid’s founders had a vision, one of a heterogenous genetic data management platform that would allow researchers to store, compare, and contextualize genetic trends, as well as purchase reagents and consumables, all in one place. With a newly-designed identity by Katie Bush Design, Inc. in hand, Intrepid and their team came to Mission Data looking to take this concept out of the futuristic conversational realm and bring it into the “now”.

What Does It Do?

A “software-as-a-service” platform allows genetic researchers to compare similar data sets from thousands of samples side-by-side. With Intrepid, a researcher can begin to quickly identify trends in entire populations which will have the potential to quickly advance discoveries in the medical, pharmaceutical and agricultural biotechnology industries. From free trials to rich-access subscriber plans, users are presented with an impressive load of features right out of the gate – multiple upload options, data downloading, user tutorials, and active collaboration between other community members of your choice, to name a few.

Who’s Using It?

Intrepid appeals to the genetic research community in two sectors: human genome research and animal (specifically, bovine) research. The markets for these two segments are vastly different, and the audience can be further segmented into researchers working for larger companies/governments/universities vs. researchers in small, relatively unfunded labs.

Take, for example, a cattle farmer. He or she obviously has a vested interest in ensuring that their clients are receiving the best product possible, be it milk, beef, etc. By using Intrepid’s services, they can access a wealth of genetic data that will help them determine which lines of cattle are best suited for those assorted purposes. And, which lines they might want to avoid because of a predilection for disease.

That’s not to say those are the only audience contingents that Intrepid is looking to pull into their community. On the contrary, a day on the horizon can be seen in which members of the public can look to utilize Intrepid Bioinformatics’ services like a digital genetic bank, safely and securely storing their data with constant and “at-will” access.

Our team at Mission Data constantly look to push and redefine the boundaries of what is thought possible and conventional in the realm of the web. And, I think I can speak for all of us when I say that if we can eliminate boundaries and make the ideas of the future happen while partnering with great clients, then the ride is made all the better. This was certainly the case here.

To further paraphrase Gordon Gekko: “It’s all about the ‘now’, kid. The rest is just conversation.”

If your best argument against using Ruby is a perception that it’s slow, a reminder: Moore’s Law is on our side. :)

Ruby’s been fighting the “Ruby is slow” meme for years now, and not without good reason — every day, new strides are being made in one Ruby implementation or another that show there is ample opportunity for efficiency improvements.

That being said, do the people making this argument realize how old and tired it is? I don’t mean, “bashing Ruby for being slow is so 2002.” I mean, “bashing programming languages for being slow is so 1972 (at least).”

“Ruby is slow. Java is better.”
“Java is slow. C is better.”
“Forget about compilers, they’re inefficient. Program in assembly!”

Resisting a programming language because it’s perceived to be “slow” is one of the most short-sighted decisions one could ever make. Over time, VMs get more efficient, compilers produce better machine language, and bandwidth, storage, and compute cycles become cheaper and more abundant. However, I have yet to hear of a single developer who has succeeded in performing more than one hour of work per hour.

Choose the programming language that is “fast enough” for your needs, maximizes your source code’s expressiveness, and increased your developers’ happiness and productivity, because:

1. “Fast enough” isn’t nearly as fast as you think it is. The dissenting developer in the story above, who rejected Ruby because it was slower than Java, is writing a web-based document management system that needs to support user concurrency in the tens, not thousands.
2. A project with a highly expressive codebase will be easier to develop and maintain.
3. It’s hard enough to attract and retain strong developers even when you aren’t hamstringing their productivity.

And one last reminder: It’s easy to write non-performant code in any language. Sometimes it pays to check up on the carpenter before you blame the hammer.

• 1970s 3270
• 1980s X terminal
• 1990s Java applets
• 2000 Flash
• 2005 Ajax

Up until about 2000 it was taking 10 years to cycle from “we want everything on our desktop” to “we want everything on the server”. Now the cycle seems to have sped up to every year and then to constant. A couple recent examples of new faces on this old idea are Adobe’s Apollo and Joyent’s Slingshot.

Fundamentally not much has changed from the 1970s. The goal is to centralize computing resources into one place (in the simple view of things) and make issues like software deployment easier.The main difference now is that the industry has come to the point where there isn’t any turning back and everyone has bought on to the need and usefulness of online apps. The main sticking point seems to be finding a way to resolve issues that come up from users being disconnected from time to time. I’ll bet that one won’t be fully resolved until you have connectivity anywhere and everywhere you go.

If you don’t respect these two possibilities, then you will get bit in the butt alot, when you least expect it. To be fair, these situations can happen whether you’re using Hibernate or not, but when we first started using the framework we made lots of assumptions.

Here is a completely ridiculous example that violates the above restrictions:

public class User
{
  private boolean isSurnameLast;
  private Name name;  

  private String fullName;
  private String initials;

  public boolean setSurnameLast(boolean surnameLast)
  {
    this.isSurnameLast=surnameLast;
  }

  public void setName(Name name)
  {
    this.name = name;
    String lastName;
    String firstName;
    initials = new StringBuffer(name.getSurName().substring(0,1)).append(".").append(name.getGivenName().substring(0,1)).toString();
    if(isSurnameLast)
    {
      lastName = name.getSurName();
      firstName = name.getGivenName();
    }
    else
    {
      lastName = name.getGivenName();
      firstName = name.getSurName();
    }
    fullName = new StringBuffer(firstName).append(" ").append(lastName).toString();
  }
  // more getters and setters blah blah blah
}

(Ignore the lame “business logic” here…)

So you look in your database and you see that all the Users database entries have names and properly set surnameLast values, and all the Names database entries have a surName and a givenName. Sure the code is sloppy, but this is gonna work fine!

Nope, this setName is loaded with problems.

First, you’ll notice as your app runs that somehow setName is being called and passed a null. What?! Why! Durn that Hibernate, it is trying to trick you! No matter, we’ll catch it with a null check. You’ll shield your eyes as to when and why Hibernate or cglib or whatever is calling setters on an instance that isn’t even in the database, but at least it won’t blow up. This is the first bad smell you’ve blown through, you sloppy panicky codemonkey:

  public void setName(Name name)
  {
    if(name!=null) // hahah
   {
       this.name = name;
      ....

Then you’ll start realizing that no matter what the database says, sometimes you are getting the surname first in the full name! “Smith Joan!”, you’ll cry, but “it’s true for Joan Smith in the database! Why?” Well, sometimes Hibernate is calling setName before it calls setSurnameLast. It doesn’t matter which you have mapped first in the User.hbm.xml file, or which field you have first in the code. You can’t depend on other properties of User being initialized in the Hibernate setters.

Now, you’re also going to get NullPointerExceptions thrown out of this code, because sometimes that Name instance you’re being passed hasn’t had its properties initialized by Hibernate yet. Talk about something that seems sneaky and evil but is totally above board: Hibernate has created the new Name instance and has passed that reference to other instances, but hasn’t fully populated the Name instance yet.

That means this line will blow sky-high sometimes:

initials = new StringBuffer(name.getSurName().substring(0,1)).append(".").append(name.getGivenName().substring(0,1)).toString();

The sane thing to do here?

  public void setName(Name name)
  {
    this.name = name;
  }

So if you’re using Hibernate, go take a look at your classes and mappings! You may very well be doing something dangerous.

The Hibernate API allows you a lot of access to its configuration object model, and this is ideal for finding out how Hibernate is interacting with your code. I wrote a small class to do this inspection. The method below is run after a Hibernate Configuration object named creatively as “configuration” has been built with mapping files:

public Map findSetters() throws MappingException
{
  Map classToSetters = new HashMap();
  Iterator classMappingIterator =   configuration.getClassMappings();

  while(classMappingIterator.hasNext())
  {
    PersistentClass persistentClass = (PersistentClass)classMappingIterator.next();
    Class mappedClass = persistentClass.getMappedClass();
    Iterator propertyIt = persistentClass.getPropertyIterator();
    List classSetters = new LinkedList();

    classToSetters.put(mappedClass, classSetters);

    while(propertyIt.hasNext())
    {
      Property property = (Property)propertyIt.next();
      Setter setter = property.getSetter(mappedClass);

      classSetters.add(setter.getMethodName());
    }
  }
  return classToSetters;
}

I have uploaded a Java project that contains the full HibernateInspector class, as well as some sample classes and mappings. Un-tar it, and run

ant -Dhibernate.home="path to hibernate 3" 

to build and run the example.

It’s been a month now since our last performance, but it all comes back every time I look at the slides.