Tasktop

Applies to: Tasktop Pro or Eclipse Mylyn Level: Beginner Summary: Learn how to focus your Java programming efforts with Tasktop, increasing your personal productivity

Which files was I working with before lunch?

In the course of a day of programming developers often work on many tasks, where each task involves a different set of methods or files. This constant shifting between tasks causes two problems for the developer. First, when working on a particular task, the developer is often interacting with views that contain 90-99% irrelevant information*, causing him to constantly scroll and search.

Information Overload: All of the classes relevant to a task may not fit in the visible area of the PackageExplorer view. In the view to the left, only one of the two relevant classes (in green) shows without scrolling. The dotted line represents the bottom edge of the view; elements below this line are not visible.

Second, when switching back to a task previously worked on, the developer must recall the details of the previous task, including re-finding the relevant files, in order to restart work on the task.

Context Loss: Developers often forget which classes (files) were relevant when returning to an existing task.

Tasktop helps developers by reducing information overload and eliminating context loss. Developers can focus on the high-level problems, knowing that Tasktop is tracking the details for them.

Tasktop: Shows only relevant files during tasks and recalls files relevant to previous tasks.

Working Task-Focused

Working task-focused with Tasktop requires only a small adjustment to most developers’ workflow. Here we present an example workflow that developers may follow when working task-focused.

When working task-focused, a developer must activate a task before beginning programming for that task. This is the only required deviation from most developers’ normal workflow. To activate a task you can (A) press the “Activate” button in the task editor, (B) click on a task’s context icon in the Task List, or (C) use the recent task selector in the Task List.

Once you activate a task you will notice that the Package Explorer is now empty except for the phrase “Empty task context, alt-click or unfocus”. Your files are not missing. Tasktop has filtered your view to show only the files that are relevant for the task. Because you have not yet worked on this task, the set of relevant files is empty. There are several ways to find files and begin working on your task:

If the user chooses to start by using Open Type, and opens class X, class X becomes visible in the Package Explorer because the developer has expressed interest in it by viewing it. As a developer views and modifies this and other files, Tasktop automatically determines which files are most relevant, based on a degree-of-interest model (IBM Developerworks Article), and displays only those files to the user. The degree-of-interest model behaves as one might expect, marking files the developer views and modifies as relevant. However, as the number of files with which the developer has interacted grows, the view could become cluttered, so Tasktop systematically prunes and modifies the set of relevant files. For instance, files that the developer viewed only once will eventually drop out of view as the developer views and modifies other files. On the other hand, files that the developer modifies or views extensively will appear as bold in the Package Explorer, denoting their importance to the given task. The table below shows an example of developer activity and the corresponding elements that Tasktop would display as a result. Note that because class B was only viewed once, and never revisited, it has dropped out of view. In practice, it takes more activity to cause a file to drop out of view than the activity shown in the example.

Developer Activity	Files showing in Package Explorer
View class A View class B Modify class A View class C Modify class C Modify class A Modify class C View class A View class D

Working with the Package Explorer focused can feel like a major step for some developers. For developers that want to experiment with working focused without this step we recommend unfocusing the Package Explorer. Files that are viewed or modified many times during a given task will appear as bold in the Package Explorer, to indicate their unusually high importance to the task. When working with a task, notice how often that you return to the same few files. If you find yourself continually visiting the same set of files for a given task try focusing the Package Explorer. Tasktop will then focus you on that set of relevant files and eliminate extra scrolling and searching.

Multitasking

Tasktop helps you focus on completing individual tasks, but most developers spend their day moving between several tasks. Multitasking is where Tasktop really shines. Consider working on task A and populating your Package Explorer with relevant files. After working on this task for an hour you are interrupted by a high priority task B, which involves a different set of files. Upon finishing task B you return to task A. When you activate task A you will notice that the Package Explorer is populated with the exact same files as when you left the task. The diagram below illustrates the Package Explorer’s response to these task switches.

