Issue Tracking Systems

3.5JIRA

Homepage: http://www.atlassian.com/software/jira/

License: Proprietary (Free – 4800 USD)

Implemented in: Java

Demo site: http://jira.atlassian.com/browse/DEMO

JIRA is a bug/issue tracking and project management system developed by Atlassian Software Systems. It is well-known for its complexity, but at the same time, keeping a clear and easy-to-use user interface. It is also famous for its community, which makes plenty of extensions and plug-ins, and also, for a wide variety of learning resources and documentation. The last big advantage is its easy integration with enterprise wiki Confluence and other Atlassian tools.
JIRA’s code is open source. JIRA is good example of having proprietary software with open source code checked and extended by community. Atlassian provides JIRA for free to open source projects and organizations that are non-profit, non-government, non-academic, non-commercial, non-political, and secular. For other organizations, Atlassian charges between $1200 and $4800 US, depending on the version, with a 50% discount for an academic license. Starting with JIRA version 3.13, a free personal license is also available for non-commercial use. This license does not include Atlassian support and it is limited to three full users.

[TSO-ATL1]

Installation

JIRA is delivered as a binary installation file, which supports either GUI-based installation (more friendly for the desktop) or text-based installation (more friendly for remote servers). No special preparations are necessary; the installation file includes all necessary parts.

There is also a possibility to not install JIRA to one’s own environment, but have it hosted by Atlassian.

User interface

JIRA’s user interface is one of its biggest benefits. When JIRAs complexity is observed, it stays very clean and easily understandable due to the UI, but it can be easily customized. Every user can define a unique UI configuration as is best for the individual.

Some tasks, by default installation, require too many steps. For this dilemma, there are plenty of plug-ins which enable a user to perform those task more easily. For example, by default, if a user wants to move ticket from one project release to another, the action must be done inside the ticket. This is not very comfortable if the user must handle 50 tickets. The GreenHopper plug-in (which we will mention later) exists exactly for this reason. Not JIRA itself, but these extensions and customizations make JIRA a top notch product.

Screen shot : JIRA use-case – Dashboard

Screen shot : JIRA use-case – Create new issue (selecting project and issue type)

Screen shot : JIRA use-case – Create new issue (adding details)

Screen shot : JIRA use-case – Projects Dashboard

Screen shot : JIRA use-case – Issue navigator (list of issues)

Screen shot : JIRA use-case – Creating a new search filter

Screen shot : JIRA use-case – View ticket (enabled actions on the left)

Ticket system

JIRA provides a default workflow – a generic set of steps that start up immediately (see diagram below). It is easy to configure JIRA’s workflow within the UI. JIRA’s flexible workflow architecture lets a user define individual workflows for departments, projects, and even issue types. Each workflow can have as many or few steps as required.

Figure : Default JIRA ticket workflow

JIRA allows the user to configure ticket custom fields on a system-wide, project-specific and/or issue type basis. JIRA ships with over 20 types of custom fields and a user can also develop individual types of custom fields within the UI.
JIRA also allows you to create and manage one’s own issue ticket types. A user can really customize JIRA for all kinds of environments, not only for software development, but also for example, for “life management”.

[TSO-ATL1]

Projects management

JIRA is designed as multi-project request tracking and project management system. Projects can be sorted to the categories, etc. as shown on image below. Each project can have individual settings (workflow, filters, metrics, reports, issue types, etc.)

Figure : JIRA concepts

[TSO-ATL2] [TSO-LAW]

Analysis and monitoring

JIRA supports monitoring and reporting based on filters.
A filter is something like a customized search. A user defines what conditions have tickets to fulfill and names this. Filters can also be set throughout all projects present in JIRA, not only for each project individually.
A filter then can be used not only for ticket management, but also as a source for monitoring and reporting tools, etc. The user can, for example, by a few clicks create a filter, which displays requests “assigned to it for current release”, set this to be displayed as a pie chart with sorting based on the status of the request; furthermore, this chart can be displayed as a portlet on the dashboard.
The dashboard is usually the starting point. It is highly customizable by placing so-called portlets on it. They are pluggable user interface components. Portlets are not classical portal server portlets based on the Java Portlet Specification (JSR168, JSR286) – they are for JIRA only. There are plenty of out-of-box portlets for monitoring and reporting purposes present; however, as mentioned, users can define their own or configure the out-of-box portlets based on filters.

Source code management systems integration

JIRA supports connection to a variety of source code management systems through plug-ins. Of course, the most common ones like Subversion connector are present out-of-box.

Atlassian also provides product FishEye, which helps development teams keep tabs on what is going on in the source code repository within the web interface. This is also possible to fully integrate into JIRA.

Accessibility and extensibility

