HockeyApp: still the best thing since sliced pizza

Sliced bread is good, but pizza is where it’s at. It’s the same with HockeyApp: once you try it, you’ll be hooked for life.

I previously wrote about HockeyApp as part of a crash reporter mini-showdown. If you haven’t read that yet, you probably should.

Since then, I’ve been using HockeyApp extensively for alpha and beta testing, and it seriously kicked my testing process up to a whole new level.

What in the heck is a Hockey App?

Yes, the name is a bit weird. Apparently it’s a play on words based on the concept of an “ad hoc” build. You can read some info about the company’s team here.

HockeyApp is two things: a service to enable beta testing of apps on iOS/Android/MAS, and a service to acquire crash reports from clients.

You get both of those services at once by signing up for an account. There isn’t any free account, but the $10 Indie account is pretty generous.

Crash report extravaganza

Your clients crash far more frequently than you think:

Yes, really.

Your job is to figure out why. HockeyApp uses the super powerful PLCrashReporter library to make this happen, and it uploads the crashes to the HockeyApp server.

The real magic happens after the upload—HockeyApp instantly symbolicates your crash and gives you a stack trace. You see all your crashes grouped by type. Your client can submit some user information with each crash. For example, I send my user’s Game Center ID and nickname, as well as whether the user has advertising on or off in my app.

So many crashes, so little time…

This is a lovely UIKit crash that I’m not aware of any fix for. Sweet!

You can mark crashes as Resolved or Ignored, or you can send them to a third-party issue tracking tool. HockeyApp integrates with a ton of them, including Jira, Assembla, Bugshelf, Codebase, Fogbugz, Github, Lighthouse, Mantis, Redmine, Trac, Unfuddle, BaseCamp, and Pivotal Tracker.

If you’ve ever tried to manually symbolicate crash reports (or use Xcode to do it), you’ll instantly appreciate just how easy HockeyApp makes it.

I use HockeyApp crash reporting in all my test and App Store builds. It can be a bit disconcerting seeing the immense variety of strange and arcane ways your app crashes in the real world, but I guess that’s better than being blissfully ignorant!

Your own personal App Store

Let’s talk about beta testing. The old fashioned way was to create an ad-hoc build with a special entitlements file, manually zip up your app bundle with a provisioning profile and a specific folder layout, rename it to .ipa, email it to your testers, and give them detailed instructions on how to drag the IPA file to iTunes and sync it to their device. Said instructions had to be replete with corner cases and instructions for if things went wrong (which they usually did). It was, to say the least, a total pain in the ass.

(Yes, Xcode was supposed to help with some of those steps in the early days, but in reality I could never get it to do anything remotely helpful.)

Luckily, with iOS 4.0, Apple introduced over-the-air distribution of ad-hoc builds. The technique wasn’t in and of itself very easy to use, but it provided the key building blocks to enable a whole new class of services, including HockeyApp.

Beta testing with HockeyApp is easy. First, integrate the SDK (instructions here). Then, in Xcode 4, create a new Scheme for Distribution, and point it at an ad-hoc provisioning profile that you created using Apple’s developer site (this provisioning profile needs to contain all of your tester’s devices). Archive your app using Xcode, then upload the .ipa and .dsym files to HockeyApp. (There’s an uploader app that will do this last step for you, which I’ll discuss in the next section.)

Your app, when enabled for beta testing, now gets a public download page.

The download page on a desktop computer.

The download page on an iPhone.

I like to use a URL shortener like bit.ly to create a more memorable URL to my download page, then hand that to my testers. Tapping the install button gives you a prompt like this:

Click Install again, and it installs just like any app from the App Store:

The only thing that can go wrong at this point is if you did your provisioning profile badly (not including this user’s device, or accidentally using an App Store profile instead of an Ad Hoc profile).

Cool! The app is installed and ready for testing!

No, really, this is better than pizza

Testing is going great, and now it’s time for you to distribute a new build to your testers. It gets even easier now.

You build and upload the app as before. But your testers immediately get a prompt right inside your app that a new build is available:

Tapping Show lets you see the changelog for this build. You can then install the update right from within the app. It’s really slick.

You can even mark updates as mandatory, forcing 100% adoption of updates throughout your test cycle. Awesome!

You also get stats on the testing. How many downloads did you get? How many hours of testing have you accumulated per build? HockeyApp will tell you:

I’ve only got one build in testing right now, so this graph is a bit lopsided.

And of course, you’re also collecting crashes from these test builds.

There’s a lot more you can do with beta testing, including:

  • Public recruitment page (users can sign up to test your app, and you can accept/reject them as needed).
  • Users can create accounts to be notified by email when a new build is ready for testing.
  • You can create “managers”, which are users who can administrate the nuts and bolts of your HockeyApp apps.
  • You can invite users to test your app.
  • There’s an API that you can leverage to do probably everything you’ve seen so far, programmatically.

The kitchen sink

As if this weren’t cool enough already, there’s one more thing that makes the HockeyApp ecosystem a breeze: the HockeyMac uploader application. You can add an item to your Xcode Scheme that launches HockeyMac, ready to automatically upload your .dsym and .ipa files. You can throw in your changelog right there, hit a button, and away you go. There is no need to visit the HockeyApp web site at all.


Here’s the deal: you should be using HockeyApp. There are a lot of competitors out there, most famously TestFlight. I haven’t personally used TestFlight, but I did try a few other crash reporters. HockeyApp gets crash reporting really, really right. The beta testing workflow is literally everything I could ever ask for, so I can’t recommend anything else.

Recently I’ve been seeing more and more iOS developers on Twitter who are switching away from whatever crash/beta solutions they were using, and changing over to HockeyApp. I’m not sure what’s driving this exodus, but comments so far indicate that HockeyApp is a better solution for the majority of developers.

The guys at Hockey are really responsive to support issues. (It seems like they never sleep, honestly!) If you have a suggestion, they’re really open to hearing it. They’ve implemented every suggestion I’ve ever thrown their way so far, and I imagine that’s the case for just about everyone.

And the best part: they aren’t some new highly funded VC flavor-of-the-month. It’s just a small team of guys who love what they do and want to provide the best service possible for developers.

And they nailed it.

(Note: I am not a spokesperson for HockeyApp or Bit Stadium, nor was I in any way compensated for writing this post. One of the HockeyApp developers did reach out to me to suggest a follow-up article, but that’s it. I’m just a big fan!)