Ruby
sum = [1,2,3,4].inject(0) {|result, value| result + value}
Scala
val sum = Array(1,2,3,4).foldLeft(0) ((result, value) => result + value)
Groovy
sum = [1,2,3,4].inject(0) { result, value -> result + value }
Python
sum = reduce(lambda result, value: result + value, [1,2,3,4])

One of the jobs of a good programmer is to make their code readable and in this case by naming the variable sum it’s obvious what’s going on to the right so if you can simplify the anonymous function or use syntactic sugar to reduce the amount of code there’s a good chance you can improve the readability as follows:

Ruby
sum = [1,2,3,4].inject(:+)
Scala can either reduce the anonymous function
val sum = Array(1,2,3,4).reduceLeft(_+_)
or in Scala 2.8 they added the sum method
val sum = Array(1,2,3,4).sum
Groovy can't reduce the anonymous function but has a sum method
sum = [1,2,3,4].sum
Python can't reduce the anonymous function but has a sum function
sum = sum([1,2,3,4])

Then even if the programmer reading the code is coming from another language and doesn’t know :+ or _+_ you’ll still have improved readability because they certainly understand how a sum is computed and can move past the line of code instead of having to read 3-4 lines of a for loop for something as simple as a summing operation. I love the balance of being very concise with the simple stuff so that I can be more verbose with the complex stuff, whereas in Java even the simple stuff is often extremely verbose.

There is of course the extreme of making your code too concise. Look no further than write-only languages like Perl to see where too much conciseness and obfuscation can lead to unmaintainable code.

This example is only trivial and somewhat contrived but I find that newer languages like Ruby and Scala give you significantly better tools to elegantly dial up or down the conciseness than Java or C# resulting in less code + more readable code = easily maintainable code.

As an example, I used just about every conciseness trick in the book I knew of when composing my submission for the 3rd Ruby Challenge’s Shortest Path Algorithm and I only discarded the ones that I thought obfuscated the intent. I like to think the reason my submission won was precisely because it was concise while still being readable. Writing that same algorithm with the same level of readability in Scala would be easy but in Java it would have tripled the lines of code hurting readability somewhat.

...
Attempting to uninstall rails-2.3.5
Unable to uninstall rails-2.3.5:
Gem::InstallError: cannot uninstall, check `gem list -d rails`
...

Following the instructions I then ran gem list -d rails noting the install path for newer gems was now /Library/Ruby/Gems/1.8 whereas the older gems that cleanup was failing on were in /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/gems/1.8. So the solution was to run cleanup once while overriding GEM_HOME as follows:

sudo sh -c 'GEM_HOME=/System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/gems/1.8 gem cleanup'

That allowed cleanup to remove the older gems in the old path and now sudo gem cleanup is once again working.

I’ve been doing some iPhone and iPod Touch development and if like me you’re used to web development in languages like Ruby, Java, and Python, the learning curve to build a native iPhone app in Objective C is quite steep. Since my applications are online (in that you need to be connected for them to be useful) I was pysched to find a much easier way using two great open-source tools:

iUI consists of Javascript/CSS/images that allow you to build a mobile version of your app that looks and feels just like a native iPhone app

PhoneGap lets you create an iPhone application (that can be submitted to the app store) that displays a framed mobile version of your site

To build your iPhone app:

1. Make an iPhone/iPod Touch friendly version of your site with iUI (which your users can access in mobile safari)

2. Bundle it as an iPhone application (so the user has an app store version they can install) using PhoneGap and submit it to the app store. What’s even better is that with PhoneGap you can also target Blackberry and Android devices.

As a web developer I’m not sure how they could make it any easier for me, sweet! Plus you get the double exposure of the app store or when users visit your site with their iPhones they get the mobile version of your site.

To that end one of the tools I want to give a shout out to is the MySQL Performance Tuning Primer Script. You download and run it against a production system (that has preferably been running under normal load for a day or two so that it’s gathered stats). It’s a read-only script so you don’t need to worry about it changing anything but it makes some great recommendations about which tuning parameters may need adjustment. Here’s a snippet from from a production server:

KEY BUFFER
Current MyISAM index space = 173 M
Current key_buffer_size = 1 G
Key cache miss rate is 1 : 1003
Key buffer fill ratio = 7.00 %
Your key_buffer_size seems to be too high.
Perhaps you can use these resources elsewhere
…
…
…

It’s no replacement for a DBA but if you want to get a somewhat sane my.cnf going for your particular application it’s a great place to start!

Selenium Selenese Continuous Integration Runner

on GitHub in the hopes that it will save other people time when trying to get their Selenese tests running from a continuous integration server. It’s very simple but one thing I battled with was that I had to patch the selenium JAR to get it to work with Firefox 3.0. It should work fine in any continuous integration server regardless if it’s Hudson, Cruise, Cruise Control, Bamboo, etc.

The functional testing products I’ve used that drive a real browser include Test Complete (commercial), Selenium, and Watir. I think all 3 do a good job but one thing I like about Selenium is that it’s dirt simple to get a user productive with the Selenium IDE Firefox plugin. However, that benefit is also the most limiting factor of the Selenium IDE which is that to be able to re-open tests in Selenium IDE you have to save them as Selenese (which is the most limited of the testing languages that Selenium supports). Still, I think Selenese is a reasonable choice for a lot of organizations that need a moderately sophisticated functional test suite.

