The response from the group was incredible. It was obvious that this is a pain point for many of us who have turned our backs on Ballmer.

I got seven suggestions. Here’s a breakdown of each followed by my conclusions:

1) Thiago suggested installing wine and then installing standalone IE or IETester.

HAH Results: I wish I could trust IE running on Wine, but I can’t. I got IE 7 working on my machine, and it was super unstable, and it looked very different as an app than it does on PCs. There could be some value in using it for initial testing, but then I feel like you’d have to still find a real PC and test again.

2) Nick mentioned, “Perhaps Litmus would suffice?”

HAH Results: Works great if things are mostly already working and you’re going for a huge set of browsers. It will show you screenshots of what pages look like on up to 24 different browsers. Unfortunately, it has no interactivity, so you can’t get to a dynamically created page, and you also can’t ‘play’ by tweaking html/css/javascript on a particular browser until it works.

3) Edward tossed out the idea of using some images Microsoft makes available with different versions of IE on each (http://www.russellheimlich.com/blog/walkthrough-setup-multiple-ie-virtual-machines-on-a-mac/)

HAH Results: If you read the last couple of comments on the referenced blog, you’ll see that these are now encumbered with license requirements if you try and convert them from VPC to something that a Mac can run.

4) Guyren had a promising-looking suggestion called ie4osx (which appears now to be WineBottler) at http://kronenberg.org/

HAH Results: This is the wine solution in a nice binary installaion package for osx. Same problems as mentioned in number 1.

5) James came through with a fantastic option: Use an Amazon EC2 instance whenever you need it.

HAH Results: This is legit and it works. Great solution. Cost is about $0.12/hr. No problems there. It speaks directly to my complaint that it’s not worth a the full license cost of Windows for just one app every once in a while.

6) Thibaut said that those Microsoft VPC images might be runnable via VirtualBox. (VirtualBox is a free competitor to Parallels from SUn Microsystems.

HAH Results: Looks like a great way to avoid paying for a Parallels license. However, we run into the same problem with the Microsoft VPC issues discussed in number 3.

7) Finally Zach dug up a neat new product from Adobe called BrowserLab: https://browserlab.adobe.com/index.html

HAH Results: This offers the same core functionality as Litmus with a few extra bells and whistles. You still run into the issue of not being able to look deep into ajaxy sites and not being able to do real time ‘poking around’.

With all these great suggestions, I was surprised to find only three real options for my particular needs. Here are my conclusions:

• Borrow someone’s PC for a while
• Use Amazon to remote into a pc (to be fair there are probably a bunch of other remoting services)
• Find someone that has an old copy of one of those VPCs that came from microsoft before they became license encumbered.

An example of what it looks like in our other “secret” project:

This plugin builds on the ideas and HTML generation outlined in http://dev.elevationblog.com/2009/07/23/event-calendar-rails-plugin/ but differs in the underlying model(s) that drive the plugin.  The original plugin used one model that had a start and end date on the model in question.  This modeling did not allow for breaks between the start and end date.  Our new plugin revises this idea and uses two models to hold the data: a parent model that represents a reservation (instead of an event) and a child model that represents one of possibly many, non-contiguous dates for this reservation.

If you want to get up and running quickly, you can check out the test application that we’ve put together http://github.com/broughten/reservation_calendar_test_app to see how all of the moving parts work together.

Mike

1. The holidays. So much eating so little time.
2. Mike and I have been working our asses off on two things that will be announced very shortly. One is an open source project for the Rails community and the other is a for profit business for surf travel. Both will see the light of day before the end of January!

Hang tight….
–Jon

Design bandwagons, more politely called ‘design trends’ are a very good thing. They make it so that you don’t have to reinvent the wheel for every new website you make. You can just look at some good examples of what you want and extrapolate.

But the moral of this story is be careful when you do this…

As I got ready to build my surf travel website, I thought about the websites I visit often that I like. I like the new design bandwagon that I’m not sure how to name. It’s the Ruby on Rails, big button, rounded box, san-serif, low intensity colors, and clean drawn images thing that has been going on in lots of new websites lately.  Some examples? Vimeo.com, Twitter.com, Shopify.com

The Vimeo WebsiteShopify

The Shopify Website

So when I set out to create a surf travel website, I went straight to a few of my favorite websites and started ‘paraphrasing’ their designs. The result was something I thought looked pretty sweet. Then a friend saw it and said, “Well I like it but it doesn’t look very Surfer.”

