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.

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

It’s exciting to see the convergence of my two favorite languages coming along!

require 'irb/completion'
ARGV.concat [ "--readline", "--prompt-mode", "simple" ]
IRB.conf[:EVAL_HISTORY] = 1000
IRB.conf[:SAVE_HISTORY] = 1000
IRB.conf[:HISTORY_FILE] = File::expand_path("~/.irbhistory")

Now when I fire up irb or script/console I get full readline support including tab completion (for example type Time:: and hit tab), reverse command search (control-R), and saved command history so when I exit and restart my command history is still there!

List states = new ArrayList();
state.add(State.CA);
state.add(State.WY);

Then today I read about using an anonymous subclass with instance initializer to initialize a collection which appeals to the block loving Rubyist in me:

List states = new ArrayList() {{ add(State.CA); add(State.WY); }};

Another approach shown to me by a new co-worker specific to Lists (that involves creating an extra array) but is also quite short is:

List states = Arrays.asList(new State[]{State.CA, State.WY});

Update: Ricky Clarkson pointed out the best solution so far in my opinion (requires JDK 5 or higher) using varargs and generics:

List<String> list=Arrays.asList("rocks","my","world");

I had one minor problem and it was that we connect to multiple databases so we have multiple session factories that interact with EhCache. Hibernates org.hibernate.cache.EhCacheProvider now expects one configuration per sesssion factory which I wasn’t too excited about given we have 51 databases (1 database per state plus Washington DC) and it’s been working fine for 2 years with one cache provider. The problem caused this exception:

 Invocation of init method failed; nested exception is java.lang.NullPointerException
    [java] Caused by: org.springframework.beans.factory.BeanCreationException:
       Error creating bean with name 'surveysSessionFactory' defined in class path resource
          [gs/data/dao/hibernate/applicationContext-hibernate.xml]:
          Invocation of init method failed;
          nested exception is java.lang.NullPointerException
    [java] Caused by: java.lang.NullPointerException
    [java] at net.sf.ehcache.CacheManager.detectAndFixDiskStorePathConflict(CacheManager.java:269)
    ...

However, I wasn’t the only person who had this problem so a quick search turned up that EhCache now offers the net.sf.ehcache.hibernate.SingletonEhCacheProvider and switching the hibernate.cache.provider_class property to this new provider solved the problem and allows us to continue using a single cache provider.

If you’re using JAXP on a 1.5 JDK (where Xalan is now under com.sun.org.apache) or a 1.4 JDK (where Xalan is under org.apache) then the only way to override the version of Xalan is to put it before rt.jar in the bootclasspath. Sure enough, there appears to be some issue with Xalan in the 1.4.2 JDK where large XSL transformations are extremely slow!

Here’s what it looks like to get Java to use your own version of Xalan:

java -Xbootclasspath:xalan-2.X.X.jar:$JAVA_HOME/jre/lib/rt.jar …

1. Use a MySQL or PostgreSQL dump that gets imported before the tests are run. I’ve never seen this approach used with Oracle, most likely because it’s such a PITA to export to text (or at least it used to be)
2. Just create the schema before the tests and then populate the test data in code
3. Use a database test fixture tool such as the XML based DBUnit for Java or Ruby’s YAML based fixtures

I have a strong preference for database test fixture tools because they work across databases (often a requirement at ISV’s) and generally offers tools to easily export fixtures in addition to importing them. However, the ability to export fixtures from your database to a fixture file is sometimes overlooked but it’s vitally important as populating those fixtures gets really time consuming if you need to type it all in. The most common use case I run into is when I pull rows of data from production into my local database and once I’m happy with the sample data want to export it into a fixture file.

At GreatSchools we’re a Java shop and we use DBUnit which does a fantastic job of exporting and importing database test fixtures. Now that I’m using Ruby on Rails on outside projects though I was starting to burn out having to manually write the fixtures.yml files by hand because Rails doesn’t offer an export facility out of the box. In this particular case I was parsing NOAA weather forecasts which I do using script/runner via cron to retrieve over HTTP and populate the database with. They can be fairly lengthy and I needed dozens of records for the tests and the thought of having to write the YAML fixtures file had me scared!

Sure enough after a little web searching I found Chris McGrath and Nathaniel Brown’s export fixtures plugin and I’m a happy camper again!

Here’s how you install it:

script/plugin discover
script/plugin install export_fixtures

Then to use it I populate the tables in question with sample data and then run:

rake db:fixtures:export_for_tables TABLES=table1,table2

It’s a little shy on giving you feedback but once it completes you’ll find table1.yml and table2.yml in the test/fixtures directory with all of the data from your tables in it. They also have other options to export data from another database such as production or export data selectively based on a query.