Tasktop

I’ve long been an admirer of Tasktop, for a number of reasons: First, as Eclipse users already know, Tasktop has built some really cool Eclipse technology, including the Mylyn task-focused interface. But many companies have built cool open source tools. It’s much harder to take those tools and build a growing, dynamic company around them. But plenty of companies have also done that, usually by following the standard open source business model: package services and a bit of value-add around a captive open-source offering, and wait for customers. Tasktop takes a far more challenging and rewarding approach: It nurtures a healthy open source eco-system around core technologies, but then re-imagines and re-purposes them, leveraging unique products that address real customer pain. That takes real vision, and to me it’s a clear signal that the Tasktop leadership is able to imagine and execute at an entirely different energy level.

So rather than admire Tasktop from a distance, I joined it! I first worked with Tasktop last year as a consultant developing the initial implementation of what has become the Mylyn Model Focusing Tools project. That was a great opportunity to get to know some of the team and the Tasktop way. Everything I saw then fit nicely with what I’d already intuited. We have a really great combination of engineering excellence, creativity and lightweight organization.

It’s nice to say “we” again — I hadn’t realized just how much I’d missed having colleagues to work together with on challenging problems. The morning I joined Tasktop, I saw a stream of emails from everyone welcoming me to the team. I must admit to some cynicism about the whole “team” thing — like so much else, it can be an empty word that doesn’t match up to reality — but in this case it feels very genuine. So heartfelt thanks to everyone.

It’s an exciting time to be building software tools. It might sound funny, but I like to think of software development as a helping profession. That’s because I think that software products really can help people live more fulfilling, interesting and even happy lives. When I tell my family and non-techie friends that I’m working on Automated Lifecycle Management (ALM) tools I get a blank look. So instead I remind them that almost everything we do relies on software and that software programs are by far the the most complex artifact that humans have ever created. And I tell them that software development communities are growing ever more diverse, distributed, interwoven and complex. So what do we do at Tasktop? We build software that embraces those complexities.

Tasktop Dev tackles the issue of software complexity. It handles a lot of the repetitive and boring stuff, simplifies and clarifies everything else, and is deeply and imaginatively integrated with other development tools. Tasktop Sync and Code2Cloud — along with other exciting tools that we’re working on — tackle the even more challenging issue of community complexity. Even a relatively small software product might involve code developed by a rich community spanning companies, technologies, continents, and even (think about the Open-Source movement) different economic models and incentive systems. And in larger projects thousands of developers might be collaborating across all of these dimensions. Software development efforts are intimately connected with customers, management, marketing, support, regulators and every other imaginable kind of stakeholder. All of these people need to talk to one another, and it seems that everyone uses different tools to manage the unique aspects of their tasks or work environments. Tasktop builds software that helps those tools to work together so that everyone can focus together on the stuff that matters. In short, we break down boundaries and help people communicate. That’s worth doing.

In Eclipse 3.6 we worked with the Microsoft interoperability team to bring some major improvements for Microsoft Windows users, such as Jump Lists, taskbar progress indicator and taskbar overlay text and images. As part of Tasktop’s ongoing partnership with Microsoft, we’ve been working hard to bring you two more improvements this year: Desktop Search, and Glass.

Desktop Search

The idea behind Desktop Search is simple: enable developers to search for resources outside of the current workspace. Until now Eclipse developers have only been able to search for resources within their workspace. First requested in 2007, this feature will help developers using multiple workspaces or those who regularly work with non-workspace files or documents.

While Desktop Search works for users on any OS, Windows users will experience a much faster search as a result of tight platform integration with Windows Search. Windows Search provides a full-text search index over a user’s files. The powerful Windows Search “SELECT TOP” syntax is used to find the most relevant matches.

Workspace and non-workspace resources are displayed side-by-side in the search result.

We hope to have Desktop Search integrated as a Platform feature for Eclipse 3.8. In the meantime, Desktop Search is available from the Mylyn Incubator update site. To install select “Help -> Install New Software” from the Eclipse menu. Using the following site http://download.eclipse.org/mylyn/incubator/3.7 select “Mylyn Desktop Search (Incubation)”. If this is something that you’d like to see as an Eclipse Platform feature, please vote for it on bug 192767.

Aero Glass for SWT

Modern Windows applications can have transparency, commonly known as Glass. For the first time, with this latest improvement to SWT on Windows, both Eclipse workbench and Eclipse RCP applications will be able to look like modern Windows 7 applications.

As an example here is the Glass look applied to the Tasktop RCP application, which only took a few hours of effort:

In this screenshot we’ve updated Tasktop RCP to use Glass for the shell, toolbar and search widget.

