Developer Aspirations

YAPB - Yet Another Programming Blog

Wednesday

13

October 2010

Quick review of JIRA

by Colin Miller, on Bugzilla, Issue Tracking, JIRA, Ramblings

Working on a personal project outside of my work environment places me in an interesting situation of being able to choose my tools. At my job, we use subversion for version control, bugzilla for issue tracking, a modified version of hudson for continuous integration, and twiki for documentation. I have minor gripes with all of those tools so in my personal project I thought I would try out some other ones.

For version control I'm using git. I actually use git at work as well through it's subversion integration for pushing changes back to the main repository, so it seemed very natural to me to use pure git for this project. Everything is stored on my EC2 server at amazon, and after having set up my private key and ssh host rules it's very simple to push and pull from the online repository.

I'm not using any wiki for documentation right now, just code comments. I'll work on a user manual when the program is closer to completion. Alas due to the way that android applications are made I'm also not participating in continus integration. That irritates me but I haven't had time to find a good solution yet. There's some complicated way of getting it to work with maven, but after a half hour of going through those hoops I decided it wasn't a process I wanted to duplicate on every machine I was going to develop with.

So now to the heart of this post, my issue tracking software. I choose to go with JIRA from Atlassian for a few reasons. First, I've installed personal copies of Bugzilla before and it is slooow. It also seems to use a ton of resources, something I don't really have with a micro instance on EC2. Second, Atlassian sells start licenses for $10. While I prefer to go with open source software as much as possible, $10 for something of possibly higher quality with good paid-for support is nothing to sniff at. Finally, since I have to use Eclipse for Android development (it's easier anyway), I decided to leverage the built-in Mylyn plugin to view my tasks in the IDE itself. Mylyn has an Atlassian plugin that works with JIRA pretty well. I know that Bugzilla, Mantis, and Trac all have plugins for Mylyn as well, but I was looking for a no-frills issue tracking software and didn't need a wiki or any additional bloat.

In a reversal of most reviews of a product, I'm going to start out with the cons of JIRA. First, the installation and setup was not the smoothest process. Rather than having a command-line installer, there are instead instructions on what config files to modify and not-quite-accurate instructions on setting it up to work with MySQL. While that was only a minor irritation, the startup process of the application itself is unpredictable. Originally JIRA did not detect that my version of the JDK was a sun version and so did not set a proper PermGen attribute causing the program to crash with OutOfMemory errors due to PermGen space. After fixing that, the program would sometimes fail to start, but upon shutting down and starting it again it would succeed. It wasn't the same every time, making it seem a bit flakey on that end.

When my Eclipse's security settings got messed up, integration with JIRA would fail and it would constantly set my account to require a manual logon with a CAPTCHA. Eventually I found the setting to disable that, but the documentation wasn't too helpful. Setting up notification support with Gmail wasn't very clear, and it took trolling through a few forum posts to find the parts where the documentation was lacking. There was even a post on the JIRA wiki about setting up notifications with Gmail, but the directions weren't quite there yet.

Setting up JIRA to integrate into Fisheye (more on that in a different post) was fairly frustrating. While it did eventually work, searching between two sets of documentation was a waste of time. I know I could have contacted JIRA technical support, but it was at night and their chat support line was down and waiting for an email response wouldn't have been very handy since I just spent the rest of the night figuring it out myself.

I was surprised that JIRA did not have a default way to have issues depend on each other. Often it's helpful to make a rollup task that encompasses some overarching goal and use separate smaller tasks that focus on individual changes. You can then use the big task to track the little ones. Now this isn't impossible in JIRA, just not what I was used to. In JIRA you can link two issues using a custom linking interface where you define your own relationships. It ends up working similarly, but isn't enabled by default and you have to set up the link types manually. It's more flexible than something like Bugzilla's "depends on", but not as obvious to set up. Still, I wouldn't really call it a con, more of a surprise.

Ok, now for the things that I like about JIRA. The interface is fairly snappy. Compared to Bugzilla it nearly flies in displaying the information that you need. The initial dashboard is customizable to an extent. I would have liked more layout options, but the ability to put different queries or graphs together for your initial page is very useful. Even then, I haven't found much need to change away from the original setup as it already is pretty useful.

While I would have preferred direct integration with git, using Fisheye as a go-between is a reasonable compromise. I can view source changes that are tagged with an issue name on the issue. I like that it has its own section rather than just being displayed in the comments list. Overall setting up an issue to track is a very nice experience. It's easy to add custom issue types (the defaults are New Feature, Improvement, Bug, or Task) along with custom components and Priorities. The ability to attach screenshots by just pasting the copied bitmap is handy, and attachments in general are handled very well. While I'm still a single-man shop, I can imagine the ability for users to vote on issues would be useful for setting priorities.

[caption id="attachment_358" align="aligncenter" width="380" caption="This is a Chart that JIRA created. It's supposed to show you the number of issues you create over the issues you resolve. Charts are handy because they create visualizations of statistical data that makes it easier for humans to consume. Mmm, consuming numbers. Nom nom nom. Tasty numbers."]Chart[/caption]

I like the ability to give my project a custom icon. Sort of superfluous, I know, but it's still a nice feature. The ability to create versions and assign bugs to various versions helps create roadmaps for what you want to complete by when. You can easily set up queries to look at what issues need to be resolved for a version to go out. Also, when a version is released you get a nice set of release notes based on the issues that you've fixed. JIRA even provide a markup to add those release notes into a wiki or some other package.

Overall, JIRA gets out of the way and lets me focus on my issues, which is what an issue/bug tracker should do. The graphs tracking my progress are niffty, and the flexibility is enough that I'm not constantly wishing it did something it doesn't. Integration with the IDE and version control are very nice features that I don't get at work (our version of bugzilla has a different login system so Mylyn doesn't work). Overall I would say it's worth the $10, but I don't see paying $1.2k for an upgraded version when free software that's high enough quality exists out there.

comments powered by Disqus