Archive for the ‘Mik on Eclipse’ Category

Happy Birthday Tasktop

Tuesday, January 17th, 2012

Five years ago, on Friday January 15th, I defended my PhD thesis on Focusing Knowledge Work with Task Context. The following Monday, January 17th, we incorporated Tasktop Technologies. Driven by the years of research that it took to prove that tasks are more important than files, integration is more important than features, and that focus begets flow, we embarked on a journey to bring to market a transformation in how we work and collaborate around software.

Our journey and passion have been fueled by our customers and our open source community, as to date we have not taken any external funding, and instead embarked on what’s more recently been defined as the Lean Startup approach to building a company in an Agile and customer-centric fashion. Bootstrapping, we have doubled in revenue and nearly doubled in head count each year since our inception, and now support over a thousand customers and over a million open source users. Working closely with our ISV partners, the Eclipse community and open source ALM projects, we are proud to be one of the key contributors defining the future of ALM.

In addition to the opportunity to be a part of a transformative endeavor, what’s guided our vision is a manic focus on the needs of individual software workers. Mylyn and its commercial counterpart, Tasktop Dev, materialized because the growth in complexity of software and the fragmentation of ALM tools were bringing our and our fellow developers’ productivity to a halt. Tasktop Sync was born out of the same need to give other stakeholders such as testers, project managers and business analysts, a connected and collaborative view on the software delivery process. With our focus on integration, our goal is to empower developers and other stakeholders in order to advance ALM to support the rise of the software-powered economy.

We want to take this birthday moment to thank all of the customers and partners who have made it possible for us to do what we love, which is to invent the future of ALM and to strive for our goal of doubling the productivity of software developers and managers. We hope you like the next round of innovations that we are hard at work for launching in 2012, which will be a definitive year for software, for ALM and for Tasktop Technologies.

Submission deadline for Agile ALM Connect at EclipseCon 2012

Tuesday, November 15th, 2011

This Friday is the submission deadline for the Agile ALM Connect sub-conference of EclipseCon. This new conference fills a gap that many of us have noticed in the conversation around Agile, ALM and developers. The “developers” part of the equation is often either missing or an afterthought. Even though developers were the root cause of the Agile movement, the discourse around Agile tends to focus on project management related methodologies. Application Lifecycle Management (ALM), perhaps by virtue of the word management being part of its acronym, has a legacy of neglecting the core need to make developers empowered and productive. While end-to-end approaches like the Rational Unified Process (RUP) had end-to-end traceability, they treated developers as an implementation detail, and as a result, have been relegated to history books. In this new age of ALM, we need to make sure that we do not make the same mistakes again. The Agile ALM Connect conference is the place to have the conversations needed to bring together the latest developments in open source, Agile, large-scale ALM, and to get developers back to the center of the discussion.

Ten years ago, I got involved with Eclipse as one of the first non-IBM committers, which has given me perspective on the way Eclipse first disrupted and then evolved along with the application development landscape. By way of efforts like EGit, Hudson/Jenkins, Tycho, and the umbrella of Mylyn projects, Eclipse has since become the leading driver of innovation in moving the developer to the center of the ALM picture. Other IDEs and development platforms are now starting to emulate the dev-centric ALM transformation that Eclipse started five years ago. From this transformation, a new set of open source frameworks were created and now broadly adopted. As a result, the ALM projects on Eclipse have come to lead the connection between the developer and the Agile plan, deployment destination, operations team, requirements, and quality management.

At the Agile ALM Connect conference we will be charting the course for the role of the developer in ALM, while connecting the organization to the new breed of open source, Agile and devops technologies. Unlike conferences focused on methodologies, we are interested in the full spectrum of approaches, ranging from tools and automation to people and practices. If you have ideas to share on how the landscape of Agile, ALM, and application development should evolve over the next decade, consider joining the conversation.

For submissions and information see the Agile ALM Connect Conference homepage

Code2Cloud moves one step closer to open source

Wednesday, October 26th, 2011