Update 7/8/2009: With the latest batch of contributed patches standalone migrations now works just like Rails migrations
Update 12/26/2008: I switched standalone migrations to use a Rakefile instead of a Ruby script.

In my work managing websites I end up working in Ruby, Java, and PHP. In everything but Rails managing the schema requires rolling your own solution. As a result I’ve started using Rails migrations in non-Rails projects to manage the schema. It’s not much code but I figured others might benefit from it so I created a little Github project called standalone migrations.

It’s based on Lincoln Stoll’s blog post titled Stand-alone ActiveRecord migrations and David Welton’s blog post titled Using Migrations Outside of Rails.

Assuming you have Ruby and Gem installed on your machine, here’s how to use it:

gem install -y activerecord rake mysql
wget http://github.com/thuss/standalone-migrations/zipball/master (or fetch it using git)
unzip it, and mv to something like my_non_rails_project/db
cd my_non_rails_project/db/ (or wherever you put it)
cp config/database_sample.yml config/database.yml
vi config/database.yml
./new_migration some_user_story
vi migrations/*_some_user_story.rb
rake db:migrate (this applies your newly created migration)

I’m pleased to say that after 3 hours I had the install done and all of my software installed and working including Jetbrains IDEA, Netbeans, Skype, VirtualBox, Flash plugin, Java plugin, Web Developer Toolbar, and Firebug. Apparently things have gotten a little better for 64 bit Linux over the past year and a half! However, I’m still running into odd issues every now and again related to both Sun’s 64 bit Java (IDE and Jetty occasionally hangs) and the the Open JDK browser plugin which is still buggy. Hopefully future updates will help address these issues. Anyhow, I thought I’d throw out the links I used to get everything working:

Fonts
Howto: Install Mac Fonts on Ubuntu
Make Firefox in Ubuntu look much better

Skype
Add the Medibuntu repository
sudo apt-get install skype-static

Flash plugin
Install Flash 10 Under Ubuntu Linux 64 bit Edition

Java plugin
sudo apt-get install openjdk-6-jre icedtea-gcjwebplugin

October 4th, 2007 was my last day as the VP of Technology at GreatSchools when I handed the reigns over to Chris Pickslay so that Susan, Sequoia, and I could take off on our sailboat to Mexico for 6-12 months. It was a great 4 years leading the tech team at GreatSchools and I was sad to leave such a terrific job and group of people but both Susan and I were really feeling the itch for some adventure under sail. Our plan was to explore the Baja peninsula, mainland Mexico, and of course the lovely Sea of Cortez.

8 months have passed and we had some great fun and adventures which you can read about on our sailing blog if you’re interested, it all starts here when we moved aboard the boat. However, with hurricane season approaching we decided to put the boat into dry storage in San Carlos Mexico for the summer and return home for 6 months to work and catch up with friends and family.

Starting June 10th I’ll be back at GreatSchools 3 days a week as a contractor until we go back to Mexico and this time I’ll be working for Chris instead of the other way around!

Having worked with a lot of front-end developers I can confirm that almost all of them would benefit from this book since most still

• use floats for layout as opposed to position absolute (which is easily misunderstood because it’s positioning relative to the containing block)
• few seem to regularly run their XHTML through a validator (a pet peeve of mine)
• and even fewer seem to know to employ the concept of a CSS reset

It’s hard to convey all of the great stuff in this book but I can almost guarantee that if you work with CSS this book will open your eyes to a better way of doing things.

Publishing dynamic content on your website in a format that you can style with CSS has gotten a whole lot easier with Google’s simple JSON based Javascript API’s. The two I’ve found myself playing with lately are the Google Ajax Feed API for publishing RSS and Atom feeds and the Google Spreadsheet API
for publishing little snippets of text that should be easily editable.

Say you want a simple headline on your homepage that you can change daily. Here’s how you’d do it with the Google Spreadsheet API:

1. Create a spreadsheet making the first row the column headers (important because you’ll refer to the cell by the column header):

2. Go to the publish tab and publish the spreadsheet: http://spreadsheets.google.com/pub?key=pouqRkV5D_eZT_VdOKu7CQA. Note in this example the key is pouqRkV5D_eZT_VdOKu7CQA

3. Use a simple container div and some javascript to display the field:

<div id="headline"></div>
<script type="text/javascript">
function displayContent(json) { document.getElementById('headline').innerHTML = json.feed.entry[0].gsx$html.$t; }
</script>
<script type="text/javascript"
src="http://spreadsheets.google.com/feeds/list/pouqRkV5D_eZT_VdOKu7CQA/od6/public/values?alt=json-in-script&callback=displayContent">
</script>

Note: the spreadsheet key in the URL that needs to be replaced. Also, entry[0] refers to row 2 in the spreadsheet (because row 1 contains the column headers and is not considered an entry):

4. The text appears dynamically on the page:

Palm releases Linux based Foleo

5. When it’s time to update, make your changes to the spreadsheet, go the publish tab, and republish it and the changes will appear on your site!

The only real downside I can think of with this simple approach is that it’s not SEO friendly so if you want all search engine crawlers to follow those links you publish, you’re better off with a non-javascript solution. The Spreadsheets API google group is a good resource and Pamela Fox has some examples to look at.