It was a breeze getting the bundle updated, just add these lines to the Gemfile and run bundle update

gem 'rails', '3.2.0'
gem 'sass-rails',   '3.2.3'
gem 'coffee-rails', '~> 3.2.1'
gem 'uglifier', '>= 1.0.3'

Once the updated gems had installed, firing up the rails server spat a few errors out. It turns out ActiveAdmin v0.3.4 doesn’t work with Rails 3.2. Within a few hours of the Rails release there was already a fix for this which has been pulled into the activeadmin Github repo.

Bundling against the edge release is risky, but it works and all my tests were still passing:

gem 'activeadmin', git: 'git://github.com/gregbell/active_admin.git'

The last issue I had was related to using Ruby 1.9.3. WEBrick has a few issues, so I switched over to using Thin in development instead.

gem 'thin'

Overall I’ve noticed a significant improvement in speed in Rails 3.2′s development environment using Ruby 1.9.2. It feels even faster when I ramp it up to Ruby 1.9.3.

Check out the Rails 3.2 release announcement and the upgrade instructions doc.

Today I’m looking at the new “natural” reversed scrolling feature in Lion. Having used it for a couple of days now I found that I like having the reverse scrolling on the trackpad, but whenever I reach for my mouse I prefer the classic scrolling method that we’ve been using for years.

I dug around and couldn’t find any way inside OS X of decoupling them, but I came across a cool app called Scroll Reverser. It allows you to customize the reverse scrolling of the track pad and not of the mouse.

The settings might seem a bit confusing though. I have OSX set up to reverse scrolling so that it works across all applications. I then use Scroll Reverser to reverse the scrolling on the mouse from OSX’s behaviour back to the classic behaviour.

Originally when I wrote the code I knew there had to be a better way, but I only found that better way today.

I was revisiting some of that code and discovered FakeWeb.  It’s a Ruby framework that makes it simple to test code that involves HTTP requests.  It intercepts HTTP calls made through Net::HTTP and makes it dead simple to create predictable responses for those calls.

This means that tests that would have been regarded as integration tests before can be isolated from the dependency on an external server and can be executed as unit tests.  Big win!

Here’s a sample of how it works in context of RSpec:

  before do
    FakeWeb.allow_net_connect = false
    register_body = {
      :id => 1
    }.to_json
    FakeWeb.register_uri(:post, 'http://localhost/register', :body => register_body)
  end

The first line in the before block tells FakeWeb to disallow any real network connections from happening.  Every ‘connection’ must be handled inside FakeWeb.  An exception is raised if a request can’t be handled by FakeWeb directly.

The register_body variable simply contains the key-value pairs to be returned in the HTTP response’s body as JSON.

FakeWeb.register_uri then registers a verb and URI to be handled by FakeWeb, and sets the body of the response.  It’s also possible to set a status code and to handle :any verb.

Once the URI has been registered, any call made to that URI from Net::HTTP will be responded to by FakeWeb.

My tests are now running marginally faster and are far less flaky since all the external dependencies are now being substituted with a controlled and predictable stub.

To get going, just add the gem to your Gemfile and run bundler:

gem 'fakeweb'

Also check out the FakeWeb docs at RubyForge

However, in hindsight having used Slim for a while it appears Haml might have stepped a bit too far away from HTML, including some cryptic syntax like ‘%’ signs to declare tags.  Slim takes a step back towards HTML.  It still uses the significant whitespace element of Haml and removes the annoying <>’s, but keeps you closer to the actual HTML that you’re describing.

Here’s an example of Slim (taken from a presentation I gave recently)

p = link_to "New Link", new_link_path
- @links.each do |link|
  div class="link"
    div class="title" = link_to link.title, link.url, :target => "_blank"
    div class="description" = link.description
    div class="manage"
      = link_to "Delete", link, :method => :delete, :confirm => 'Are you sure?'
= paginate @links

Nice and clean. The way it should be

To install it in your Rails app, just add it to your Gemfile:

gem 'slim-rails'

Then create a view using the .slim file extension to start using Slim.

Resources to check out:
Slim Templates
Slim – Github Repo
vim-slim plugin (syntax highlighting and indent assistance)
Haml

For those using vim and the rails.vim plugin – the most recent version of the plugin supports .slim extensions for templates.

My books collection has been growing, particularly with PragProg titles.  In the last 4 months I’ve read:

• Seven Languages in Seven Weeks – Bruce Tate
• HTML5 and CSS3 – Brian Hogan
• Programming Ruby 1.9 (1.9.2 update) – Dave Thomas
• The Rails 3 Way – Obie Fernandez

In the mean time I’ve come to love the Ruby programming language and the Rails framework – which has just recently released version 3.1.

I’ve been doing some learning projects over the last few weeks, including Platform45‘s battleships developer challenge and I’ve been rewriting this blog using Rails 3.1.

Thanks everyone who attended my talk on using jQuery PJAX with ASP.NET MVC3.

Here are my slides and code from the talk.

Slides
Code

Devs4Devs has to be my favourite developer event of the year.  There’s time to socialize with fellow geeks and learn how to use some really cool new technologies.

I will be presenting on using jQuery PJAX to speed up client side performance with the ASP.NET MVC framework.

A list of presentations and the registration link can be found on Microsoft’s South Africa Developer Platform blog, here

For those who weren’t there – I gave a talk on Dynamic Languages and the DLR on Tuesday 12 July.

Here are the resources from the talk:

IronPython: http://ironpython.codeplex.com
Clay: http://clay.codeplex.com
System.Dynamic: http://msdn.microsoft.com/en-us/library/system.dynamic.aspx

And here’s the code used to call a Python script from C#, using the DLR interop and dynamic keyword:

            var engine = IronPython.Hosting.Python.CreateEngine();
            var scope = engine.Runtime.UseFile("greeter.py");
            dynamic greeterClass = scope.GetVariable("Greeter");
            dynamic greeter = greeterClass();

            dynamic s = greeter.sayHello("Kevin!");

            Console.WriteLine(s);
            Console.Read();

For a long time I’ve used NHibernate as my ORM of choice for .NET and registered listeners for the pre-insert and pre-update events in NHibernate to handle this for me.  Now that Entity Framework 4.1 is out and becoming more useful I was interested in seeing how similar things could be done.

Entity Framework’s extension points are very limited compared to what NHibernate is capable of, but there is enough there to get you through most borderline scenarios you’ll hit while working with Entity Framework.

The problem I have with using the extension points is that you have to embed code inside your DbContext class to hook into the inserts, updates and deletes.  This means you’re mixing concerns of hooking into the extension point and the logic of what the hook must actually do.  This means it becomes difficult to test your hooks in isolation and that your DbContext class can become exceptionally long.

In comes EFHooks.  It’s a project I’ve just started to make it easier to hook into Entity Framework.  Check the code out on Github here.

EFHooks allows you to separate the concerns of writing pre-action hook code from accessing the extension points and registering your hooked code for execution.  This means unit testing your hook without using a DbContext becomes easy.

Here’s an example of a hook to run before any entity that inherits from ITimeStamped gets inserted.  Everything is strongly typed, so only ITimeStamped entities will be passed into this hook.

public class TimestampPreInsertHook : PreInsertHook<ITimeStamped>
{
    public override void Hook(ITimeStamped entity, HookEntityMetadata metadata)
    {
        entity.CreatedAt = DateTime.Now;
    }
}

This means you don’t need to write code to set your CreatedAt date every time you create an entity that implements ITimeStamped.  By the same pattern you could use .NET reflection on System.Object and not even have to use an interface.

Note I said “pre-action” – This handles 99% of the use cases I’ve ever hit.  I’m working on a way to handle post-action hooks as well and I’ll have it all in a Nuget package as soon as it’s stable.

Check the code out, build it, play with it and please let me know if you have any problems with it.

(Update: Post-actions are also implemented and the package is available on NuGet here)

Links:

EFHooks on Github

Well soon after that I sat playing with Android 2.3.3 and began seeing holes in WP7 that I didn’t even know were there before.

The first point is location based, Google has got far more market penetration here in South Africa than bing has.  In preparation for the Soccer world cup last year, Google beefed up their maps of South Africa including Street View, local business references, their geolocation quality and their routing engines.  If I type something like “Roman’s Pizza” into my droid device it shows me the nearest Roman’s Pizza restaurants.  If I type that into bing, it asks if I meant Romania.

If I were sitting in the USA this wouldn’t be an issue since bing’s market penetration seems to be far better there.

The next thing I noticed was the smoothness of apps.  WP7 still has a few bugs to kill in its threading implementation which will hopefully be resolved by WP7.1.  The result is that WP7 apps tend to jitter as you’re scrolling through them while visual states are updating, or when items are being added or removed from a list.  The Facebook and Twitter apps demonstrate this clearly.

On Android I fire up TweetDeck and it’s silky smooth from the moment I open it.  No jittering, no lagging.

That brings me to my next point, community apps.  WP7 is still young and I was willing to hold on a bit for the community to catch up with apps, but it’s been slower than anyone expected to the point that it’s actually painful.  At this point there is still no decent instant messenger for WP7.  Whatsapp is nowhere to be seen, nor is Skype or Google Talk. (Yes… I know that Skype is on its way with WP7.1, but at the moment we’ve got nothing).

There’s just a much broader support for Android than WP7.  A few other examples that have no close matching app on WP7 are the Formula 1 live timing app which I now use for every F1 race, TweetDeck, Winamp, SoundHound, Guitar tuner and Harvest time tracker.

I’ve also found that similar apps have better functionality on Droid – e.g. YouVersion Bible can stream an audio version of a passage in Droid which can’t be done in the WP7 version.  I mentioned TweetDeck before, I know Birdsong is decent on WP7, but Tweetdeck is free and does an equally good job as the paid app on WP7.

When the WP7.1 update hits, I believe the two operating systems will be pretty much on par with each other – with WP7 in the lead for enterprise integration with Exchange and Lync Server.

WP7 has a great edge in a few areas already.  I definitely prefer the IE based web browser in WP7 over any of the browsers on Droid.  3D graphics in games are absolutely stunning on WP7 with its Direct X based hardware accelerated rendering.  Also the simple ability to fire up the camera from the lock screen is very useful.

App development for WP7 is also light years ahead of Android’s.  While the tools for Android are very good (Eclipse + Java + ADK with Android Emulator), the tools for WP7 have the edge with the Blend + Visual Studio + Silverlight combination.

As things stand right now, WP7 really is a great phone OS, but its community is lacking and bing really sucks in South Africa.  When the Mango update hits, when Whatsapp finally releases a client for the WP7 platform and when bing’s search in South Africa improves (or we can change over to Google search in WP7) I will probably change back over to using Windows Phone.