Repopulating the Package Explorer helps you restart your task with a minimum of searching and manual recollection. Often, developers will also put additional notes on the task itself, reminding them of the next step in completing the task, further reducing the cost of the context switch.

Managing Change Sets

Working task-focused with Tasktop has many additional advantages. For developers, one of the chief advantages is automatic change set management. As you work on a task and modify files Tasktop creates a change set for that task. Then, upon task completion, developers can submit exactly the files changed to address the given task, eliminating the need for manual tracking. Offloading this tracking allows the developer to work on more tasks in parallel, because she has confidence that there is a record of which changes go with which task. Managing change sets in this way virtually eliminates unintentional commits of unrelated files, which often cause problems in a source repository (e.g., compilation errors due to incomplete commits).

More Focus

Once you are comfortable working with the Package Explorer focused there are many other ways that Tasktop can focus your work. Here are a few highlights for you to explore:

Focus your assist menus: Tasktop will place relevant elements at the top of content assist and Open Type selection menus.

Focus your source code editor: Tasktop can be set to fold all elements that are not relevant in your source code editor.

Focus across all views: Tasktop focuses many other code views, such as the outline view, providing the same focus consistently throughout the IDE.

Working Task-Focused

Currently most code views in Eclipse are ineffective… they show too many files or elements to be usable. Tasktop reclaims these views by limiting their scope to the current task and the relevant files. Task-focused code views reduce clicking and scrolling during individual tasks and ease the transition between two tasks by serving as the programmer’s memory of relevant files. Tasktop tracks the details of programming tasks so you can focus on being more productive.

*This estimate was calculated using the author’s workspace and the author’s average number of relevant files.

Do you have news for the task-focused community? Send news to news@tasktop.com

Tasks are a vehicle for communication. Tasks that you create may be completed by others, and next month you might resume tasks that you create today. Whether communicating with others or with your future self, your style of communication will affect its clarity. A task you create named do the coding, while possibly meaningful when you created it, will not be clear in three weeks when you resume it. To assist you in creating tasks with style, we present the following guidelines and tips. These guidelines improve communication while also improving more technical task qualities such as searchability. If you have other naming patterns that you are using, please consider commenting on this post, as we are always iterating on these guidelines based on our understanding of task usage.

Naming tasks

Naming tasks is a surprisingly important step in task creation, as it affects a variety of task qualities. A carefully named task is straightforward to search for and, once found, easy to begin or resume work on because it is easy to understand. Follow these guidelines to create well-named tasks:

1. Start with a verb, follow with the object(s): Most task names naturally consist of a verb and one or more objects (nouns). If you consistently order these components of the task name then it is easier to scan each name, to search task names, and to categorize tasks.

   Example: add_verb content assist_object for tasks_{object 2}

2. Be specific: Using specific verbs and nouns when formulating a new task name will make this task easier to search for at a later time and will make the purpose of an older task easier to recall. In addition, being specific when naming tasks makes it easy for collaborators to understand your task.

   Example:	addverb open report buttonobject for timesheets pageobject 2
   Anti-Pattern:	makeverb buttonobject for pageobject 2

We provide two types of examples to make our guidelines more concrete. First we provide a list of verbs that commonly appear in task names. Note that many verbs are domain specific and so the most commonly used verbs will differ depending on your domain.

We also provide examples of complete task names that follow the above guidelines:

Anti-patterns when naming tasks

In addition to these guidelines we have also indentified the following anti-patterns. These anti-patterns, derived from the guidelines, address common mistakes that are made when naming tasks.

