Project Management with Redmine
The Redmine project management system includes Gantt charts, a calendar, a roadmap, and other helpful features you can use to keep track of what's going on with your software development projects. (You can use Redmine for any other kind of project you care to manage, but it's clearly aimed at software development.) It includes bug-tracking and support ticketing, allowing you to track feature, bug, and support requests along with project management for your next software release. Redmine also provides news and document management, a per-project wiki, and per-project forums. Does all that sound intriguing? Here's how to get started with Redmine.
If you know Trac, the design of Redmine will feel a little familiar. The software's Ruby on Rails base means that it's cross-platform, and it's also cross-database – you can use MySQL, PostgreSQL, or SQLite as the database back end.
You can install Redmine on Unix, Linux, Mac OS, Mac Server, and Windows. I first tried it on a Mac running Snow Leopard, but ran into a number of problems, most notably a Rails/RubyGems incompatibility, so I tried Linux instead. On Debian, I installed the package available for Debian stable (version 1.0.1-2; the most recent source code release on the project's website is 1.2.2). Some post-installation configuration is required. Config examples are available at /usr/share/doc/redmine/examples; it's not an "install and it just works" package. I did later try reinstalling from source to try the latest version, but ran into problems with various RubyGems. Redmine is quite specific about which versions of various Gems it will work with (for example, it requires rack 1.1.0 rather than the current 1.3.5). All of this means that it's not necessarily a smooth install. I didn't try installing it via Bitnami stack, which is designed to install an application and all its necessary accoutrements, but that might simplify things.
My First Redmine Project
Once you've got Redmine up and running, go to http://localhost/redmine and log in as admin. The user's guide is helpful to get you started.
The first thing you'll need to do is set up at least one project, and probably at least one user in addition to admin. Projects can have subprojects, and the project summary list shows both main projects and their subprojects clearly.
Once you have a project set up, the main class of thing you interact with is an issue. An issue must be identified as bug, feature, or support, and you can't add to those classes; you can however create categories to divide up your issues. You can also create issues as subtasks of other issues, which is a great project management feature that allows issues to develop as they need to without becoming unmanageable. If someone reports an issue that turns out to need a lot of complicated work, you can break the solution down into multiple steps which can then be assigned and tracked separately. Issues can be assigned to people who are members of the project. When you go to an issue list, all issues for that project or subproject show up, but unfortunately the list doesn't show whether they're subtasks of one another.
Keeping Track of Things
If you're a project management geek, you'll be pleased to know that Redmine provides Gantt charts, which are a special kind of bar chart that shows a project schedule. To be shown on the Gantt chart, issues need both a due date and a start date. (Start dates are given by default as the date the issue was entered, although the default can be deleted or altered.) Redmine shows the due date (and start date if it exists) of an issue, and whether it's a subtask of another issue. The calendar also shows start and end dates of tasks, making it another useful way to keep track of issues.
Of course, for a Gantt chart to be truly useful, you need to be able to mark which issues depend on other issues. Redmine can do this for you, but the dependencies won't actually show up on the Gantt chart, only on the issue description, which is annoying. To create an issue dependency, go into the edit screen of an issue and look for the "related issues" button, which includes a "precedes/follows" option along with various other forms of relation between issues. You need to know the issue number of the related issue; there's no potentially helpful drop-down functionality, although with a large number of issues things could get out of hand if there were. The start and due dates of the two tasks need to match up correctly; if they don't, you'll get an error message that isn't particularly informative.
[caption id="attachment_97583" align="alignnone" width="300" caption="A roadmap showing two versions and some completed issues"]
One thing I really liked was the roadmap function, which shows what issues must be resolved for a particular version of the project. To access it, you first need to create a version of the project, which means creating a label of "version 1.1" or "version 2.3.4" that should match the current working branch of your version control system. You then start editing issues to assigning them to that version. To mass-edit issues, highlight them in the issue list then right-click to get a list of options. Go back to the Roadmap tab, and you'll see a roadmap for that version of your project! Roadmaps are great for getting a swift handle on what's already been done and what still needs to be done. Similarly, the Calendar option shows tasks and due dates in another useful, visual form. For overall project management and keeping developers in touch with the wider project, I also liked the "latest news" feature on the overview page.
[caption id="attachment_97582" align="alignnone" width="300" caption="Overview page; note the "latest news" section on the left"]
As another option to help your developers keep track of their issues, you can set up a reminder email task to inform people about tasks due in the next [x] days.
Redmine also has a useful time logging feature. Developers can make a note of time spent on the project and what they've done, and you can generate a report on spent time per project or subproject from the overview page.
Redmine suffers from some questionable user interface design choices. For instance, some of Redmine's issue fields are more difficult to edit than others. Some can be edited from the issue summary screen, without going into the edit screen (for instance, related issues and subtasks), whereas others (description, assigned to, spent time) cannot. I couldn't see any rationale for the distinction. Also, there is a "log time" button at the bottom of the issue display screen, but it seems odd to have it there rather than up by the time spent box.
If the columns shown on the issue summary page don't work for you, you can change them, but only as a global setting (log in as admin and go to Administration -> Settings -> Issue Tracking), not per-project.
Note that to be able to change an issue's status (e.g. from New to Closed), you need to be a member of the project and to have at least developer status. You can change status in the Settings tab.
While Redmine has some ticketing features, it isn't really a standard trouble ticketing system. It doesn't have that much in the way of email integration (though you can "watch" an issue to be emailed when it's updated), and there seems to be no way of getting back in touch with the bug reporter to ask for more information. Being able to report bugs and roll them into a particular version or into the project as a whole is great, but for support-type ticketing, you'd be better off with Request Tracker or another similar dedicated system.
If you do want to use Redmine for support-type trouble ticketing, or for bug reporting outside of your own developers, you can set it up to let users open issues by sending an email message. However, such emails have to correspond to a particular format – users must provide all required custom fields or creating the issue will fail – which is likely to be a problem for regular users. You can set up a web form to make ticketing easier. A useful approach might be to have known users just log in to Redmine and create issues themselves, and accept email from unknown users.
Version Control, and Extending Redmine
You can link Redmine in with your version control system, which is a great feature, especially for projects that are being worked on by widely dispersed staffs. You can serve up your SVN, Mercurial, or Git repository through Apache, which means that you can use Redmine's own access control, and secure it via SSL. Check out the HowTos (under Source Code Management) for more information.
If you like Redmine, but feel that you need a particular extra, all is not lost. Developers have written a whole bunch of plugins to extend the application, and development is very active. If you're running Redmine in production and need a particular feature, it's worth contacting the team about it.
Redmine is easy to get started with and has some really great features. As a project management geek, I'd particularly like to see the Gantt chart feature improved, as well as some of the niggles with issue editing; but as a centralized project management system with a whole bunch of features to keep everyone up-to-date, Redmine looks pretty good already.
This work is licensed under a Creative Commons Attribution 3.0 Unported License
This work is licensed under a Creative Commons Attribution 3.0 Unported License