After months of favorites-list marking and bemoaning the empty spaces on our white(ish) walls in our new(ish) high-ceilinged if not alll that large apartment, we spent most of this rainy Sunday shopping away on Etsy.

I’ve bought a few things there before, a print and some jewelry, but mostly I’ve just clicked around, saving copies of prints to put in my computer desktop background rotation, where they would lie in wait for the eventual day I’d give in and drop some money on the ones I really liked a lot. And putting painting after print after t-shirt into my favorites list (represented by a cute little heart).

Just in the interface, you can tell the people behind Etsy really care about getting their artists’ goods out to the public, including some very nice shopping features like interviews with artists, galleries (public lists by users), and the innovative if eventually unhelpful color-based shopping path. They have some performance issues at times (we seemed to have abnormally slow page load times around 6-7pm), but considering their relative newness as a tech company and image-content-heaviness, this isn’t all that shocking. If Etsy can figure out how to do Amazon-style recommendations with their content, they could have something truly amazing as opposed to just a great place to buy art.

After hours of deliberation (there’s a ton of stuff on Etsy!), we narrowed it down to a bunch of pieces that really struck us as befitting our styles. A not insignificant but fortunately also not ridiculous amount of money later, we walked off with (technically, sat around and waited for) a nice big pile of art to brighten up those sterile walls.

Target Freedom (David V Moore)

Pele (David V Moore)

Chlorophyll Dreams (David V Moore)

Together (Mattsart)

The Bunny Sisters (Sarah Ogren)

Gone To Earth, Plate Two (Magic Jelly)

The Cherry Berry Monster (Yumi Yumi)

Sitting Still (Yumi Yumi)

The Guava Berry Monster (Yumi Yumi)

Bubblegum Betty (The Black Apple)

Cat And The City (Bigrin Design)

The Sound Of Young America - http://maximumfun.org/

The first podcast I recommend to people if they ask, and often even if they don’t. Other people have told me this show is like NPR, but I’ve never been able to make it through more than a few minutes of anything on NPR without becoming bored to tears. Instead, TSOYA’s Jesse Thorn has the gravitas of an old-time radio interviewer, but the youthful energy of an idealistic recent college grad. Produced from his living room, this show has that honest indie feel while simultaneously maintaining highly professional quality. There’s a very good companion blog as well.

Never Not Funny - http://podcast.jimmypardo.com

This is the most consistently funny podcast out there for my tastes. Never Not Funny is the first thing I listen to on Monday’s commute (new episodes come over the wire on Friday evening).

Air Out My Shorts - http://www.theitspot.com

Sophomoric humor with a contagious manic drunken energy. The two hosts — “Preston Buttons & The Word Whore” — read listener-submitted short stories while progressively getting drunker and drunker. There have been some disappointingly frequent stumbles lately with scheduling, and the show suffers greatly when they’re not co-located and instead record over the phone (using skype, judging by the sound quality?). The “let’s call a friend” sketches are hit or miss, but I did find myself missing them when they stopped for a while.

AST Radio - http://podcast.aspecialthing.com/

The production quality and focus of this conversational podcast have skyrocketed since its stumbling debut a year or two back. AST Radio is the only source I’ve encountered where you get to delve deep into the motivations and opinions of a slew of (usually west coast) comedians. Unfortunately, new episodes are few and far between.

The Sound Of Young America: The College Years - http://feeds.feedburner.com/collegeyears

With the format of a morning show (regardless of actual time of day of original broadcast), TSOYA: The College Years is an exceptionally entertaining broadcast done by intelligent college students. It’s intriguing to see the origins of the current incarnation, with sketches and banter which often entertain me more than the new episodes.

Jordan, Jesse, Go! - http://feeds.feedburner.com/thornmorris

Pretty much the same as TSOYA: The College Years, although down to two hosts from the original trio, and recorded now instead of years ago. This also has comedy-celebrity guests like Judge John Hodgman.

PopSci Podcasts - http://www.popsci.com/podcasts/

Eight to nine minutes of Jonathan Coulton interviewing people involved with stories in Popular Science. A framing device claiming that he’s doing all the interviews in an empty office on the moon provides an excuse for the low quality of the audio (it’s recorded via Skype)

Escape Pod - http://escape.extraneous.org/

When commutes and local travel cause me to burn through all of the new episodes of the above, it’s time to hit the well of Escape Pod, the best short-story podcast I’ve found. Focusing on science fiction short stories, this usually runs in the 20-30 minute range. They actually pay their authors as well, which is excellent.

Make your own at b3co.com