1. Avoid ambiguous references: During the act of naming tasks it often feels like overkill to precisely name all objects involved, and you will be tempted to create tasks like update wizard icons on the page. While it is clear at the time which page you are referring to, by the time you are able to work on that task it will require thought to recall, at best wasting time, at worst creating an incorrect product.
2. Avoid adverbs: Avoid starting task names with adverbs like “quickly” or “carefully”, since they are often related to planning or priority information and not to the goal of the task.
3. Avoid names and dates: Tasks are decomposed into separate fields, such as “Due Date” or “Assigned To”, so that tasks can be presented according to their properties. For instance, tasks with overdue deadlines can be shown as red. Do not include information that belongs in other task fields in the name, including collaborator names, due dates, and project names. The task named implement refresh with Todd will become inconsistent if you change your CC field to include John instead of Todd.
4. Omit common verbs: Bug reports are traditionally named with a summary of a problem. For example, tasks losing scheduled date after restart. In this sense, all defect reports are implicitly prefixed with some variant of a verb like “fix”. Since the verb could be the same for all bugs, there is not much value in adding it.

Following all of these guidelines and tips when naming tasks will lead to increased output that both yourself and your collaborators will appreciate. While it can be difficult to appreciate these guidelines in the abstract, concrete tasks that break these guidelines serve as an enlightening illustration. Here’s an example that breaks the guidelines and tips for naming tasks:

Scoping tasks

Other providers of task management systems (e.g., CollabNet, 43 Folders) agree that tasks should be reasonably sized, usually defined in terms of the estimated time to complete a task. These providers recommend avoiding tasks that are too small (e.g., type a method header), because you will spend too much time tracking every detail, or too large (e.g., implement the product), because you are likely to become overwhelmed or lost. We avoid more precise scoping rules because we have found that following our task naming guidelines, especially “be specific”, naturally leads to well-scoped tasks.

Describing tasks

Although naming a task is the most important aspect of creating a task, there are several other task fields that can be completed during task creation. Here we provide a table with recommended content for several important fields:

Giving tasks a good home

When using Tasktop, you can choose to either create local tasks (on your machine only) or shared tasks (on a server, shared with others). If you are the only person involved in the entire lifecycle of a task, create a local task. If any collaboration is involved, e.g., input from others, the task forms a part of a product release cycle, it should be a shared task. Don’t worry if you’re not sure at task creation time where your task should live as it is easy to move between local and shared tasks using Tasktop’s “Send To” action in the Task List.

When using shared tasks collaboration is simple; you can add collaborators to a task and track task communication on the task comment thread. Collaborators can use a variety of repositories so Tasktop offers several Tasktop Certified Connectors (i.e., that connect Tasktop to the repository). To begin sharing tasks browse and download Tasktop Certified Connectors.

During the course of a project you and your team could create hundreds or even thousands of tasks. If your team follows these task creation guidelines you will save time searching for old tasks, remembering the goal of an existing task, and interpreting a task someone else has assigned to you. You and your team will understand the benefits of working with your task management system, instead of against it, as you begin creating tasks with style.

UPDATED on January 30, 2009: We’ve revised the best practice to simplify the configuration and avoid duplicate tasks in the task list. We will address more advanced configurations in an upcoming how-to.

Tracking Changes with Tasktop

When working in a team tasks change quickly. The team lead raises the priority of your task, a co-worker indicates your task is blocking his work, or a domain expert responds to your task-related question. Keeping up with these changes, while still making progress on your tasks, can be overwhelming. Fortunately, Tasktop can help reduce this burden by automatically tracking relevant tasks with Queries. A Query specifies the tasks that are relevant to you, such as tasks you are in charge of completing. Creating a Query downloads and periodically updates tasks directly in your Task List, eliminating the need for checking email updates or refreshing web interfaces. These advantages and others make Queries an important part of Tasktop users’ workflow.

Screenshot 1: Is your email inbox cluttered by task updates?

In this article we’ll walk you through the mechanics of setting up a single Query as well as introduce best practices on creating a set of Queries that monitors all relevant tasks.

Mechanics: Creating a Query

Creating a Query in Tasktop is simple assuming one prerequisite. You must first configure a Task Repository (see previous post), which, fortunately, is a straightforward task. Assuming you’ve configured a repository, follow these steps to create a query:

1. Right click on the Task List and select “New Query” (see Screenshot 2)
2. In the resulting dialog select the appropriate Task Repository
3. Fill out the Query creation form and press “Finish” (see Screenshot 3 for Bugzilla’s form)

Screenshot 2: Creating a new Query

While this form includes many options to empower the advanced user, simple queries are easy to create and beginners can leave most fields blank. See the “Best Practices” section below for example form values that create common Queries.

Screenshot 3: Bugzilla’s Query creation form is shown. Other repositories, such as JIRA, have a similar query form.

Task Synchronization
Once created, Queries automatically download relevant tasks and periodically synchronize with the task repository, ensuring that your Task List is always up-to-date. You can adjust the automatic synchronization interval by navigating to Window -> Preferences -> Tasks. You can also manually synchronize by right-clicking on a task or query and clicking “Synchronize”. When updating, a Query or Task will be displayed in italics in the Task List (see Screenshot 4).

Screenshot 4: Task 3778 (in italics) is being synchronized and Task 3817 has already finished.

Once a Task or Query is updated Tasktop will create visual indicators in the Task List (see Screenshot 5). In the example below Tasks 2 and 11 have changed since they were last viewed and Task 15 is a new task has not yet been viewed. A single scan allows you to know which tasks are updated, which are new, all within the context of your Task List, which is sorted by priority and scheduled date. When using the Task List to stay updated you can eliminate task update emails. As a final step to eliminate these emails we recommend turning off email notifications on your Task Repository (see “Turning Email Updates Off” below).

Screenshot 5: A Task List with notifications: arrows indicate updates and arrows with ?s indicate new tasks.

Best Practices: Crafting a Smart Set of Queries
Tasktop allows significant configurability when deciding which queries to put in your Task List. To achieve the full benefit, we recommend you try the following guidelines when setting up your Task List. Do this for every task repository of interest.

1. Set up a single query for all tasks assigned to you.
2. Set up another query for all tasks that you’ve reported, commented on, or been CC’d on.

If you follow these guidelines you will end up with a Task List that is similar to this one:

This query set focuses you on the tasks you own (“All Mine”) while keeping you in the loop on the tasks where your input is needed (“All Related”). To setup these queries, use the following parameters in the Bugzilla query form.

In some cases, it’s also desirable to create queries to easily track the tasks of people you collaborate with closely. We will address this more advanced case in an upcoming how-to.

Now that your Task List is populated you are better prepared to deal with a busy workweek. New tasks may be assigned to you and priorities may change but your Queries will keep you up-to-date. You’ll be able to focus on the task at hand, knowing that you’ve offloaded significant responsibility to Tasktop.

We’re pleased to announce the first in a series of “How-to” posts that will help you make the most of the task-focused technology in Tasktop and Mylyn. We’ll start with basic topics for new users and then move on to techniques and best-practices for advanced users. Enjoy!

Teaming Up with Tasktop

Although you can always create “local tasks” to streamline your workflow, the full benefits of task-focused productivity are realized when working together as a team. When working as a team, you create shared tasks in a Task Repository. A “Task Repository” is any system that tracks a team’s work items such as bugs, tasks, issues, defects, stories, etc. When sharing tasks using a Task Repository, Tasktop streamlines your team workflow. For instance, Tasktop provides task updates in real time, eliminating lag, and makes it easy for users to share task-relevant comments, files, and contexts, reducing unnecessary emails and file searches. To begin enjoying these benefits each teammate should install Tasktop Starter (Free) or Tasktop Pro and the team should have one (or more) Task Repository.

Tasktop is compatible with many popular Task Repositories (see the full list to check if yours is supported).

1. Installing a Connector

Setting up Tasktop to connect to your team’s repository involves two steps. First you will need to install the appropriate connector, which is a single click for Tasktop Certified Partner Connectors. Second, you will need to configure Tasktop’s settings to connect to your team’s repository.