WHAT!!!??? But it looks so web 2 point oh-y and nice and it’s easy to read, and it follows good design principles and it uses one of my favorite pictures, and …. … you know what? You’re right. It doesn’t look very surfer.

This is when it hit me. The neato big button rails-y 2.0ey design that I wanted might be fine for a market of tech savvy, possibly hipsterish, late-twenties to mid thirties, internet marketing loving, social media slinging Bay Area or Chicago types, but it’s not what surfers want.

The new fangled rails/web 2.0ey/big buttoney/low-color-intensity websites may be the culmination of years of industry progress and user research and plain old human intuition on what’s ‘good’, but they are not surfer!

So I took a look at some surf websites, and sure enough. Those sites have their own ‘bandwagon’.  I’ll call it electric blue meets black and white with heavy contrast and sharp corners with high exposure ocean and wave imagery thrown in. And every surfer website from magazines to stores to live streams of competitions is squarly within the bandwagon.  Take a look at Surfing Magazine, Transworld Surf Magazine, a contest Website from the Hawaiian Triple Crown, and Billabong:

The Surfing Mag Website	The Reef Hawaiian Pro Website
The Transword Surf Website	The Billabong Website

The proof is overwhelming. These companies have no trouble attracting surfers, and surfers have no problem supporting these companies. If my website was to have any chance of success, I needed to switch design bandwagons.

I think the best piece of advice that my friend gave me regarding choosing the right web design (and therefore jumping on the right bandwagon) was this: Ask yourself whether the webdesign you chose is something that makes you happy or if it’s something that will make your customers happy. Too often the answer is the former, and it should always be the latter.

A little background is in order here for those new to my world.  I’ve been doing software/web development for 10+ years now and have worked with many companies, big, small, startup, established and everywhere in between.  One company I even worked at twice, returning after a small stint working remotely for another company that was full of folks from a previous employer.  Everyone that I have worked with at these companies has been a good person; some I got along well with personally and others not so well but that’s the way it is.  Along this path I have learned many different technologies and methodologies for developing software.

Another part of my life is a study, practice and teaching of the ancient tradition of Yoga.  Yoga has been part of my life for almost as long as technology has been a part of my life.  The yogic path has been just as exciting and event filled as my technology path, filled with many good people, many good schools of yoga and many teachings that have help shape the person I am today.

In September 2008, I decided that it was time for me to strike out on my own as a independent developer and started Samyama Technology Solutions, LLC (www.samyamatech.com).  My purpose was to allow me work to merge the two parts of my life, to practice applying the teaching of Yoga to the technology world to serve my clients and myself.  I just didn’t feel like I was able to do that while working within another company because it always seemed like the culture of my employer trumped my desire for that merger, almost like I was swimming upstream in the corporate river.

Here we are just over a year later and I have to say that the answer to the question of “Why do I enjoy working for myself so much?” is because the fundamental direction (or dharma for you yogis out there) of my employer and myself are in line.  You might be saying to yourself “Duh silly since you are your employer and the only way for them to be different would be for you to have a split personality”.

A couple of months ago I would have thought that working for myself was the only way both my direction and my employers direction would be in line.  In the past couple of months I have been exposed to the Ruby on Rails world (coming from a PHP/.Net world previously) and have found some people/organizations/beliefs that now make me rethink the idea that working for myself is the only way for this alignment to happen.  I now feel that there are companies/people/systems out there that I could work with/for as an employee and still be able to continue my goal of combining the two parts of my world.

No it’s not those previous companies/people were doing anything wrong.  It’s just that their way of doing business didn’t align with the direction that my life was going.  I was spending too much energy trying to “fit in” and that was taking a toll on me.  I wish them all the luck in their endeavors and I am sure that many of them will be successful.

Thank you to all of those companies/people who have given me the opportunity to get to where I am today and thank you to all of those “new” people who have shown me that some day in the future I may be once again part of a team of people moving in the same direction in a corporate culture.

A big shout out to the folks at 37Signals (www.37signals.com) for being so open with their philosophies on business and development/design.  Another big shout out to the whole Ruby on Rails community for being an inspiration and mentor as I begin my journey down the Rails track.  I’m hooked and look forward to a long, fruitful career doing Rails development.  They have really taken the mantra of “developer happiness” from Ruby and made it evident in Rails, both from a code perspective as well as a culture.