It’s low on features, in that there’s no concept of stored state, user accounts, or Google Map integration, but it’s a fun toy nonetheless. I’d love if it covered other rail options like MetroNorth and the Shinkansen, but without some sort of easily-managed public submission process (or even a Wiki-style public management process), it’d be nigh impossible for a site to accurately cover the world’s public transport options.

When viewing large tables of data via a web interface, it’s often desirable to limit the visible rows to a single column’s value. This can be done very efficiently through backend coding, but can require knowledge of programming languages and more access to a server environment than many users have or want.

In the case where the data set is large enough to be unwieldy, but not so large or business-critical to need a multi-tiered system to manage this filtering, it may be good enough to just do all filtering on the client side.

I began writing this after using Stuart Langridge’s excellent sorttable in a number of quick & dirty admin tools. I wanted something that satisfied the principles of unobtrusive DHTML, and which allowed me to add functionality without much effort.

TableFilter is in its initial version, so if anyone finds any bugs, or has any suggestions, I’d love to hear about them.

An interesting feature Yelp’s included is the ability to have an animated change between multiple views. Williamsburger reviews are more often than not clustered in the East Village, Williamsburg, and Park Slope, so the way the map refocuses itself is very nice. They’ve also made properties like the animation speed, badge size, and colors configurable to allow better integration into a site.

The Yelp badge does seem to have a bug or two in Firefox as of the original date of this posting, one of which is pretty major. When the map initializes, one review’s popup window opens by default, and it’s impossible to get it to close. This doesn’t happen in IE, and it only happens intermittently in Firefox, so I suspect it’s difficult to reproduce. It’s brand new functionality, though, and it went into production with a bunch of other new features this week, so I suspect it’ll be fixed shortly.

Get your own badge here.

Core Functionality

• SessionSaver .2 (Extension)

  Considering how frequently Firefox crashes on both my Windows XP and Mac OS X machines, SessionSaver is a life saver.

• Adblock (Extension)

  I have a difficult time using the internet at all on computers which don’t have this installed. I suppose I’m depriving some sites of revenue, but the sheer joy of making flashing monkey banners leave my screen far outweighs any guilt here.

• Tab Mix Plus (Extension)

  Tab Mix Plus gives you more control over Firefox’s tabs. I have my suspicions that this occasionally causes trouble with JavaScript-intense sites, as I’ve noticed errors pop up in my FireBug display. The abilities to re-order tabs and force address bar changes to spawn new tabs are very convenient.

• BugMeNot (Extension)

  BugMeNot is absolutely essential for reading sites like the New York Times or the Washington Post, who confusingly still mandate registration to read the free content. This extension cuts the trip to bugmenot.com out of reading the news.

Thirdparty Integration

These extensions really only have value if you use these sites. I’m an avid user of all three, so I get a great deal of mileage out of them.

• Del.icio.us (Extension)

  With a simple toolbar “Tag” button, posting to del.icio.us becomes an easy task.

• GMail Notifier (Extension)

  The GMail Notifier is a simple grey / red status bar indicator with a number letting you know how many unread messages you have. The only problem is a bug preventing the notifier from consistently logging back in if disconnected, so the notifier can sometimes stay grey for a day or two until you get suspicious and check.

• Bloglines Toolkit (Extension)

  This extension has two parts: another simple notifier (a blue icon with a additional red dot for unread posts), and additional options in the context menu to help add new feeds to your Bloglines account. The context menu options seem to have a lot of trouble consistently functioning under Firefox 1.5, though, which can lead to a lot of frustration.

Developer Tools

• FireBug (Extension)

  Allowing far more powerful JavaScript debugging than Firefox’s already reasonably good native console, FireBug has the additional benefits of integration into the status bar and inline display of DOM element data. This extension also provides the ability to monitor XMLHttpRequest activity in detail, which is hugely useful when debugging JavaScript apps.

On Wednesday, 25 January 2006, Google began providing filtered search results on Google.CN, contributing to the Chinese government’s ongoing censorship of the internet. This side-by-side viewer is intended to illustrate the implications of this censorship by providing side-by-side comparisons for search terms.

A few interesting queries:

• Tiananmen (Images)
• Falun Gong (Images)
• Taiwan Independence (Web Search)

It seems that, even for terms like “democracy” and “freedom“, Google.CN still returns a reasonably good spread of links. Whether or not these pages can be accessed from within China itself is a far different issue, of course.

Please leave a comment if you find any search terms with frighteningly different results between the two versions; I’d be interested what other people can find.