A year ago at SpringOne 2010, Spring founder Rod Johnson announced a new technology called “Code2Cloud” during his opening keynote (skip to minute 56). Since that announcement, development of Code2Cloud has continued at a rapid pace, with a growing community of private beta users. The ideas and technology behind Code2Cloud have become an underpinning of how we see the convergence of ALM and cloud and a key building block of our vision for a more integrated and developer-centric ALM stack, outlined at a high-level in the following talk.

Many of you have been asking when Code2Cloud (or as some knew it, Cloud Foundry Code) is going to be made publicly available. Today we are announcing a key milestone on this longer-than-expected journey. Tasktop has now been tasked by VMware to bring Code2Cloud to the open source community. Tasktop’s services division has been the delivery partner for the project and Tasktop will continue to maintain and evolve Code2Cloud for the early adopters of the closed beta. Although we haven’t yet determined the specifics of how, when, and where Code2Cloud will be made available in open source, or for that matter the name of the project when it is open sourced, we are committed to making the project available in Q1 of 2012. Code2Cloud will be available via a community and commercial-friendly open source license (either Eclipse Public License v1.0 or Apache License v2.0).

We are announcing this change in the project structure because as with Eclipse Mylyn, we see a successful Code2Cloud as being built on an open and inviting charter for both individual and commercial contributors wanting to leverage the Code2Cloud frameworks and tools. We will work with our existing partners and community over the coming month to define a structure and charter for the project. We encourage any interested parties to contact us at We believe there are tremendous opportunities for ALM vendors to participate in and leverage Code2Cloud as an on-ramp to their initiatives and to get a step ahead in the move of the deployment destination to the cloud.

Over the past year, Code2Cloud has grown to become a developer-centric integration platform architected to connect developers to PaaS deployment destinations by way of the ALM stack. It supports CloudFoundry and builds on existing tools such as Hudson/Jenkins, Git and GitHub. It also provides a Bugzilla-compatible but cloud-centric issue tracker intended to connect the running application, CI and SCM tools to the developer’s desktop, and unifies services such as authentication via OAuth. A key opportunity that we see now is in making Code2Cloud even more agnostic of the ALM stack and in delivering its integration and Cloud deployment support to the wide variety of open source and commercial ALM tools available today.

If you have ideas or questions on bringing Code2Cloud to open source please post here. If you want to get involved in discussing the structure of the open source project please email For more see:

Tasktop Dev 2.1 released

Tuesday, August 9th, 2011

Hot on the heels of the Tasktop Sync 1.0 release, we are pleased to announce the availability of Tasktop Dev 2.1. As an indication of our focus on the Agile and ALM needs of the developer, the product line previously known as Tasktop is now called Tasktop Dev. This release builds on the Eclipse Indigo release of Mylyn 3.6, includes the latest connectors, productivity features and new Agile planning support, and is a significant step forward in terms of connecting developers to both the Agile and the traditional planning process, while ensuring that we get to use the best-of-breed ALM and open source technologies that make us productive.

James Governor (RedMonk founder and Principal Analyst) and I discussed the release and walked through some of the key features:

Here are a few highlights from the Tasktop 2.1 New & Noteworthy:

HP ALM & Quality Center 11 on Mac, Linux and 64-bit Windows
HP ALM Requirements, Defects and Tests can now be retrieved on Mac, Linux and 64-bit Windows machines using the REST connection provided by ALM 11 instead of the native connection. This feature is only supported when connecting to ALM 11 Patch 2 or higher.

HP ALM & Quality Center Tests
You can now bring HP ALM Tests into your Task List along side your HP ALM Defects and Requirements.

Tasktop for VS: Ability to View Task Associations
The Visual Studio task editor now displays task associations, making it easy to see the parent and child relationships and external dependencies inside Visual Studio. Double-clicking an associated task opens it in the task editor, allowing you to quickly access its content.

Planner Story Board and Kanban
The planning tools now support Kanban for compatible ALM tools, and includes a story board and WIP limits. The release planner now supports grouping stories and tasks by activity or assignee, allowing you to organize your planning around these high level concepts.

Focus plan on My Tasks
The task board and story board now include a “Focus on My Tasks” button which shows you only the tasks or stories that are assigned to you.

Download the free trial

Announcing Tasktop Sync 1.0

Monday, August 8th, 2011

