Revision as of 18:01, 10 December 2012 by Tpavek (Talk | contribs)


Rich task UI integration in the NetBeans IDE

Presents and discusses the benefits of an integrated rich task UI over it's web counterpart with the main focus on a task editor. Lists already existing and planned integration in NetBeans.


Before we dive deeper into a high-level discusion about what makes sense or is possible in regard of an integrated task support in an IDE, it seems to be in place to provide a brief overview of the underlying ideas/concepts.

Task management

Provides facilities aiding the user when working with tasks:


The necessary minimum to get a useful task related functionality into an IDE.

  • access, create and edit tasks
  • create and manage queries


The extra value provided by an Integrated Development Environment to its user when he is working with tasks.

  • custom task categories
  • private task scheduling
  • private notes
  • offline editing

IDE integration

Provides facilities aiding the user while working on a task by:

  • automation of task relevant activities in an IDE
  • fast lookup of task relevant artefacts in an IDE
  • reducing complexity
    • what artefacts are task relevant and what are not
    • unified working environment


  • commit hooks
  • attachment support
    • attach artifacts from the IDE
    • open and apply attachments in the IDE
  • stacktraces and hyperlinking
  • drag & drop facilities


  • set a task as active
  • track, store and restore task relevant state of the IDE
  • track and present task relevant changes made on a task relevant artefact in the IDE

Rich Task UI vs. the Web Interface

Let's first consider the level of provided functionality (integration) when confronting an IDE task UI with it's web counterpart:

  • the IDE task UI is missing important features from the web UI
  • the IDE task UI is just an alternative (mimicking) to the web UI
  • the IDE task UI is improving flaws of the web UI
  • the IDE task UI is enhancing functionality beyond the possible potential of a web interface

And now let's have a look on how each of those four level aids the user while working on his actual task in an IDE.

Integration with missing functionality

Poor mans solution in the best case, the user needs to go to web to do routine tasks. Missing or even no functionality at all in the IDE itself. The user is forced to switch to a different environment with a different look&feel, interface metaphors, etc. . Has a disruptive effect on users workflow. Is potentially counterproductive. Hinders automation and fast lookup. In the means of an unified environment it introduces complexity instead of reducing it.

No real advantages from the users point of view are evident.

Integration as an Alternative

Not really interesting in the scope of this document. Theoretically a stage of integration when the user doesn't have to switch to a different tool anymore.

While being honest, and admitting the fact that there probably always will be a scenario when a fallback to the web functionality will prove useful or maybe even necessary, the thing that matters in a well designed integration is that this doesn't happen too often or for a majority of users.

It is the following stages that really matter.

Integration improving functionality

Fixing and improving the UI experience. Also that a web UI typically was created for a broader audience than developers. Hence, an IDE UI should be better trimmed for a developers day to day work in an IDE.

Task Editor

A not complete list of examples of what was already done in NetBeans. Depends on the particular tracker and the particular effort/usefulness ratio.

Some examples of what's already provided.

  • when reassigning a bugzilla issue via web a list of projects is presented. In the next step the component has to be specified. The IDE makes it possible to do so in one shot. It is faster and less error prone.
  • some tasks can become very long with a lot of irrelevant or obsolete comments. NetBeans provides the possibility to expand/collaps task comments and it keeps that state persistent between sessions. Complexity reduction.
  • fast lookup of related tasks - duplicates, depends on/blocks in bugzilla. parent-/subtask in Jira. ... No need to open another, search dedicated tab or switch to the mailbox to "somehow" find the task. Faster and doesn't clutter the environment.
  • in the bugzilla web ui it isn't possible to specify the list of files while creating a new issue. this is inconvenient as it forces the user to focus on a two or more step process - write first the description in context of which the attachements are already mentioned and after it's submited attach the files. Easily avoidable in an integrated editor.

Note that especially in case of older legacy trackers with a "messy" or poorly designed interface the user experience might be easily and yet significantly improved.

Query Editor and Results TODO

Integration enhancing functionality - aka Integrated Environment

This is where the real meaning of the word integration becomes apparent.

Task Editor Specific:

Already existing features.

  • tighter integration with other IDE functionality
    • hyperlinked stacktraces in a comment either open the relevant file or navigate to the versioning search history dialog where the user can the lookup the relevant version
    • hyperlinked java types referenced in a comment - the find types dialog is only one click away
    • apply a patch
      • via web - click on the patch in the task web UI, then switching to the IDE, then select the scope in a file view, then open the patch UI, then click and click and click and click trough the filesystem to the saved file, and then confirm.
      • via integrated task UI - click on the patch, select the scope on which it is supposed to be applied, then confirm
    • open another kind of attachment in the IDE - profiler snapshots, xml files, text files, all of them just one click away. Especially interesting in case when the IDE already provides a specialised editor/viewer functionality for the given file type like e.g. profiler snapshots.
  • task changes annotations
    • if a task was changed since the last time the user has seen it - the changed fields in the task editor are annotated with a different color
    • if a task was changed while it was edited by the user (midair collision) - the conflicting fields are annotated

Planned features.

  • associate private notes with an issue - obviously, for the extra value in such a feature to appear, the private notes have to be tightly integrated with the task editors UI so the user doesn't have to switch between task editor and the notes editor anymore. Also that once the task editor is open and the notes are just by hand and do not have to be looked up at a different place in a different tool.
  • offline mode - the last downloaded task state is persisted. The user can open and change a task, save the changes, close the task, open it again as wished. Submit is done when online again. It is a state of the art feature when working with emails, seems to be quite convenient for working with tasks as well.
  • d&d facilities ?

Note that private notes and offline mode are expected to work for all future mylyn connector integrations. No significant additional effort necessary.

  • hyperlinked commit references - opens on click the dedicated versioning history UI

Other features

Already existing.

  • commit hooks
    • select and close an task on commit.
    • associate task and commit
  • attach patch - create a patch file and attach it to an issue without having to browse on the filesystem to store the file first and then to again when using the attach UI in the issue dialog
  • task state annotations - the IDE annotates tasks in a task lists (query result, task categories) which were remotely changed or new since the last a user has seen them.


  • private scheduling - e.g. schedule an issue for this week even if it is "officially" scheduled for the end of the release in 3 months - the user can better fine tune what and when has to be done by his own schedule. According to this make it also possible to lookup issues privately scheduled for this week. And agains - the user easily finds out what he has planed to do and when. On top of it - some tracker don't even have to come with a scheduling functionality at all.
  • attach other IDE files/artefacts - d&d?

Note the editor for issues from netbeasn.org/bugzilla was enhanced with a set of nb project specific features. Theoretically speaking such option (UI extensions) stays open also for other potential providers. e.g. a submit hook - automatically attach the messages.log file when submitting a new issue.


At least some query support is necessary to get a reasonably useful task support into an IDE. To achieve this, it is necessary to implement a repository setup, connection and repository metadata representation. There also has to be a query editor, query execution and a task result list. Further on, once the requirement for at least some integration on task level is requested (e.g. commit hooks), then also a tasks representation has to be implemented in the IDE support. Once it is possible to programatically access and change a task from the IDE and also considering all of the possible features that were already mentioned above, then it seems to obvious, that a task editor make sense as well. Because that's where a significant and interesting part of the tasks integration actually happens.

Last but not least - let's not be ignorant about the fact that many third party mylyn connector implementors already decided (and so perhaps also found it useful) to invest the necessary effort into providing task editors.

thanks for reading so far ...

Not logged in. Log in, Register

By use of this website, you agree to the NetBeans Policies and Terms of Use. © 2012, Oracle Corporation and/or its affiliates. Sponsored by Oracle logo