I am sure that there are many other folks out are just as inspirational so I ask you to define your direction/dharma as a developer and a person and seek out those that help you become better at both.

Mike (@mikegehard on Twitter)

Since I was using javascript rather than ERB to create the hidden input tags in the HTML, I needed to know exactly how to construct my tags to tell rails what to do with my nested models.

First a quick definition of Nested Model forms: These are forms where you manage an object and associated child objects within the same form.  For example, you might create a room (such as a hotel room) and it’s associated bookings in one form.  Another example closer to what I was trying to do is to update a room by adding and removing bookings within a single form.  The official Rails blog discusses it in some detail here.

So, rather than boring you with everything that didn’t work, allow me to get right to what works.

When using nested model forms, you can add new child objects to your model by ensuring your html form has properly named input tags.  Each input tag with a rather convoluted name (full of brackets like this: project[task_attributes][]) results in a new child object getting created with the name set to whatever is in the ‘value’ attribute of the html tag.

What I found odd is that delete didn’t seem to work the same way.  It turns out that in Rails 2.3.4 it is necessary to provide pairs of hidden input tags for each child you want to delete from your model.  This works because Rails figures out that it must group the two inputs together; one to define the id and the other to signify the delete.

Like this:

<input type="hidden" value="56" name="room[bookings_attributes][][id]"/>
<input type="hidden" value="1"  name="room[bookings_attributes][][_delete]"/>

This method raises an important concern, though.  Would this start failing if I had multiple children to delete in one server request?  Also what would happen if there was a mix of inserts and deletes?  Further testing showed odd behavior.  The only way I have been able to get this to work is with pairs of hidden inputs as follows:

<!-- Add a booking -->
<input type="hidden" name="room[bookings_attributes][][id]"/>
<input type="hidden" value="11/18/2009" name="room[bookings_attributes][][date]"/>

<!-- Delete a booking -->
<input type="hidden" value="15" name="room[bookings_attributes][][id]"/>
<input type="hidden" value="1" name="room[bookings_attributes][][_delete]"/>

<!-- Delete a booking -->
<input type="hidden" value="16" name="room[bookings_attributes][][id]"/>
<input type="hidden" value="1" name="room[bookings_attributes][][_delete]"/>

<!-- Add a booking -->
<input type="hidden" name="room[bookings_attributes][][id]"/>
<input type="hidden" value="01/22/2010" name="room[bookings_attributes][][date]"/>

These get translated to parameters as follows:

{"commit"=>"Update Reservation!","authenticity_token"=>"blah",
    "id"=>"1",
    "room"=> {"bookings_attributes"=>[{"id"=>"", "date"=>"11/18/2009"},
                                      {"_delete"=>"1", "id"=>"15"},
                                      {"_delete"=>"1", "id"=>"16"},
                                      {"id"=>"", "date"=>"01/22/2010"}
                                     ]
             }
}

<input type="hidden" value="1" name="room[bookings_attributes][16][_delete]"/>

{"booking_attributes" => {"16" => {"_delete" => "1"}}}

Six months ago I was told by my dental hygienist that my gums were not doing so well in terms of health.  This made for a somewhat uncomfortable (ok it was downright painful) dental cleaning.  She said that flossing was really the key to keeping my gums healthy, keeping my teeth in my mouth and making visits to the dentist more “enjoyable”.  I took it upon myself to help myself by flossing more regularly.  Yes I missed a couple of days but for the most part I flossed every day.  It really only takes 5 minutes at most to do a good job in there…which you can easily make up by reading 5 less minutes of the Internet (or at least this is how I found the time).  Today’s cleaning was a breeze compared to last time.  Yes it was still a little uncomfortable but nothing compared to the last time.

So what does this have to do with test first development?  We’ll just this morning (before the dentist’s visit) I was in the process of refactoring a bunch of Rails code to add a new object hierarchy for some new requirements.  To make a long story short, my refactoring broke a bunch of code (as one would expect).  Thanks to our suite of existing spec code, I now had a laundry list of tasks that were needed to properly integrate the new code.  After addressing all of them and tweaking some views (we don’t have view specs but hey nobody is prefect), I fired up the app and it all just worked.  Until I started working on Rails sites, all of that spec code would not have existed.