In our mission to improve the productivity of software development, our focus to date has been the developer. With Mylyn for the masses and Tasktop for the Enterprise, we have provided developers the tools that they need to focus on coding amidst constant interruptions and organizational shifts between disparate application lifecycle management (ALM) tools and ever-evolving flavors of Agile. Mylyn and Tasktop provide developers a single pane of glass through which to view all parts of the application lifecycle relevant to their work. But other key stakeholders, who do not live in the IDE, are missing this visibility. Over the course of the past decade, as the heterogeneity of ALM has increased the vantage of these stakeholders decreased. Today we are announcing a new product that will bring all members of the development process into the modern software delivery loop.

Tasktop Sync moves our existing Task Federation(tm) technology from a developer’s desktop client to the server. Developers’ need for Task Federation arose from the fact that in larger organizations, development tasks span multiple systems, from requirements definitions to defects, from issues to change sets and from tests to builds. But tasks not only span systems, they also span stakeholders. If a tester needs to email a developer to get clarification on a fix, or to email a business analyst for details on a requirement related to testing, the ALM stack is broken. With application complexity continually rising, it is no longer feasible to effectively collaborate and report over disconnected chains of email. Just as Tasktop, Mylyn and the task-focused interface have been instrumental at starting to bring about the end of email between developers, today we are embarking on connecting the other members of the software lifecycle. The difference is that unlike developers, most other stakeholders do not live in an IDE-type rich client capable of bringing the many disparate forms of software project information together. Their window on the software delivery process is the web browser. To support them, we needed to integrate directly with the data models of the tools that they use.

Tasktop Sync is the first real-time synchronizer for ALM. While synchronization is largely solved for email and contacts, with protocols and synchronizers working seamlessly across Microsoft Exchange, IMAP, Google Apps and iOS, the lack of a scalable and generic solution has been an endemic problem in large-scale ALM. With Tasktop Sync, the ALM architect simply sets up a mapping between the various ALM systems of record for requirements, Agile, development and testing. For example, the mapping may specify that defects should be one-to-one mapped between the Agile tracker and the defect tracker. Once Tasktop sync has built up its cache, every change in the test system is propagated instantly to the agile tool, and back again, ensuring that all stakeholders can work in their system of choice. We have built on the Mylyn frameworks, Tasktop Certified ecosystem of connectors, and our deep partnerships with the leading Agile and ALM vendors to create this entirely new level of ALM interoperability.

If you are involved in an Agile rollout or ALM modernization effort that is struggling with disconnected tools and increasing presence of open source in the stack, Tasktop Sync will provide you with the integration that you need for all stakeholders to collaborate with context in their tool of choice.

Learn more, view data sheet, get Sync

Eclipse Mylyn 3.6 lights up Indigo, puts an end to faceless builds

Thursday, June 23rd, 2011

Yesterday’s Eclipse Indigo release delivered a year’s worth of improvements on what has become the de facto IDE platform for Java and beyond. The Java package has seen major additions, including the WindowBuilder tool that originated from Instantiations and the m2e plug-in that eases Maven-based builds. EGit 1.0 is an essential tool for the growing number of Eclipse developers using Git, and in addition the top-level project included new tooling for Hudson/Jenkins as well as early access support for Gerrit.

The Mylyn features in Indigo further entrench Eclipse as the leading IDE in terms of the application lifecycle management (ALM) tools needed for developers to collaborate around code. Most developers spend the majority of our time on application maintenance activities rather than the creation of new features, making the new traceability aspects of Mylyn and Mylyn-based tools increasingly important to large-scale application development. Out of the box you now get ALM support for the leading open source tools including Bugzilla, Trac, CVS, Git and Hudson. The rich ecosystem of both open source and commercial integrations available means that you can plug Eclipse into your own ALM stack and get the benefits of tasks-focused productivity and automated traceability across the vast majority of the leading task, issue, source and review management tools as visible below.

Other notable features in Mylyn 3.6 include automatic population of contexts on activation for tasks that contain stack traces, making it very simple to navigate to relevant sources when starting on a new task.