RCP and Eclipse platform developers will be able to use Glass with the new TRIM_FILL style bit:

	Shell uiShell = new Shell(display, SWT.SHELL_TRIM | SWT.TRIM_FILL);
	uiShell.setText("Glassy World");

	Composite uiRoot = new Composite(uiShell, SWT.TRIM_FILL);

Looking forward we would like to see this new Glass support adopted by the workbench modernization effort in e4.

Glass support in SWT is nearing completion, under development on bug 325795: support Windows Vista and 7 Aero Glass shells.

Eclipse And Windows – Looking To The Future

Through our partnership with Microsoft, Tasktop is continuing our efforts to keep Eclipse looking fresh and modern on Windows. We are currently discussing the next round of improvements, so if you have any ideas or feedback about what you’d like to see next, please drop me a note at david.green@tasktop.com.

You can read more about these and related efforts from the Microsoft perspective:

• Windows Gets Eclipse Platform Improvements
• Eclipse shines on Windows 7: Microsoft and Tasktop partnering to contribute code enhancement to Eclipse
• Interoperability Bridges and Labs Center

Contributors

Many thanks go out to Felipe Heidrich, Scott Kovatch, Mike Wilson, Steve Northover, Silenio Quarti, Bogdan Gheorghe, Raymond Lam, and Shawn Minto for helping to make Glass with SWT a reality, and to Łukasz Milewski for his prototype. Thanks also go out to Raymond Lam, Shawn Minto, Steffen Pingel and David Green for creating the desktop search integration, and to Dani Megert for supporting integration into the Eclipse core platform. Also I’d like to give a special thank you to the Microsoft Interop team who have been driving a better experience for Eclipse users on Windows.

This year, Tasktop Technologies and VMware co-hosted the Eclipse Indigo DemoCamp in Vancouver. The event was a smashing success with some 60 developers in attendance, awesome networking and even cooler talks including:

		Presentation by Ralph Muller from the Eclipse Foundation
		Benjamin Cabé from Sierra Wireless presenting on Koneki
		Rafael Chaves from Abstratt Technologies presenting: “Full code generation with AlphaSimple” (AlphaSimple is an online modeling tool built on Eclipse technology)
		Kris De Volder from VMware presenting on Cloud Foundry
		Presentation by Ed Merks, project lead of the Eclipse Modeling Framework project
		David Green of Tasktop Technologies presenting the latest Mylyn integrations for Git, Gerrit and Hudson (see photo below)

To get a sense for what Demo Camps are all about, watch the video of the opening talks from VMware’s Andrew Eisenberg, Eclipse’s Ralph Mueller, and Tasktop’s David Green available here: http://vimeo.com/25746826. We were not able to capture the sessions, but hope to do so next time.

After the event, we all headed out to a nearby Lennox Pub for more fun and networking…

In this picture, Ralph Muller of the Eclipse Foundation, as well as Andrew Eisenberg of VMware and other developers networking in the background.

For more information about the DemoCamp please see the Vancouver Eclipse Indigo DemoCamp wiki

Hope to see you all there next year!

The Tasktop team is growing again! We have four new technical positions available. This is a great opportunity to join a fantastic team of world-class engineers who affect hundreds of thousands of people through open source and our proprietary innovations.

The Tasktop Team, Vancouver contingent

Before I joined Tasktop, I was astounded at the Tasktop’s velocity and the impact they’ve had on software developers through Tasktop’s “less is more” approach to developer tools and the task-focused interface. Now that I’ve seen it from the inside, I understand that it’s a combination of many factors: the caliber of the team, the extent to which Tasktop’s innovation is driven by community, the way that Tasktop works with its customers and partners, the connection to thought leadership both within Tasktop and at large, the way that Tasktop communicates and organizes, and Tasktop’s culture of listening to and empowering the individual.

If you’re passionate about software and people, love technology and tools, have a persistent hunger for learning, and want to work with some of the best minds in the industry, apply and join the Tasktop team!

Software developers leverage many supporting technologies to get their own work done and to coordinate their activities with others. Developers use issue-tracking systems to organize tasks, SCM systems to store source code, and an IDE to write code. As developers use these disparate technologies it’s easy for them to develop ALM ADD. They switch to the issue tracking web UI to determine what task to do next, open the IDE to work on that task, and use a command-line client to check-in the newly created code. They code for a few minutes and then reopen the web UI to retrieve a code snippet. The constant switching, inability to focus, and distraction that is a hallmark of this workflow kills developers’ productivity. It causes otherwise productive programmers to forget relevant details and struggle to stay on task. Fortunately, through tool support this development disorder can be avoided.

In our upcoming joint webinar with Perforce we’ll be showing how to use Perforce and Mylyn to stay inside of Eclipse as you work. Instead of switching from IDE to browser to command-line, we map out a IDE-centric approach. Of course, bringing the ALM tools into the IDE avoids switching, but it also enables some deeper integration across the ALM stack such as automatically creating change-sets for tasks. Sound interesting? Join us by registering for the webinar that Perforce’s Randy DeFauw and I will be holding on Wednesday, April 27, 2011, 11 AM PDT / 2 PM EDT.