The OpenSearch API provides a flexible common standard for XML-powered searches. WordPress OpenSearch 1.0 worked on WordPress 1.5, but a few changes in the way WordPress deals with DB configuration and HTTP GET parameters caused it to fail in WordPress 2.0. Thanks to tips from James E. Robinson, III, version 1.1 of this plugin now wraps WordPress 2.0’s search functionality. This code should be generic enough to allow anyone to quickly add OpenSearch RSS feed functionality to a WordPress 2.0 site.

The source of version 1.1 is freely available for download here.

Here are six quick steps to getting your WordPress blog running an OpenSearch RSS feed:

Step 1

Download the WordPress OpenSearch code.

Step 2

Unpack the tgz contents into some directory under your wordpress installation. I chose /wp-content/code-plugins/wp-opensearch/. The “code-plugins” part isn’t strictly necessary; that’s just where I happened to put the files, as I didn’t feel right putting them in the plugins/ directory without first figuring out how to integrate the on/off switch with the WordPress admin interface. The php files do have relative require statements which access WordPress’s wp-blog-header.php, so being 3 directories down is important (unless you want to go to the small effort of changing the “../../..” values to reflect your directory structure).

Step 3

Replace logo.gif with your own 64 x 64 pixel image.

Step 4

Open up description.php and change whatever you like. Many values have been prefilled for your convenience. The ones you should be sure to replace are the tags, sample search, and my name and email address, unless you feel like making me more popular than I should be.

Step 5

Edit your .htaccess file so that the paths hardcoded in the PHP files will match up with the actual file locations on your site. Here’s a snippet from my .htaccess file, as an example. Be sure to add this before the line containing “# BEGIN WordPress”, or the broadly-scoped default WordPress rewrites may override yours.

# BEGIN OpenSearch

<IfModule mod_rewrite.c>

RewriteRule ^os-query?(.*)$ /wb/wp-content/code-plugins/wp-opensearch/wp-opensearch.php?$1 [QSA,L]

RewriteRule ^os-description$ /wb/wp-content/code-plugins/wp-opensearch/description.php [QSA,L]

RewriteRule ^os-logo.gif$ /wb/wp-content/code-plugins/wp-opensearch/logo.gif [QSA,L]

</IfModule>

#END OpenSearch

Step 6

At this point, you should be ready to use your new OpenSearch RSS feed. Head over to a9.com and add it to your columns. They have preview functionality which lets you debug any problems you hadn’t noticed before.

The API is:

/os-query?s={searchTerms}&itemstart={startIndex}&itempage={startPage}&itemlimit={count}

I ran through the DB backups easily, as well as the very quick official upgrade script. I’ve reactivated most of my plugins, although Akismet doesn’t seem to be working anymore. I’ve fixed problems with Williamsburger Maps, as well as an issue I already knew I would need to deal with to patch the WordPress OpenSearch Plugin.

The changes I needed to make to support WP 2.0 are as follows:

1. The .htaccess file needs to have all non-WordPress regexp’s before the WordPress section, or else the new default rules will simply override any additional rules you’ve added. This appears to be a change since Wordpress 1.5, where your custom regexp’s needed to be after the WordPress section.
2. If you want to directly access a HTTP GET parameter, you can’t simply reference the variable by name, as is often the case with PHP, but instead need to use the internal $_GET function, as such:

     $id = $_GET['id'];
   

   Thanks to James E. Robinson, III’s post explaining how to patch my OpenSearch plugin for this tip.
3. Something strange is going on with relative links within JavaScript GXmlHttp.create calls. Previously, this code worked fine (there’s a .htaccess redirect behind the scenes, but I haven’t changed that):

     request.open( 'GET',
                   'wbmaps-map-info-' + WbMaps.Version + '.php?id=' + mapId,
                   false );
   

   With WordPress 2.0, I needed to change this to the following:

     request.open( 'GET', 
                   '/wb/wbmaps-map-info-' + WbMaps.Version + '.php?id=' + mapId,
                   false );
   

   Note the addition of the absolute directory path on my server, something I’d obviously prefer not to need to hardcode into JavaScript.

4. The default editor for managing posts provided by WordPress 2.0 fails miserably when formatting the interiors of <pre> tags. Granted, this isn’t an issue that most writers need to care about, but considering the tool offers an “edit as HTML” button, one would hope that it would at least attempt to respect what’s been typed into that field. Also, in the case of Williamsburger, there are enough code snippets posted that <pre> absolutely must work as expected.

   Additionally, the Markdown plugin provided with WordPress 2.0 has major troubles with <ol> and <ul> elements within table <td>’s, turning them into long hex strings, and the Textile plugin inserts unwanted <br>’s between <li> elements. None of this behavior is appropriate, although Markdown’s problems are particularly unacceptable. Markdown worked fine in WordPress 1.5, so I suspect it simply needs patching for WordPress 2.0, especially considering its “Extra” version is the eventual solution I’m now using.

   PHP Markdown Extra 1.0.1 seems to solve all of the other plugins’ problems, and my posts now render as they used to, although it seems that multiple carriage returns within <li>’s don’t seem to act as they do outside of <li>’s, causing some mashed-together paragraphs if extra attention isn’t paid to adding your own <p> tags.