To emphasize the social nature of task-focused collaboration, the task editor now displays images for the assignee of a task. Thanks to the traceability that we provide between Hudson builds, tasks and code changes, putting these features together means that you now get to the faces associated with builds. Perhaps for the next release we should streamline things even further and use mapping to inline all the contributors’ Gravatar images in the build editor itself, to help give credit where it is due.

What’s key is the way that these features work together to make the Eclipse IDE be the collaborative console for the developer. The video below, recorded at the JAX conference in May, has Tasktop’s Steffen Pingel and Benjamin Muskalla illustrate the sort of open source ALM workflow automation that can be created using the new connectors and APIs and tools shipping with Mylyn 3.6. We hope that both this release and our ongoing efforts will continue to make your workday easier and more productive.

See the Mylyn 3.6 New & Noteworthy for more from the Mylyn 3.5 and Mylyn 3.6 releases included in Indigo.

Proposal to move Hudson to Eclipse

Wednesday, May 4th, 2011

Some of the most successful open source projects have histories that transcend organizational boundaries. My first experience with this was AspectJ, which we launched as an independent open source portal out of Xerox PARC in 2000. In 2003 our DARPA funding dried up, but the user community was still growing. We moved the project to Eclipse, the leadership moved from PARC to IBM, then to SpringSource. Not one of the original committers remains. But Eclipse has allowed the project to thrive throughout these waves of change in commercial interests, community leadership and intellectual property (IP) ownership.

Today Oracle proposed to move Hudson to Eclipse. As a board member and long-time committer, I have an inherent bias towards Eclipse being a great place to grow frameworks and tools. But I also believe Eclipse’s track record is a strong indication of the foundation’s effectiveness at combining the interests of multiple vendors and community of plug-in builders and contributors, to the net benefit of all involved.

Oracle owns the Hudson IP which they acquired via Sun’s initial investment in the project. IP ownership is a key factor that drives companies to innovate, in open or source and otherwise. Open source projects additionally need governance that combines the interests of vendors and of the community. In moving the IP and governance of Hudson to Eclipse, Oracle has done the right thing for the long term success of this very popular Continuous Integration (CI) tool.

Jenkins exercised the very important open source community right to fork, but in the process split the community. I in no way want to diminish what Kohsuke Kawaguchi created, and I have a deep and personal appreciation for the labour of love that open source projects like this require. But FUD ensued around the state of CI, and today’s announcement of moving the project to a neutral body marks major progress.

Consider the alternatives. As we learned with the rapid exodus off CruiseControl to Hudson, CI tools are a well understood space and easy enough to migrate between. If the differences between Hudson and Jenkins had grown sufficiently large and there was overall confusion and friction among the developer and corporate communities, this would have increased the demand for a new CI solution.

At Tasktop we follow the Application Lifecycle Management (ALM) stack needs of our customers, integrating open source, legacy and enterprise ALM tools rather than pushing a single stack. Since the announcement of the fork, we have been witnessing our customers’ frustration from the lack of a clear path forward from the current fragmentation and from the fear of downstream incompatibilities, or of betting on the wrong horse. While we are happy seeing a heterogeneous and best-of-breed ALM ecosystem thrive, we are less happy about all of the duplicated effort this would involve, especially since there is so much work left to do on REST APIs of Hudson and its plug-ins, as well as in providing the IDE integration and ALM traceability needed to make Hudson a key component in modern ALM stacks. It would be counter-productive to split efforts in evolving the CI interoperability layer that we have been creating in Mylyn, which enables both IDE integration and traceability across builds, source code and tasks. Eclipse is a tried-and-true place to evolve this level of tool support around ALM tools such as Hudson, and we are looking forward to collaborating around the convergent evolution of Mylyn, Hudson and Git/EGit and other key ALM technologies.

While there may be many questions about this move, the proposal phase of the Eclipse Development Process makes the path forward clear. The next stage is soliciting input from the community-at-large. As I see Eclipse as a great home for this technology, I have agreed to mentor the project and look forward to the community discussions around this proposal and the increasingly central role of continuous integration in the ALM stack.

Prediction #1: Task-focused collaboration transforms knowledge work, starting with developers

Thursday, April 28th, 2011