Several Tasktopians will be speaking at EclipseCon 2011 in Santa Clara, CA March 21 – 24. As well, there will be several additional sessions on Mylyn. If you are attending Eclipsecon, please do stop by and say hello:

Monday, March 21 13:30 – 13:50 in Stevens Creek
Tired of CVS? Pimp your productivity with Git, Gerrit, Hudson and Mylyn
by Tasktop’s Benjamin Muskalla and Tasktop’s Steffen Pingel

Tuesday, March 22 10:40 – 11:00 in Stevens Creek
Case Study: Shipping Mylyn Reviews for Software Development in Air Traffic Management
by Mylyn Review lead Mario Bernhart as well as Stefan Reiterer and Killian Matt

Tuesday, March 22 11:10 – 11:30 in Stevens Creek
Mylyn meets Intent : Documentation made fun and useful
by Cedric Brun

Tuesday, March 22 14:00 – 14:20 in Ballroom BC
The Mylyn Reloaded
by Tasktop’s CEO Mik Kersten (and Chris Aniszczyk and Wayne Beaton)

Tuesday, March 22 14:30 – 15:10 in Ballroom D
The Business of Selling Free Software
by Tasktop’s President Neelan Choksi

Tuesday, March 22 19:30 – 20:30 in Camino Real
Mylyn – Application Lifecycle Tools BoF
with Tasktop’s Kersten, Pingel, Muskalla, and Choksi

If you are going to at EclipseCon 2011 in Santa Clara, CA, contact us to set up some time to meet.

Over the past year I’ve been working closely with those in the Tasktop and Mylyn community at large to define best practices for task-focused programming and collaboration. My goal has been to share what I’ve learned about how the leaders in task management use Tasktop and Mylyn to collaborate effectively. To this end, I’ve created several articles on the major task management topics. My focus on major topics is necessary to communicate the full task management vision, but it also results in longer, more intense in-depth posts.

I’ve found the perfect companion series to my in-depth best practices posts. Marc Esher, a thought leader in the Eclipse and Cold Fusion community has been creating an outstanding series of articles on Mylyn best practices in short, bite-sized posts. His content includes great text and often includes a video walkthrough of the feature or concept that he is focusing on. Next coffee break skip the walk (or drive) to Starbucks, grab a home-brewed cup, and spend 5 minutes with one of Marc’s posts. You’ll save a few dollars and your new-found Mylyn knowledge could save you a few minutes (each day!).

Here are Marc’s Mylyn posts to date:

1. Why Mylyn is Indispensible
2. The Best Eclipse Menu You’ve Never Heard Of
3. Mylyn and Jira Short Tutorial
4. Mylyn and Jira Sharing Context
5. Mylyn Creating New Issues

I hope you enjoy these articles. If you have any input on task management best practices please join the dialog with me on Twitter. I love to hear from users and your input will influence our future posts.

“An apprentice carpenter may want only a hammer and saw, but a master craftsman employs many precision tools. Computer programming likewise requires sophisticated tools to cope with the complexity of real applications, and only practice with these tools will build skill in their use.

–Robert L. Kruse, Data Structures and Program Design

Eclipse is one of the most sophisticated toolsets ever offered to developers. Its plethora of available tools can eliminate many headaches from a developer’s day. Unfortunately, there are days when headaches still occur, as developers struggle to discover and use all Eclipse has to offer. A great technique for discovering the most useful tools in Eclipse is to watch an experienced developer work. In this post I’ll be sharing my change set toolset knowledge, gained from watching others, in hopes of eliminating unnecessary clicks and frustration from your workday.

The (Small) Cost of Change Set Support

Contrary to many spammers’ beliefs, everything in life has some costs, and the advantages offered by Tasktop and Mylyn’s change set tooling are no exception. To enable the benefits of the change set tooling you will need to:

1. Click the “Activate” button on a task before starting that task
2. Click the “Deactivate” button when finishing a task

Once you develop the habit of working in this way (see Task-Focused Tutorial for details) then you will be able to:

1. Navigate from any line of code to the relevant task or bug report
2. Review your teammates changes and view only the files that changed
3. Quickly erase changes made for a given task (Undo at the task level)

The following sections will walk you through different aspects of the change set tooling and show you how to maximize your benefits.

Change Set – ..the set of changes made in a single commit.

http://en.wikipedia.org/wiki/Revision_control

In (hopefully) all software development organizations there is repository for storing your code. For Eclipse users this often means using a Software Configuration Management (SCM) system like CVS or Subversion. When working with an SCM developers usually download the entire code base and then submit updates to this code base in the form of change sets, or a set of files that they have changed.