JIRA 3.0 and above ships with the RPC plug-in, which enables remote access through XML-RPC and SOAP. It is also possible to use the Java API interface and extend it to JIRA.
There is quite a large community working on extensions of plug-ins and extensions of JIRA. Their work can be found on the JIRA webpage (http://www.atlassian.com/software/jira/plugins/).

[ANC-ATL]

Specialties

• 
  Possibility to configure the UI individually for each user, even anonymous ones;
  
  • 
    this allows for JIRA to be used even for Help-desk / Support / Customer service;
    
• 
  Provides fine-grained enterprise level security;
  
  • 
    there can be set access rights not only for individual projects, but also for requests, even for single comments of tickets;
    
• 
  Requests can be created automatically from e-mails (useful again for Help-desk, etc.);
  
• 
  Requests can be divided into subtasks;
  
• 
  Default support for time tracking (logging of work, claiming, time estimations); and
  
• 
  Integration with other Atlassian tools, like enterprise wiki Confluence, etc.
  

Conclusion

JIRA is a top product in request tracking and project monitoring. It has very friendly politics of distribution and thanks to the support of the open source community; it makes plug-ins and extensions to make JIRA even better. It is easy to learn and highly customizable.

3.5.1GreenHopper plug-in for JIRA

Homepage: http://www.greenpeppersoftware.com/en/products/greenhopper-jira/

License: Proprietary (350 – 1150 USD)

Demo site: http://www.greenpeppersoftware.com/en/products/greenhopper-jira/demo/
While JIRA models the project information very well and has excellent reporting features, it is not a very attractive environment to work in for project managers. The interface is geared towards searching and listing issues, but editing and managing the project is, by default, quite unfriendly. This is where the GreenHopper plug-in is introduced. The main goals of this plug-in are to provide JIRA users with the following:

• 
  an interactive and simple interface to manage their projects, and
  
• 
  tools to increase the visibility and traceability of ongoing versions.
  

It was designed to make the interface more useable for both developers and project managers. Using a whiteboard and index card metaphor, it gives an instantly recognizable and very editable front end. Actually, it gives only three additional views:

• 
  Planning Board – for a global view of all versions and all components;
  
• 
  Task Board
  
• 
  Chart Board – charts and diagrams to help a manager analyze the progress of a project
  

Here are the views in greater detail:

Planning Board

Screen shot : JIRA GreenHopper plug-in - Planning Board

Planning Board gives the user a global view of all versions and all components. It is divided into two parts:

• 
  The main pane is called the “Issue navigator.” The user sees a list of issues within the selected content and by using the drag-and-drop method, he or she can easily order and plan.
  

• 
  The right pane contains droppable boxes and offers a choice of different management views. There are three ways to manage issues:
  

1. 
   Overview (all unreleased fix versions and unscheduled versions merged into one view) – this is very useful for ranking.
   
2. 
   Versions – by unreleased fix versions.
   
3. 
   Components – by components.
   

As mentioned, the right pane is droppable, so managing issues between versions and components have actually become a fun task in JIRA with GreenHopper. By simply dragging and dropping, issues can be associated to the appropriate version or component.

Each version or component box also contains the following information and allows the following operations:

• 
  Progress bar, which shows work progress on the selected version or component. Clicking on a color state will bring the issue navigator, pre-filled with the issues in that state.
  
• 
  “Master” attribute in each version or component box. Through this setting one can organize versions/components in a “ hierarchical” way. This is very useful and will help the user to have a global view of the versions and a more granular view of the sub-versions.
  
• 
  Statistics and counts – release date, count of issues by type, count of unresolved and resolved issues, etc.
  
• 
  “Release version” button, which will enable the user to release versions directly from the version boxes.
  If some issues are unresolved, GreenHopper offers two options:
  
  • 
    Swap the unresolved issues to the selected version; and
    
  • 
    Ignore these issues and release anyway.
    

So, in summary, Planning Board provides the user with:

• 
  a global view of all unreleased versions;
  
• 
  a global view of all components;
  
• 
  a card and list look and feel;
  
• 
  multi-level planning (hierarchical);
  
• 
  issue ordering using drag-and-drop;
  
• 
  issue planning using drag-and-drop;
  
• 
  multi-selection in the planning board;
  
• 
  coherent handling of sub-tasks;
  
• 
  issue filtering and sorting; and
  
• 
  quick access to the issue navigator.
  

Task Board

Screen shot : JIRA GreenHopper plug-in - Task Board

Task Board allows users to easily track the requests within versions. The screen is divided into multiple columns, which correspond to a JIRA transition. Users can add, remove, and rename these columns to make the board handier. Every user can personalize their own Task Board by hiding or showing specific columns.
By simple drag-and-drop of issues between the swim lanes, a user can easily change the status of an issue. Dropping a card into a column will automatically display the list of all possible transitions. Of course, all notification events, post-functions, etc. will be triggered. If the transition of the issues requires some mandatory entries, GreenHopper will ask the user to enter this required data through a modal screen within the task board.
In summary, Task Board provides:

• 
  an intuitive tracking of versions;
  
• 
  an outlined task board;
  
• 
  a personal board;
  
• 
  configurable swim lanes;
  
• 
  an update of the issue status using drag-and-drop;
  
• 
  quick logging of a user’s work;
  
• 
  quick access to the issue navigator; and
  
• 
  issue filtering and sorting.
  

Chart Board

Screen shot : JIRA GreenHopper plug-in - Chart Board

Chart Board offers plenty of charts and diagrams to help managers analyze the progress of a project. More about the available charts and their configuration can be found in the documentation available at http://www.greenpeppersoftware.com/confluence/display/GH/CHART+BOARD.
In summary, Chart Board provides:

• 
  dynamic work and the requirement of no settings;
  
• 
  a display of the burndown curve;
  
• 
  a display of the team effort curve;
  
• 
  a display of the estimation accuracy curve;
  
• 
  a burndown chart based on a custom field;
  
• 
  a burnup chart based on a custom field;
  
• 
  a value chart based on a custom field;
  
• 
  issue filtering; and
  
• 
  a configurable start date and end date.
  

Issue views

Issues can be displayed in three levels of details:

1. 
   Summary view
   

This view is designed to show only basic information about the ticket. By default, it shows the ticket number, short description, and assignee; however, this can be customized by user.

Screen shot : JIRA GreenHopper plug-in - Summary view of the ticket

2. 
   Card view
   

This view enables a detailed view of the ticket and also easy editing of its information. A user can customize which fields he or she wants to see; however, by default, this view takes up much place on the screen.

Screen shot : JIRA GreenHopper plug-in - Card view of the ticket

3. 
   List view
   

The most compact view. Shows only the ticket number and short description. Mostly used for basic overview and fast sorting of tickets.

Screen shot : JIRA GreenHopper plug-in - List view of the ticket

[TSO-ATL2] [TSO-GRE1] [TSO-GRE2] [TSO-GRE3] [TSO-LAW]

3.5.2Atlassian Bamboo

Atlassian Bamboo is the tool used for continuous integration. Bamboo automates the process of compiling and testing source code, saving time and instantly providing feedback about build problems for developers, allowing quick collaboration.

Screen shot : Atlassian Bamboo - “My activity” dashboard

Despite being a widely accepted best practice, many teams struggle to adopt a continuous integration process due to the perceived cost of setting up and maintaining such an environment. With Bamboo, setting up continuous integration process is simple. The installer auto-detects the development environment, enabling the user to start a build within minutes.
With Bamboo, one can specify multiple projects, each with their own set of unique build plans. A build plan defines elements such as:

• 
  what tests to run;
  
• 
  when builds should run;
  
• 
  what outputs ('artifacts') are produced;
  
• 
  which branch (if any) to check out; and
  
• 
  who gets notified upon what build event.
  

Bamboo's notifications system and intuitive web interface provide developers with the necessary information and simple navigation to interact with each build, as well as manage the entire continuous integration process.

Bamboo also allows one to distribute builds across different machines. These distributed builds allow the user to harness the computing power of the entire network, maximizing build productivity and decreasing wait times, allowing the user to test on different platforms.

The user simply installs a new Bamboo remote agent on any additional build computer and the main Bamboo server will manage it. When a build is detected, the Bamboo server will automatically and intelligently distribute the builds to the agents. Remote agents are even able to restart themselves in the event of a crash with the Remote Agent Supervisor.

It is also possible out-of-the box to integrate Bamboo with JIRA. From within the issue details, one can manage builds and testing – as shown on the image below.

Screen shot : Atlassian Bamboo - Integration into JIRA

[TSO-ATL1]

3.5.3Atlassian Crucible

Crucible is a peer code review tool that allows teams to review, edit, comment, and record outcomes.
Effective code review improves code quality by identifying bugs earlier in the development cycle when they are less costly to fix. In the process, developers learn new development techniques from each other and raise their level of discipline, knowing their code will be reviewed by peers.

Screen shot : Atlassian Crucible - View on review of code

Making it easy for every developer to engage with the code review process is a key item to implementing the practice. Participation in reviews with Crucible is really simple. As soon as a potential problem is spotted in the code, the user simply selects the line(s) of code that he or she wants to comment on and starts typing.

Screen shot : Atlassian Crucible - Add new comment (select code & type)

[TSO-ATL1]

3.5.4Atlassian FishEye

FishEye is an advanced repository browser. It opens the source code repository and helps development teams keep tabs on what is occurring using a web interface.

Screen shot : Atlassian FishEye - Changelog dashboard

FishEye gives the source code repository (Subversion, CVS, or Perforce) a simple Web interface. Developers can use FishEye to browse directly to a file or directory, quickly traverse deep directory hierarchies, and see visualizations of a branch history for an individual file.
FishEye makes the repository instantly discoverable through search. Queries by author, date range, tag, branch, filename, comment, file content, etc. are possible. FishEye gives the user a chronological view of changesets (i.e. collections of files that were included in the same commit) per directory, per author, or per branch. It also allows a user to track these changesets, commits, and other activity in the repository in near real-time, all from the comfort of the favorite RSS reader, or via email alerts.
FishEye makes it simple to share quick links to source code by representing each line of code as a unique URL. FishEye can directly link to specific files, revisions, diffs, lines of code, directories, changesets, search results, and more.
It also gives the user a simple way to report on activity in the repository with meaningful charts and graphs. These charts can be used to report on the activity of teams, the status of projects, and the detail of what has changed. These reports can also be used in a user’s own web pages and online documents.