With this final and belated prediction in the series, I have taken the liberty of looking beyond 2011 speculating on the coming decade. I’ll start with a trip down memory lane in order describe how we got into this mess of information overload and what we can do about it.

It all goes back to files. The concept of a file is one of the simplest and most widely used abstractions in user interface design. Files are how we share documents, source code, and online content. Part of the success of UNIX and C that started in 1969, and lives on today in Linux, came from the elegance that files provided to the programming model. Those of us who started our careers programming C may still be amazed at seeing UNIX-style file paths now engrained in pop culture in the form of URLs. In addition to being a useful construct for programmers and operating systems, the notion of files became the primary way to organize information in the IDE, on the desktop, and on the web.

The problem with files is that we have way too many of them. In 1981, the graphical user interface was created at Xerox PARC in order to help us manage large volumes of files more easily than we could on in the filing cabinet or command-line interface. That same desktop metaphor was imitated first by the Mac, then by Windows. With a few decades of Moore’s law driving graphics performance improvements the windowed desktop has become a lot prettier. But the window-based desktops have experienced only incremental improvements, and the amount of information that we now need to process has exploded. The document hierarchies that we access daily have grown to tens of thousands of files. For developers, tens of thousands of files turned into hundreds of thousands. Yet the file and folder metaphor for browsing them remained the same. We were spending more time hunting for and clicking for information than creating it. The desktop metaphor collapsed under the weight of all of those files.

In late 1990s search-based navigation started getting embedded into both our desktop and online information retrieval experience. We were no longer bound to constant browsing for files through deep hierarchies or Yahoo-style categorizations of tagged content. Computers, network infrastructure, indexing and ranking technologies had become fast enough to place at our fingertips the thousands of files on our desktop, millions of classes accessible in our IDEs, and billions of pages on the Internet. When you consider the sheer speed of access that we have via Google’s Instant Search or Eclipse’s Open Type, this is nothing short of remarkable. But then we started seeing a familiar pattern emerging again: we were spending more time searching for information than we were spending on the collaborative and creative endeavours that are productive and rewarding. The repeated, wasteful clicking and keystrokes used to constantly browse and re-browse through information had now turned into repeated, wasteful finding and re-finding for the same information. We increased the volume of information that we could work with effectively by an order of magnitude or two, but the level of information relevant to our day-to-day work grew at an even higher rate.

The information overload problem that we are facing goes back to this notion of files that we have been relying on so heavily. Files encapsulate content. We tag them, bookmark them, index them and search them. Some of us are filers and obsess with having our content neatly organized and desktops de-cluttered. Most of us are pilers, with our computers’ desktops as cluttered as our physical ones. Either way, we are all playing a losing battle. The fundamental problem is that no matter how we organize and structure our documents and source code, our daily tasks crosscut that structure. We need a new approach to managing knowledge work in order to survive the ongoing deluge of information and increased demands for collaboration. The graphical user interface and search-based navigation will continue to be a key part of user interface design, but improvements on that front will only provide diminishing returns.

Tasktop task structure

The primary unit of knowledge work is the task. Tasks have a structure that is defined by the process that we use in our knowledge production activities. For software, this could be an Agile process, with tasks being recorded in a project tracking tool and taking the form of user stories and defects. For the sales part of the organization, tasks are captured as opportunities in Salesforce. The game changer created by the task-focused interface [] is to leverage these entrenched tracking tools to make tasks the primary anchor for the conversation and context around knowledge work. This concept means that the primary way that we access the information in the IDE and desktop user interface becomes the task, not the file. All conversation is available through a single point of access, no matter how many different repositories, email, or social communication channels it appears on. Even more importantly, all knowledge accessed and created as part of the task is tracked automatically, meaning that we offload our brains and let the computer do the work of ranking the information that’s relevant to what we are doing. Multi-tasking becomes a one-click operation, meaning that we don’t have to pay the price of context switching in the presence of constant interruptions. The near-term benefits of this approach are the reduction of information overload and multitasking overhead. The long-term benefits are a new level of knowledge capture and sharing that will eventually transform the productivity of the knowledge worker by an order of magnitude.

In 2011, tasks will be well on their way to becoming an entrenched unit of abstraction in the software development of leading IT-centric organizations. Every change made to a system will be automatically linked back to the task that it originated from as task activation becomes an integral part of developer workflow. This task-level traceability will be connected to continuous integration systems, which will position tasks as the primary unit of production in the continuous integration loop. This will dramatically improve development transparency across heterogenous ALM stacks, and plug Agile project tracking into the development loop, while empowering developers with the tools that they need to manage changes in very complex systems.

In 2012, this automatic capture of context will be leveraged by other stakeholders in the software delivery loop, including support staff, DevOps and QA. Stakeholder-specific context tracking will tie together the activities of developers, operations and quality assurance engineers; this will help to unify all of the participants in the deployment, diagnosis, and development of an application. Materializing a release-specific workspace to investigate a defect in a deployed application, along with all of the context from the application operators and help desk staff, will become as easy as clicking the “activate” button on a task.

2013 will bring tasks-focused collaboration higher up the management stack. Requirements tracking, project, and portfolio management tools will become directly linked to development activities happening at the production level. The production level of software development activity will finally have a high-fidelity link to the planning level, allowing for a new level of predictability and productivity in the software lifecycle. In their support of this movement, ALM tools will learn to speak the language of development tasks and then get out of the developer’s way.

What follows in 2014 is an infection to other parts of the enterprise. With project and portfolio management activities planned via tasks, email will finally start being displaced by task-focused collaboration as the mechanism for tracking work. One-click multitaskingâ„¢, task-focused collaboration and automatic knowledge capture will start to be tailored to the other departments in the organization.

In 2015, the single integrated Task List and task-focused interface will layer so seamlessly over desktop and mobile operating systems that consumers will start seeing the same level of productivity and collaboration benefits. By 2020, it will be effortless to assign your grandmother a task to bake you cookies, no matter where she is located, and have the recipe automatically captured as part of the context in order to later delegate the same task to your robot assistant before flying to work in your car.

As William Gibson stated, “the future is already here – it’s just not very evenly distributed”. In writing this blog series, every bit of content that I produced and accessed has been automatically captured as part of my task context, and each of the many revisions and bits of feedback were tracked on the task. When I re-activated this task after a series of interruptions, my desktop-based Word and web-based WordPress editors were instantly restored. In the same way, every change that any committer has made in the Eclipse Mylyn codebase is automatically linked to the Bugzilla bug describing the social conversation around the change, then linked to the corresponding build and release. Tasks and contexts externalize our memory and make it much easier for both our forgetful selves and for newcomers to help us evolve our software.

To my surprise and concern, Tasktop is telling me that I have spent over 88 hours researching, collaborating on, and writing this prediction series on Agile, ALM and developer tools. All of this information was automatically captured and will be accessible to me in 2015 when I attempt to explain away any inaccuracies in my predictions.

“The best way to predict the future is to invent it” said Alan Kay at Xerox PARC in 1971, inspiring Smalltalk and paving the road for the graphical user interface. Our vision at Tasktop, as embodied in the “less is more” logo , is to transform knowledge work around the focus and flow required to get creative work done in the presence of ever-growing volumes of infromation. As with other innovations, like the file hierarchy and desktop metaphor, this move to task-focused collaboration will originate from developers and move upwards and outwards in the organization. We look forward to working with you in making this vision a reality, starting with the transformation of the Agile ALM stack and developer tools. <=>

Interview on ALM getting a bad name, how Agile and open source are changing that

Friday, April 1st, 2011

Here is a short interview from The Server Side conference, with Jan Stafford of Software Quality Insights, on how ALM got a bad name from heavyweight methodologies like RUP, and why the move to Agile, open source and developer-centric tools is changing that. Yes, I am in fact holding an invisible crystal ball, which is the very same ball that I’ve been using for my Agile/ALM/dev predictions series. It has been malfunctioning for the past couple of weeks, but has started working again, so stay posted for prediction #1.

Tasktop 2.0 released with Eclipse Mylyn 3.5, brings sanity to your heterogeneous ALM stack

Tuesday, March 22nd, 2011