Tip #1: Tracking Current Changes

Tasktop and Mylyn automatically track the changes that you make as you work on a task, thus automatically creating a change set. You can view all of your current changes by opening the Synchronize View. Be sure to toggle the view model (circled below) until you are viewing changes as change sets.

Viewing changes using the Synchronize View makes it easy to quickly review others’ changes and to manipulate your own. The left pane in this example contains four change sets, one of which is expanded.

As you make changes when working on a task a new change set will be created and shown in the Synchronize View. Thus, when you have completed a task it is easy to commit only the relevant code. Open the Synchronize View, right-click on the change set, and select Commit. Occasionally you will work on a task and then abandon it, either because it seems infeasible or because priorities have shifted. In this case it is easy to remove all the changes you’ve made for that particular task by selecting the change set in the Synchronize View and selecting Override and Update (see screenshot above).

Tip #2: Connecting Commits with Tasks

All source code was written for a reason, but when viewing a particular file the original reasoning is not always clear. Fortunately, when using Tasktop/Mylyn tasks to track your work you can easily connect every line of code with the reason it was changed. This connection makes interpreting individual files easier and reviewing changes after-the-fact possible.

Creating and Configuring Automatic Commit Messages: When using tasks to track your work meaningful commit messages will be attached to every commit that you make. When you attempt to commit a set of files Tasktop/Mylyn will automatically populate the commit dialog with tasks that were active when you changed these files.

In the above example you can see that the file AbstractTaskAssociation.java is the only file in this change set and that bug 5256 was active when it was changed. To establish a connection between this change set and your task simply do not erase the commit message. Later, when viewing the changed lines in file AbstractTaskAssociation.java it will be easy to trace back to the relevant task (discussed below).

Advanced Tip: Changing Your Commit Message

If your team decides that these commit messages are not exactly as they would like them to be they can configure the template by selecting Tasks -> Team in Window -> Preferences. They can use the following variables as well as any text to alter the commit message. You must keep the task URL in the commit message to enable easy task lookup, all other variables are optional.

Commit message variables: connector.task.prefix, repository.kind, repository.url, task.assignee, task.cc, task.description, task.id, task.key, task.keywords, task.lastmodified, task.notes, task.priority, task.product, task.reporter, task.resolution, task.status, task.summary, task.type, task.url, task.completiondate, task.creationdate, task.reminderdate

From Code to Task: Enabling the automatic commit messages allows your team to trace from any line of code back to the last task that changed that line of code. Starting from a source file, use the context menu in the editor to select Team -> Show Annotations. This will populate the gutters of the editor with a line to task mapping.

In the example above you can see that method isValidUrl was last changed to ensure that URLs did not contain spaces. To open the relevant task use the context menu in the History View (automatically opened for you) and select Open Corresponding Task.

Viewing the task has several advantages for understanding a particular line of code.

1. The description and comments of the task often have relevant information, including design decisions or problems that were encountered.
2. The task context (if available) will allow you to interpret the changes as a whole.
3. The task contains information about the people involved, including those that did not make the commit, whom you may want to discuss the code with.

Tip #3: Sharing Changes with the Team

In the open source community developers often need to submit a patch, essentially a change set, to address a particular bug. The developer in charge of that component will review the patch and either apply it or ask for improvements. The process of creating, reviewing, applying, and reapplying a patch is painless with Tasktop.
When a developer is creating a patch he (or she) usually begins with an up-to-date workspace. He then changes a few files to implement the fix. Once complete, he can use the Synchronize View to create the patch (left), which he can then attach to the bug using the Task Editor (right).

Sharing Changes with Your Team (click to enlarge)

Once the patch is attached to the bug he can revert to a clean workspace by Overriding and Updating his change set in the Synchronize View. If the patch is not approved he can, directly from the task, reapply the patch (below) and begin working on the necessary changes, again submitting an updated patch to the bug.

The developer reviewing the task also has the advantage of reviewing the changes in his workspace instead of reviewing a text file. He can apply the changes to his workspace and download the context (below) so that only the relevant files are shown in his package explorer. Reviewing changes in this way allows the developer to focus on only the changed code while reviewing, testing, and applying the patch.

Attach Your Context!

In this post I’ve shared with you the toolset that Eclipse and Mylyn/Tasktop offers for change sets. There are many opportunities to eliminate extra clicks and improve collaboration by taking advantage of this tooling. A great way to start using this tooling is to activate your Mylyn/Tasktop tasks and attach your context when submitting a patch. Attaching your context when submitting a patch makes it easier for other developers to review your patch, actually increasing its odds of being accepted.

Next time that you submit a patch… do not forget to check “Attach”!

Watch Tasktop webinars

Tweet