What simple steps can developers take to help out the next reader down the line?

I’m not taking into account vastly more important (but more difficult to engender and enforce) practices like good design, refactoring, unit testing, and code reviews; the intent here is to document steps which require little effort but return large gains in readability. Any examples here are in Java, as that’s the language I’m most familiar with lately, but the same principles are applicable to most programming projects.

1. Define Formatting Standards

   A major barrier to understanding code in a code base maintained by a large team is the presence of disparate code formatting. Developers are often fanatical about their personal style; arguments about numbers of spaces and locations of brackets can get pretty vehement. Without explicit attention, this results in a code base with wildly different styles, sometimes even within the same file. Keeping the code style variance in check reduces the amount of effort needed to mentally parse code.

   Using an IDE like Eclipse or IntelliJ, it’s not difficult to create formatting rules for a code base. Take advantage of this to ensure that code ends up in your common standard. Auto-formatting tools (e.g., Jalopy) can also be made to work as IDE plugins or ant scripts, enforcing a common style while still allowing recalcitrant developers to continue coding in their own personal style.

   Integrating an open source tool like JCSC or Checkstyle into your ant build scripts isn’t a bad idea either. With this, you can tie code formatting into your continuous integration environment, or, if you have more draconian leanings, you can simply cause developer builds to fail if the style checks have failed. In working in large, highly geographically diverse teams, I’ve often found the latter method to be more effective, especially in keeping new team members in line.

2. Use Comments Wisely

   Comments must describe why, never how.

   I can’t count the number of times I’ve seen comments like the following:

     // add value to list
     list.add( value );
   

   In this simple case, the comment just doesn’t add any value, and is a distraction.

   In worse cases, when the code is incomprehensible without comments, a far better solution than writing comments is to clean up the code. The need for comments to describe logic is an indicator that this code is too convoluted, and should be cleaned up. Fowler calls these comments “deodorant”, hiding the smell of bad code.

3. Choose Meaningful Names

   At a previous job, we had the following three books on hand at all times: Design Patterns, a thesaurus, and a dictionary. Any time we wanted to name a class, or encountered any confusion about a variable’s name, out came one or more of these tomes. Design Patterns was usually the best of the three to refer to, if only to support industry standards and wider understandability, but having the other two around always made for some interesting discussions.

4. Avoid Acronyms & Abbreviations

   Shortening words results in confusion. Different people abbreviate things different ways, and the accuracy lost in the abbreviation far outweighs the characters saved by writing shorter code. The problem increases when a team includes developers whose first language isn’t English.

   Some industry-standard acronyms are necessary and understandable by any developer (e.g., XML, HTML). Feel free to use these, especially as they’re often in thirdparty package, class, and method names.

   This is not to say don’t ever shorten variable names. A misinterpretation of this I’ve seen far too frequently contributing to overly verbose code is the following:

     SpecialSellableProduct specialSellableProduct = new SpecialSellableProduct( );
   

   It’s just fine, especially if the method is fairly short, and there aren’t any other variable names which could be mistaken for this one, to write something like:

     SpecialSellableProduct product = new SpecialSellableProduct( );
   

   Succinct, to the point, and is better than this acronym anti-pattern:

     SpecialSellableProduct ssProduct = new SpecialSellableProduct( );
   

   Or this abbreviation anti-pattern:

     SpecialSellableProduct specSellProd = new SpecialSellableProduct( );
   

   Also, avoid practices like Hungarian notation. Appending/prepending letters to indicate variable type (nThings for ints, ISomething for interfaces) was very useful in the days of text-editors. At this point, though, IDEs rule the development marketplace, and can be configured to distinguish types of variables with color or emphasis.

5. Ban Inline Source Control

   Expandable change logs within files duplicate information readily found in your source control system (e.g., CVS’s $Log$), and don’t add value. And if there are lines of text adding zero value to your code, they’re directly reducing the clarity of that code. These can also lead to source control issues, and certainly make manual diffs more complicated.

Applying these practices to a development team can give relatively quick benefits, although as always, the way these are communicated is key. Be sure to focus on maintainability costs, as this has obvious monetary justification. It can help to adopt a common standard (like Sun’s), even if you disagree with it as a team lead, because then at least the onus of defending specific subjective style choices is deflected onto a third party.