I couldn’t imagine what might have happened had we not taken the TFD (test first development) route with this project.  Yes it takes a little more time up front to write the tests (just like flossing) but the next time you have to do some major work in your application (which is regular just like visiting the dentist’s office)  the experience won’t be as painful as it could be.

Today’s experiences with TFD as well as the dentist office have made me a firm believer that both regular TFD and regular flossing makes my life a little easier.  I vow to no longer look at writing tests as wasted time but an investment in pain saved down the road.  I hope that anyone that reads this either starts doing test first development, or maybe even flosses a little more regularly and uses this analogy when preaching the wonders of TFD.

– Mike Gehard

Technically speaking, I wanted to create collections of child objects on a parent object where the membership of each collection depended on whether the parent and the child shared an attribute in common.

In simpler terms, imagine you have a group blog.  Each post in the blog is written by one of several authors.  A Post belongs to an Author.

Then imagine that each Post can have many Comments.  Once again a comment belongs to an Author.

Each Post could have many Comments.  Some of the comments will be owned(written) by the same Author as the Post and other Comments will be owned by other Authors.  In your application, you may find it valuable to know the difference, and, moreover, to be able to access each group of comments for each Post as a collection.

I’m sure there are many working ways to do tis, but here’s the way I stumbled upon last night and I think it’s sahweeeet.

First, let’s look at our Post model before adding these collections:

<br />
class Post &lt; ActiveRecord::Base<br />
  belongs_to :author<br />
  has_many :comments<br />
end<br />

And the Comment model:

<br />
class Comment &lt; ActiveRecord::Base<br />
  belongs_to :post<br />
  belongs_to :author<br />
end<br />

I won’t show the Author model. All that is important about it is that it has an id and that it can own Posts or Comments or both.  Now say I want to actually differentiate between comments created by the Author of the Post and comments created by other Authors, but I don’t want a separate model for each type of comment.  I just want the one Comment model.  Here’s what I mean:

For a given Post, I want to access all the Comments that are owned by the same Author that owns the Post.  Let’s call these AuthorComments,

and

for a given Post, I want to access all the Comments that are owned by someone other than the Author of the Post.  Let’s call these ReaderComments.

As I mentioned, there are probably several valid ways to do this.  A few that come to mind are 1) Actually having two seperate model classes to do it. 2) Using find by methods on the post. 3) Using named scopes on Comments and retrieving the lists via @post.comments.byauthor or @post.comments.byreader

I chose a road less traveled.  In the name of less code means less to maintain (as long as it’s readable), I searched high and low for a way to use ‘has_many’ to accomplish this job.  I ended up finding it in this other blog posting: http://www.dweebd.com/ruby/has_many-with-arguments/ by a guy who’s name might be Duncan Beever.  He was trying to do something a little different, but the nugget I needed was in there.

Below is the updated Post model with the magic.  These are litterally the only two lines I had to add to achieve the functionality I’ve been describing:

</p>
<p>class Post &lt; ActiveRecord::Base<br />
belongs_to :author<br />
has_many :comments<br />
#note: learned out to create associations below<br />
#from http://www.dweebd.com/ruby/has_many-with-arguments/<br />
has_many :author_comments,<br />
         :class_name=&gt;'Comment',<br />
         :conditions=&gt; 'author_id != #{author.id}'</p>
<p>has_many :reader_comments,<br />
         :class_name=&gt;'Comment',<br />
         :conditions=&gt;'author_id = #{author.id}'<br />
end<br />

As Duncan says in his blog, “But all is not lost! A poorly-documented feature of the association methods is the lazy evaluation of conditions.”  The single quotes on the condition clause tell the interpreter to wait to evaluate the contents until it needs to. When the conditions clause is evaluated, the author method will be called on the comment.

When this worked the first time I tested it, I couldn’t believe it.  So I double checked the SQL generated when accessing the list of AuthorComments for a Post, and this is what I saw:

</p>
<p>SELECT * FROM &quot;comments&quot; WHERE (&quot;comments&quot;.post_id = 15 AND (author_id = 44))</p>
<p>

It’s getting all the comments that belong to a particular post that shares the same author_id as the comments it’s getting!  My advice to anyone out there that is looking to try this is to only use this technique if there is no internal difference in behavior between the objects in the two collections.  If the objects within the two lists need to be different in any way other than their name, then they should really have their own model classes.

Thanks for reading.

–Jon Christensen