Ive been a bit inactive here on my blog for a while, it is not because there has been nothing to talk about, in fact there has been plenty, and maybe I’ll be able to catch up on that, but this post is about some of my core development environment at home.
ClearCase / ClearQuest
As someone might also have noticed, I have been bitching a bit about ClearQuest / ClearCase which we have switched to at work, and only god knows why (and i don’t belive in him so that might pose a problem?)… So In light of those posts I would post something positive on what they try to accomplish.
It’s not that IBM fails completely, some of the very core ideas is good engough, well those ideas might actually not even originate form IBM, so maybe they do fail, but i can’t say for shure since i don’t know the history of CC/CQ enough, what I do know that the core ideas are just drowning in bad implementation, weather it be the interface or deeper.
And then there is the core things that is missing, like Atomic Commits which is a very interesting area to talk about on ClearCase apparently, I have seen comparison matrix’s that claims that ClearCase does have it, but thats a lie, however the latest release should actually have it though, there is just one problem, it only works under a specific project model which is a real kicker to me, do I dare to ask why it only works under a specific model?… If that does not scream bad design, I don’t know what does.
But enough about CC/CQ.
Jira 4.0
http://www.atlassian.com/software/jira/
JIRA is an Issue tracking system implemented in Java with a web based platform.
JIRA seems to be very well implemented if you ask me, it is very lightweight in the default deployment containing only the very basics, however it should cover the simple needs for very small and new projects.
From that point the system can grow with the project and the added needs a bigger project gets, this could be:
- Linking issues together.
- Sub-Items
- Custom Fields
- Time Tracking
- ect.
Those are more basic extentions, and all directly bundled with JIRA, but JIRA also offers other ways to fit it into the projects needs, personally I have no experience in extending Jira my self, but there is already a load of plugins out there, from “SCC Connecters”, “Agile Management” and so on, some are bundled with the installation, others can be purchached or downloaded for free, actually much of the code functionality in JIRA is implemented as plugins. Here is some i use:
- GreenHopper – Agile project management, I will have a paragraph on this by it self.
- RPC JIRA – For accessing jira through “code” as such.
- JIRA Subversion – Plugin that can link subersion commits to Jira issues, I will also go deeper into this.
And there is many more out there.
JIRA ofc also alow you to ajust what types of issues you have on your project, what resollution types, states, priorities and so on, bassicly everything can be ajusted more or less.
In all that, many of the core functions are the same of Clear Quest, so what is better?, for one major thing. the whole way it is presented to the user. The interfaces is much more user friendly and intuitive where CQ is actually counter-intuitive on many points.
There is things missing, or things that could be better, but iw you where to make a scale from -100% to 100% where -100% means total counter productive and counter intuitive, and 100% being the opposite (the perfect interface). I would place CQ in the range from -50% to -75%, yes in the counter productive and counter intuitive area, but JIRA i would place around the 80%-90% for the general user interface (what all the developers, project managers ect would use)… and then around 60%-70% for the administration interface because it is slightly less intuitive, but that is overall ok.
Some things I do miss is:
- Creating new “linked” issues directly from an issue, much like the way you can create Sub-Items. This would serve well when JIRA is used to also store things as stories, features ect. since it would ease the process of breaking features into stories, you can however ofc. just have stories as Sub-Items, but after trying that I didn’t really like it.
- Choose how Sub-Items time tracking in handled towards there parent, as it is in JIRA it is added together, but when one might use the sub items to break down the issue, then the hours on the parent should be a ROM which remains that way, while the more accuarate estimate is only the sum of the Sub-Items.
- More levels of sub-tasking, not that I need it, however the option seems to be missing.
GreenHopper
http://www.atlassian.com/software/greenhopper/
GreenHopper is an Agile Project management tool for JIRA, it basicly tries to imcorporate the SCRUM process into JIRA and offers planning bords, task boards, chart boards and so on, and it does it’s job well most of the way.
Im not shure just how usefull the task board would be to the general SCRUM team, it proberly has more use to a team where members are located at different places which is proberly mostly seen in the OpenSource world, but I won’t draw any conclusion on it, logging work and closing issues is actually something I do through the task board, so if nothing else it has that conveniecense level, here it would however be smart if moving an item would be able to auto trigger the “log work” dialog.
But all in all, it’s rather good, or at least much better than or equal to any other tools ive seen for it.
Here is a glimt of the planning board, simply drag items to the scehduled versions:
Mingle from ThoughtWorks seems to be a worthy competitor with card to code links, time tracking ect. But it seems to be very similar to a Jira, GreenHopper and FishEye implementation, where it just has some advantages and other disadvantages.
Mingle can be found at:
http://www.thoughtworks-studios.com/mingle-agile-project-management
The JIRA way seems to have a price advantage as well as it seems to be more extensible. Mingle sounds easyer to install, and if i know ThougtWorks right it properbly more scaleable as well, meaning less hardware for large deployments.
JIRA Subversion
https://plugins.atlassian.com/plugin/details/291
This is a plugin used to link Subversion commits to JIRA issues, the commits and comments will apear on a tab at the bottom of each issue, it is very easy to work with and will allow for linking several issues to a single commit.
Simply add the “Issue-Id” in the comment and the plugin will pick it up after some time. Personally I put it in the beginning and enshure that it is easy noticable, e.g. “[JVS-12] Commit comment…” and the result will be:
Compared to the CC/CQ way, this is way less invasive for the devoloper, yet the linking can still be enforced, but enforcing it requires some work, like commit hooks ect. So where in CC/CQ it is more a core thing, here it becomes a gimick unless you do something.
But looking at how it works, enforcing would not even make it close to as intrusive as the whole CC/CQ procedure which is just purely painfull.
What is lost i gues, is a linking from the various branches in a project to the issue, or more specificly what branches an issue has been fixed on and merged to, and I’m not shure that is possible, and… I can see the use for it, but mostly for projects that has been released in various supported versions, but the intrusinveness of CC/CQ is to high a price to pay for it, and is ultimately not really the facilitator for that specific feature, how hard or easy it would be to add to the JIRA – SVN combination i don’t know either.
It all put together
All these things put together seems to work really well, it is a bit of a hassle to install it all, especially all the JIRA related things, but this is mostly because I installed JIRA, Confluence, FishEye as well as making an attempt on Crowd, but I have not gotten it all to work just yet.
The connection this post is about though all works really great togther.
To summerize the tools:
That will be it for this post, maybe more to come.