If you are involved in large-scale software development, you may be alarmed to hear leading analysts discussing the growing number of Agile rollouts that are failing. Several factors are contributing to this. Legacy and in-house ALM tools have proven to be sticky and hard to migrate from. Their content, customizations and workflows encapsulate product history. Agile tools have moved in, but have not been adequately connected to developer workflow or to enterprise ALM tools and processes. Lightweight open source ALM tools are becoming favoured by developers and being adopted in a bottom-up fashion, but these are disconnected from both enterprise and Agile ALM tools. The resulting difficulty of modernizing and integrating the increasingly heterogeneous ALM stack is a key cause of the failing Agile deployments and ALM stack modernization efforts.

For the past three years, the Tasktop 1.x train for releases was focused on providing developers with the integrations that they need to work with Agile and ALM tools within their home environment, the IDE. Our goal is to bring the productivity benefits of the task-focused collaboration paradigm to as many developers as possible. On the Mylyn side, this has meant collaborating with Agile and ALM vendors and contributors in order to grow the frameworks that have become the most widely extended APIs for ALM integration. With last year’s restructuring of Mylyn to become a top level Eclipse project, these frameworks grew to encompass SCM tools, Build and Continuous Integration tools and code reviews. The Tasktop 2.0 release extends this ecosystem with new Mylyn connectors and new features that support the range of our integrations, including Task Federationâ„¢ and cross-repository Agile planning.

New Mylyn Connectors

For the 1.x release, our obsession with improving the developer’s workday meant providing integration with the huge breadth of ALM tools in use today. This meant getting involved with each of the corresponding open source projects and partnering with the best-of-breed Agile and enterprise ALM vendors in order to enhance their web service APIs and establish the long-term support needed for this level of interoperability. The figure below highlights the new integrations made available as part of Tasktop 2.0 in green, with the most notable being:

  greenbullet_icon HP Agile Accelerator (Tasktop Enterprise): This builds on our existing support for HP Quality Center and ALM in order to provide both the task management and IDE-based Agile planning facilities. Learn more.
  greenbullet_icon Accept360 (Tasktop Enterprise): Brings requirements and other product management artifacts to the developer’s desktop in order to better connect development to planning activities. Learn more.
  greenbullet_icon SmartBear CodeCollaborator (Tasktop Enterprise): This is the first full-featured Mylyn connector for a code review tool, SmartBear’s popular CodeCollaborator. Learn more.
  greenbullet_icon Polarion ALM (Tasktop Pro): Polarion is the vendor behind the Eclipse Subversive SVN client project and we now have full support for the Track & Wiki and ALM solutions. Learn more.
  greenbullet_icon Hudson/Jenkins (Eclipse Mylyn): For the Mylyn 3.5 release we created a Hudson integration that layers on top of Mylyn’s new Builds framework. On top of this Tasktop provides traceability with tasks that exist in ALM tools such as HP Quality Center. Learn more.

Tasktop for Visual Studio

Many of our customers have been asking for support for their teams and colleagues who are based in Visual Studio. Organizations are building both Java and .NET based applications that need common lifecycle management tools. The Tasktop 2.0 release includes the GA of Tasktop for Visual Studio, which brings the ecosystem of our task connectors into the Visual Studio IDE. Whereas previously only basic integration existed for task management within Visual Studio beyond Microsoft’s TFS product, you now get Mylyn’s functionality including instant opening of tasks, offline access, the Task List and a full-featured and WPF-based task editor.

  greenbullet_icon Supported Connectors (Tasktop Certified): Accept360, Atlassian JIRA, CollabNet TeamForge & ScrumWorks, Edgewall Trac, Google Gmail, HP Quality Center & ALM, IBM Rational ClearQuest, Microsoft Outlook, Microsoft TFS, Mozilla Bugzilla, ThoughtWorks Mingle, Polarion ALM, VersionOne. Adding support for the remaining Tasktop Certified connectors is underway.

Learn more about Tasktop for Visual Studio.

Task Federation, for Developers

The big news in Tasktop 2.0 is not the new connectors, but what we have created on top of this ecosystem in order to solve the problem of ALM stack heterogeneity. Tasktop 2.0 includes a Task Federation framework that provides a layer of insulation between the various stakeholders in the software lifecycle and the implementation details of the organization’s ALM stack. Task Federation manifests differently for each set of stakeholders.

Developers are often stuck working with multiple ALM tools. You may be working on two different projects, each of which has a different ALM tool. Or you may be adopting Agile, but still needing to use the company standard defect tracker. Those of us depending on open source frameworks and SDKs will have dependencies between our internal task and those managed in an external repository such as or Apache. Tasktop 2.0 provides full support for linking dependencies between the various task repositories that define your software’s evolution, and new features such as cross-repository Agile planning and task synchronization build on this support.

Task Federation, for Agile Planning

The biggest single new feature in Tasktop 2.0 is the release of the Agile Planner that we launched as beta at the Agile 2010 conference. Just as we do not replace your existing ALM servers, we are not replacing your existing Agile planning tool. Instead, we augment it with our unique interoperability features. The Tasktop Planner provides:

  greenbullet_icon Task Federation: The most important feature of the planner is its ability to show plans that span repositories. Planning your user stories in an Agile tool but using HP Quality Center for defects or an open source issue tracker is no longer a problem. Depending on another team or an open source project? These dependencies now show right in your release plans since Tasktop can display and reconcile state across repositories. All of the cross-repository state is stored in your existing ALM tools as hyperlinks and metadata.
  greenbullet_icon IDE Integration: This is the first full-featured cross-repository Agile Planning tool within the IDE. You get a fully native and offline-capable Scrum style task board and a release planner. Relevant content from your web-based planning tool, such as burn down charts, is available when connected via our embedding of web UI gadgets. For product owners and project leads, the planner is also available in the Tasktop desktop edition.
  greenbullet_icon Developer Focus: Whereas most tools focus on project-level views, the Tasktop Planner supports developer centric workflows such as highlighting everything assigned to you for the current Sprint or populating your Task List with user stories assigned to you for an iteration. Everything you need for your daily Scrum or release planning is always at your fingertips.
  greenbullet_icon Automatic Time Tracking: The Tasktop Planner uses time values from Tasktop’s automatic time tracking facility to make Agile estimation dramatically more realistic
  greenbullet_icon Supported Tools: Agile plans can be displayed from HP’s Agile Accelerator and Rally. More tools will be supported in subsequent releases. All Tasktop Certified connectors are supported as targets for cross-repository plans.

Task Federation, for the ALM Tools Manager

In addition to providing developers and plan stakeholders with a unified view of the various tools and servers that define their planning activities, Task Federation can also be deployed to further unify an ALM stack. Say that you are deploying IBM Rational Team Concert (RTC) for Agile planning, but have realized that HP Quality Center (QC) is completely entrenched in your defect and quality management process. You can deploy a Task Federation setup that bi-directionally synchronizes all the key tasks and fields between RTC and QC so that RTC has the state needed for planning, while QC happily remains your system of record for quality management. Since each Tasktop client includes the full federation functionality and uses Mylyn’s hardened bi-directional task synchronization and conflict resolution interface, it is possible to deploy this solution in a scalable and secure fashion without requiring any new servers.

Learn more about Task Federation

Task-Focused Continuous Integration

As always, our commercial efforts in Tasktop have been driving framework and open source tool improvements in Eclipse Mylyn. The most notable of these is the new Hudson tooling, which also supports Jenkins. You can now work with Hudson day-to-day entirely from within the Eclipse IDE, monitor and run builds, and inspect results. Accessing build information is instant and available offline. One of the most useful automation features is the ability to run tests that failed on the server within your workspace, with just one click. But the most profound feature here is the first phase of our new support for ALM traceability. If your developers are using Tasktop, thanks to the magic of task activation and automatic change set tracking, you now have perfect traceability between your Hudson builds and the tasks that changed for a given build, providing an unprecedented level of traceability between your tasks, source and builds.

Learn more about Mylyn 3.5


With this release of Tasktop 2.0, we are taking a big step forward in bringing a new level of interoperability and sanity to your Agile deployment and ALM stack, helping developers focus on coding while giving teams a much more complete and real-time view of plans and progress.

  greenbullet_icon Read the Tasktop 2.0 New & Noteworthy
  greenbullet_icon Sign up for my webinar on Tasktop 2.0