To install the appropriate connector you will need to know what type of Task Repository your team uses (e.g., JIRA, CollabNet, Rally, etc.). If your team does not yet have a Task Repository there are many that are compatible with Tasktop (see the full list). Tasktop comes with the Bugzilla connector pre-installed, so if your team uses Bugzilla as your Task Repository you can skip to step 2.

Installing Certified Connectors

Certified partner connectors are certified by Tasktop Technologies to ensure quality and usability and can be easily installed from Tasktop. If you’re a Mylyn user you need to upgrade to Tasktop Starter (Free) or Tasktop Pro to use this easy installation feature. Alternatively, Mylyn users can follow the instructions for uncertified connectors. Connectors for JIRA, CollabNet and Rally are Tasktop-Certified.

Installing a certified connector is a simple process. Select “Configure Tasktop” from the main toolbar, follow the “Partner Connectors” link, and click the “Install” link next to the appropriate connector (illustrated above).

Installing Uncertified Connectors

Dozens of other connectors are available so that Tasktop users can connect to popular task repositories. While these connectors are not certified by Tasktop, you may find that many of them work well. Some of the most popular uncertified connectors are Trac, Mantis, and XPlanner. A full list is available here.

To install uncertified connectors you will need the update URL for your connector, which can be found on this listing. The Update URL for Trac is http://download.eclipse.org/tools/mylyn/update/extras. You will then need to add the Update URL as a new update site and click through the install process.

Once you have the update URL, first open the “Software Updates” menu:

Then click “Add Site” and paste your update link. Once your site appears in the list make sure it is checked and click “Install”.

Once you have installed your connector it is simple to verify whether the installation was successful. Open the Task Repository view and click “Add Task Repository” (see the next section for detailed instructions on how to open this view). If the repository type appears in the resulting wizard then the install process was successful. Below, Tasktop is shown with Bugzilla, Generic IMAP, GMail, and JIRA successfully installed.

2. Adding a Task Repository

Once you have installed your connector you will need to add a Task Repository to Tasktop to access your tasks. Here we will walk through the process of adding a JIRA repository. Adding other repositories follows the same process except for the final configuration form, which has a few necessary differences for each repository type.

First, open Tasktop’s Configuration Page to open the Task Repositories view and click on “Add Task Repository”. In the resulting dialog select “JIRA” and click “Next”.

Next, fill out the Repository Settings form with the URL, username, and password necessary to connect to your Task Repository. When you are finished you can press “Validate Settings” to verify your settings.

After pressing “Finish” your repository should appear in the Task Repositories view. Below is the repository created by the above form. Notice that the Task Repository has a decoration to indicate its repository type (i.e., JIRA as opposed to the “Tasktop Support” repository whose type is Bugzilla) and that the Label entered above is used in the Task Repository view.

Teamwork Ready

You’re done! Now you’ve successfully added a Task Repository to your configuration and Tasktop can begin streamlining your team workflow. To begin interacting with your team you will need to decide which tasks to download to your personal task list by creating Queries (right click on the Task Repository and select “New Query”). In the next post, we will introduce best practices on how to setup your Queries to best keep track of your tasks and keep you up-to-date on your team’s tasks.

This week we’d like to highlight an insightful blog post by David Green. David has applied Mylyn’s degree of interest model to focus complex diagrams on only the interesting elements. You may also be interested in a set of slides from a talk by Avishay Halperen and Ori Dar that concisely introduce the Mylyn framework and some of the technologies that build on it.

Every week we come across a growing number of thoughtful articles and blog posts about the task-focused interface technology behind Mylyn, Tasktop and other task-focused tools. These posts include events, how-to’s, experience reports, and reviews of task-focused software. Starting today, we will post a weekly summary of interesting task-focused content.

If you would rather omit these summaries from your feed, please update your reader to use this feed URL: http://tasktop.com/blog/?feed=rss2&cat=-8

Since this is the first community news post, here are some of the best news items from the past several weeks: