Tasktop Blog

The recent Mylyn 3.2 and Tasktop 1.5 release for Eclipse Galileo (3.5) includes a new Connector Discovery wizard that makes it much easier to find and install Mylyn and Tasktop connectors. This has proven to be a popular feature and we’ve teamed up with Atlassian to produce a short screencast that shows it in action.

This screencast shows an example of how to install the Atlassian Connector for Eclipse, which provides Eclipse integration for JIRA, Bamboo, Crucible and FishEye. All other Tasktop Certified connectors can also be installed using the Connector Discovery wizard.

Tasktop CEO Mik Kersten has been awarded JavaOne Rock Star status, which recognizes speakers for outstanding session content and speaking ability. In an interview with Janice J. Heiss, Mik discusses his most recent JavaOne talk, Eclipse Mylyn, cloud computing, advice for Java beginners and more. The interview is reproduced below.

	Mik’s 2009 JavaOne session is “Mylyn: Redefining the ‘I’ of the IDE”, which was also delivered previously at QCon. Watch the video and slide show of the QCon talk (Note that the fonts and formatting aren’t properly reproduced).

JavaOne 2009 Interview with Janice J. Heiss

Bio: Mik Kersten is Chief Executive Officer and Co-Founder of Tasktop Technologies. His session focuses on how Mylyn, a task-focused interface tool from Tasktop, can be used by Java developers in their everyday work. Kersten invented the user interface technology underlying Mylyn while working on his Ph.D. at the University of British Columbia in Vancouver, Canada. While completing his Ph.D., supervised by Gail C. Murphy, Kersten and Murphy co-founded Tasktop, which provides productivity software built on the Mylyn technology.

Q: Tell us about your 2009 JavaOne Conference session.

A: The goal is to show developers how they can start on the path to doubling their productivity. We’ve all experienced moments in which we feel like we’re coding at the speed of thought. For some, it only happens when they are distraction free during late-coding sessions, or at release crunch times. With our task-focused interface, we’ve discovered that it’s possible to bring that level of productivity to day-to-day work. Hundreds of thousands of developers have already started working this way with Eclipse Mylyn. But many are still discovering the technology and tools, so during the presentation newcomers will get a high-level overview of how to streamline their Java tool suite in order to make coding faster and easier. Seasoned users will get a preview of the new productivity features in Eclipse Galileo and Mylyn 3.2, to be released on June 24.

Q: Tell us why the notion of a tool that hides more of the program than it shows is not a crazy idea.

A: Consider the size of a typical Java application. Tens of thousands of lines of code are common. Add to that the size of the JDK and other SDKs that you’re building on, and we’re talking about millions of lines of code. When I’m working on Mylyn and Tasktop, I have around eight million lines of code at my fingertips.

Now consider the size of the monitor sitting on your desk. If you’re lucky it’s 1280 pixels tall. In a tree view — one of the key facilities we have for navigating program structure — you can see only a few dozen elements on the screen at a time. In other words, you can’t possibly see the whole structure of the system. After just a few navigations of the code, these tree views can end up showing thousands of elements that are not relevant to the task at hand. There’s something wrong with this picture. So a traditional user interface often demands more browsing and searching than coding. But, for any task, any bug you fix or feature you add, you only care about a subset of the system that’s relevant to that task. Instead of showing you the compiler’s view of the entire system structure, the task-focused interface shows you only what’s relevant to the task at hand. All the structural information is still at your fingertips, but in the views and editor you see only what you’re working on.

Q: You say that “tasks are more important than files; focus is more important than features; and an explicit context is the biggest productivity boost since code completion.” Elaborate.

A: Whether you’re fixing user-reported defects, working against a SCRUM backlog, or submitting patches to your favorite open-source project, tasks define what you’re working on. Files and classes are the artifacts that you modify in order to complete the task. Thus, tasks should drive your interaction with files, not vice versa. Ever since the original GUI that Xerox PARC produced, we’ve been obsessed on streamlining interaction with files. As a result, the latest indexing and search technologies are quite adequate. It’s now time to evolve the user interface beyond files in order to handle the vast amount of information that we work with today. Automating the capture of task context has enabled a productivity transformation that we have been able to measure with statistical significance.

Q: What is the biggest down side to a task-focused interface?

A: That we’re not finished with it yet. Don’t get me wrong. If you do a Twitter or blog search for Mylyn you’ll see a stream of people stating how much it’s helping their work and programming activities. But, to date, we’ve taken a very incremental approach to extending the IDE user experience. You can use Mylyn without its focusing facilities for task management alone. You can use each of the focusing facilities selectively. We’ve constrained ourselves to layer the new facilities over the existing UI metaphors in order to enable an incremental adoption. It has been important in order to enable the rapid adoption of Mylyn over the past couple of years. But I’m getting an itch to make more fundamental changes to the user experience, basing more of our interaction with the computer around tasks. A few of these changes are already starting to show up in the Tasktop, the commercial version of Mylyn, which is bringing the task-focused interaction metaphor to the desktop and web applications.

Individual Developers and Mylyn

Q: Are there individual strengths and weaknesses that make developers better or worse at working with Mylyn?

A: There’s one interesting trend that I’ve noticed. In some cases, very experienced and senior developers don’t feel as much need for the focusing facilities of the tool. They’re familiar enough with the code that they work on that they can rely on their mental map of the system in order to navigate, rather than rely on tool support. Thankfully, for the rest of us there’s the tool support. And context sharing makes it easier for developers of all experience levels to collaborate around the code.

Q: What do you hope to accomplish with Tasktop Technologies?

A: We want to bring the benefits of the task-focused workflow to everyone’s workday. Based on our research results and adoption of Mylyn and Tasktop, we are convinced that this way of working can double productivity and bring more control to people’s work life. It’s an audacious goal, given that we’re a growing startup, but we’re doing it alone. We’ve created an innovation network with our partners to bring this shift about, including SpringSource, Atlassian, CollabNet, Rally, and IBM. We’ve made such a big portion of the technology open source that we’ve also had the benefit of hundreds of community patches to help us harden the Mylyn framework and APIs in order to extend them to more and more tools and integrations — three dozen at last count.

Cloud Computing

Q: What do you see ahead for cloud computing?

A: I’m interested in how the split between the client and server is getting redefined. Browser/JS/AJAX clients are here to stay. But for some applications having a rich client that’s connected to the cloud will provide a fundamental advantage. Consider Mylyn, where our goal is to open up your task, typically hosted in a web application, in under 200 milliseconds. We also need to ensure that your work is not interrupted if you go offline or if the network goes down. To achieve that, we have a sophisticated offline store for all the cloud-based data that you access, all while seamlessly integrating browser-based access when you are connected. These hybrid rich client approaches will help bring the desktop user experience to cloud-based applications.

Q: Can you describe the process of writing code?

A: Activate task, focus, repeat.

Q: What do you see as the most important API in Java three years from now?

A: That depends largely on your application domain, but considering the trends in processors and virtualization, I believe that the Concurrency API will be more and more important. As programming models continue to become more asynchronous, the current Concurrency API helps take the pain out of debugging concurrent applications.

Q: Can you give us an example of code that you are most proud of creating and explain why?

A: The InteractionEvent class and related parts of the Mylyn Monitor framework. This is the underpinning of Mylyn’s task-focused interface and isolates the various models that we have created from the user’s interaction with the system, such as the degree-of-interest model that defines the task context. The API and its externalization has not changed since the first Mylyn 0.1 prototype, since it stores interaction data in its most basic form, as a stream of interaction events. As a result, I can load a task context from Mylyn 0.1 into Mylyn 3.2 without requiring any data migration. No other API I’ve written has managed to be that stable, although notably all releases since Mylyn 3.0 have been binary compatible.

Q: The Java class that you couldn’t live without is…?

A: A year ago, I would have probably answered ConcurrentHashMap or CopyOnWriteArrayList. Except that I’ve now used them in the Mylyn codebase so much that we’ve had to reduce their use due to the fact that they can end up allocating a lot of memory when not used diligently.

Q: Favorite Java book?

A: Effective Java by Josh Bloch, by far.

Q: What do you do when you feel stumped?

A: Switch to a lower energy task.

Q: What recent changes to the platform have made your life easier?

A: Generics. And OSGi. I do realize that OSGi may not yet be part of the Java platform, but it has been such a key enabler of all our programming that I can’t imagine using Java without it.

Advice to Beginners

Q: What advice would you give to a programmer new to the Java language?

A: That you’ve made a good choice and that the language will be worth the up-front investment that you need to make to become proficient at it. Statically typed object-oriented languages will continue to play a very important role in how we build large systems. At Tasktop Technologies we use a pretty broad range of programming languages to get the job done. But building our core products and frameworks on Java, leveraging Java-based APIs in the JDK and Eclipse, and having access to the first-rate tooling available for Java, has made it possible for us to work very effectively with a humongous code base.

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.

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.

While Mylyn will happily display other languages and character sets coming from the task repository, the Mylyn UI has never been internationalized. The Eclipse Babel project has provided a great service by enabiling the community to contribute translations. But to support Babel, a project needs to update its codebase to support internationalization.

In a tireless effort, Hiroyuki Inaba contributed patches that externalize strings in the Mylyn code base. Despite a changing code base and the necessary IP review process, Hiroyuki kept the patches current and we were able to apply them to cvs last week. A new build is now available from the weekly update site.

The changes introduced by the patches were quite significant and a few strings may have been lost or misplaced in the process. If you encounter any missing or garbled strings in the latest weekly build, please comment on bug 258358.

Starting now, everyone who has a Bugzilla account can help translate Mylyn through Eclipse Babel. Follow the Help Translate Eclipse link, select a language and choose tools.mylyn as the project to make Mylyn speak your native tongue in time for the upcoming Galileo release.

The love of camping, for many, is rooted in the experiences we had as kids being dropped off in the great outdoors for a week of fun, food, and friendship. We’d learn how to create shelter from branches and fire without matches; survival skills we’d hopefully never have to rely on. All too soon the week was over and it was time to say goodbye to all the new friends. Good times.

Fast forward to November 25th, 2008, the 2nd Vancouver Eclipse Demo Camp. We had a bunch of similarly eager faces gathered around the warm glow of a projector waiting to see the latest in Eclipse-based Technology. It only lasted one evening but we all learned about cool stuff and met a bunch of great people over beers (no Marshmallows at this camp). I kicked things off with an overview of the Eclipse Ecosystem and its amazing growth to date, then we jumped right into demos.

David Green introduced us to WikiText, the slick new wiki syntax and rendering engine slated for Mylyn 3.1. Blog, Slides:

Jingwen Owen Ou then gave an excellent overview of his Google Summer of Code experience developing numerous features for Mylyn 3.1 including intelligent comment folding, find support in the task editor, and WikiText Mylyn integration. Slides:

Kaitlin Duck Sherwood demonstrated Tripoli which leverages code coverage tooling to quickly locate where behavior is implemented.

Guillaume Pothier of Pleiad Lab, University of Chile presented TOD, an amazing debugging tool that can travel back in time to when and where a variable was set! Slides:

Mandeep Jassal of BusinessObject/SAP Vancouver demonstrated Crystal Reports for Eclipse which enables report construction and execution all from within Eclipse. An Eclipse RCP based Crystal Reports viewer was also demonstrated. Slides:

Andrew Eisenberg of SpringSource gave us a glimpse of the work he has done to make JDT more extensible though application of load time weaving (using AJDT). Slides:

Mik Kersten of Tasktop Technologies discussed the Task-Focused Interface and how Tasktop is able to use the modularity of Eclipse to address different market segments. Slides:

Thanks to all who participated this year and to each of the presenters. To be notified of other Mylyn, Tasktop related news, consider signing up for the Tasktop newsletter.

I hope to see you all again at the next Vancouver Eclipse DemoCamp!