Tasktop

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.

We’re pleased to announce the release of a full-featured Mylyn Connector for Borland StarTeam, a robust and scalable platform for software project and source code management. This new connector is available for both Tasktop Dev (Eclipse and Visual Studio) and Tasktop Sync and is the result of a close R&D collaboration with Borland, a Micro Focus company. Today Borland is also announcing that StarTeam 12.0 will be released on December 16th 2011. This latest version of the platform includes a number of new capabilities that complement the new interoperability provided by the connector.

Connect StarTeam with Eclipse and Visual Studio Development

The StarTeam Mylyn connector provides integrated access to StarTeam artifacts
such as tasks, defects and requirements, all from the Eclipse or Visual Studio IDE. In Eclipse, Mylyn’s task focused programming productivity capabilities are fully supported, enabling developers to recover from interruptions and view only the relevant code for a task with a single click.

StarTeam tasks and task editor

Time tracking is a painful reality for many developers but with the StarTeam connector time spent on each task is automatically tracked, making it easy for developers to adjust recorded time as needed and submit it to the StarTeam server. The StarTeam task editor also displays a chart showing when and how much time was spent on the task in the recent past.

Bi-directional task to code traceability

The new connector also seamlessly extends Borland’s existing StarTeam Eclipse Client (STEC) to group file changes on a per-task basis and automate the tedious task of writing commit comments when submitting code. The automatically generated commit comments include a link to the relevant task, which establishes traceability between the code and the relevant defect or other project management task.

Eclipse Synchronize view with StarTeam code changes grouped by task

This connector can also automatically update StarTeam tasks with the reverse link back to the relevant code for full bi-directional traceability. To support teams in mixed ALM environments, this automated traceability can also be provided between StarTeam tasks and SCM artifacts in Microsoft TFS or Subversion.

Attach commit traces to the task	View traces in the task editor

Connect StarTeam to dozens of ALM systems with Tasktop Sync

The new StarTeam Connector is also available with Tasktop Sync, enabling instant bi-directional synchronization between StarTeam and dozens of third party ALM systems. One of the new features in StarTeam 12.0 is the introduction of Custom Components, which allows arbitrary artifacts to be defined and managed in StarTeam. Tasktop Sync takes advantage of this capability to synchronize arbitrary artifacts from third party systems with StarTeam. This ensures that each stakeholder has access to the data they need within their primary tool while making StarTeam a hub for comprehensive visibility and reporting across a diverse set of tools.

Through the Eclipse, Visual Studio, and Sync integration capabilities provided by this connector, organizations with new or existing StarTeam deployments can now enjoy a new dose of integration bliss.

The Borland StarTeam Connector is available now via Tasktop Dev Enterprise and Tasktop Sync.

		Read the announcement press release
		View StarTeam connector product information
		Download Tasktop Dev Enterprise with the Borland StarTeam Connector

Our aim is to transform software delivery by unifying ALM and empowering developers as the core stakeholders of application delivery. The Tasktop Sync 1.0 release provided the first ALM integration middleware for the wide range of enterprise, Agile and open source ALM tools. They key change that Tasktop Sync enabled was to connect developers with the other stakeholders in the process, such as testers and Agile project managers. By building on the Eclipse Mylyn open source frameworks and ecosystem of Mylyn connectors, we were able to focus our efforts on creating a new kind of synchronization framework capable of providing immediate updates across vendors’ and open source ALM tools. It’s this real-time aspect that created the game changer in terms of collaboration, since for the first time, developers and testers could use their tool of choice while their task updates and comments propagated instantly across organizational boundaries. Not only does this reduce tedious email inbox overload and put ALM data where it belongs, it is a critical step in addressing the ALM disconnect that for many organizations has become is the main bottleneck on large-scale software delivery.

Since the 1.0 release of Sync, we have been swamped with requests to help organizations weave together disconnected best-of-breed ALM tools. A problem we quickly discovered with deploying Sync 1.0 is that most organizations do not have their ALM architecture or data models documented, as these have been scattered across disparate tools and departments. In order to help organizations do for themselves what our professional services division provides, we have added a repository introspection tool capable of connecting to each of your ALM tools and retrieving each repository’s data model. Our goal is to make it as easy as possible to connect the ALM stack, and given the state of ALM today, that has meant creating a whole new set of ALM data model management tools in order to achieve this.

The biggest new feature of Sync 2.0 is new OSLC-based support for linking application lifecycle artifacts. This feature has been three years in the making, kicked off when we started collaborating with IBM on the OSLC-CM protocol, targeted at linking together our common representation of tasks across various ALM systems. The immediate benefit of this new linking support is for organizations with IBM CLM tools in their stack, such as Rational Team Concert (RTC) and Rational Requirements Composer (RRC). In addition to providing the full synchronization that enables collaboration, Tasktop Sync can now link and retrieve ALM data on-demand via this new OSLC-based REST layer. In the video above, you can see a demo of how we are able to leverage the CLM tools seamless embedding of OSLC data in order to provide rich linking as an alternative to full synchronization, particularly suitable to connecting Requirements Management tools to dev and QA tools.

Tasktop Sync is continuing to evolve rapidly in order to become the glue needed to modernize and connect the ALM stack. We have been working very closely with our partners, who are driving the innovation of Agile and ALM features, and ensuring that the new capabilities that they are add are seamlessly exposed in the Sync and Dev products. In order to provide the developer-centric view on our partners’ rapidly evolving ALM tools, we are also releasing a new version of Tasktop Dev, as well as a key new integration, both to be announced later this week. Stay posted for those announcements, and check out all of the new features and overview videos on the Sync 2.0 web page.

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

We had an awesome EclipseCon Europe with great talks and discussions that covered the latest developments in the Mylyn community. Fret not if you missed the conference. There will be more opportunities in November to see Mylyn in action.

I’ll be speaking at Devoxx in Antwerp, Belgium next week about connecting Agile, ALM and the IDE. The week after I’ll be heading to democamps in Germany to present the Git, Gerrit and Hudson integrations. The first demo is in Hamburg on November 23, followed by Kaiserlautern on November 24 and Kassel on November 29. Hope to see you there!

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.

When Mylyn became a top-level project, the monolithic command line driven PDE build that was understood by one committer, executable on a single machine was no longer appropriate to support the modularization needs and distributed development of the project. Since we like to play with the cool kids we jumped onto the Maven/Tycho and Git bandwagon for a ride to the land where contributions merge without conflicts and sources build themselves. We are still on the road learning something new each time we hit the occasional bump. We already found out…

• …how to convert our reasonably linear CVS history into a Git repository that does not look like a blooming tree,
• …how to setup CI builds that finish within a couple of minutes,
• …how to aggregate tests results across build jobs,
• …how to create reproducible builds with strict target defintions,
• …how to manage releases across several Git repositories,

…and much more. While the new build system is not a silver bullet that made release engineering obsolete it’s a huge improvement over the previous configuration and enabled us to take advantage of tools like FindBugs or Gerrit that we could not easily integrate before.

If you are interested in learning from our experiences take a look at the video of the EclipseCon session.

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 partners@tasktop.com. 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 partners@tasktop.com. For more see: http://tasktop.com/c2c

It’s always a good time when you meet people in person that you otherwise only interact with through the Eclipse.org Bugzilla. Recently, Matthias Sohn organized a week long hackathon at the SAP offices in Walldorf bringing together committers from EGit, Mylyn, Gerrit and the community. From Tasktop, Benjamin Muskalla and I joined the hackathon. We enjoyed lots of free SAP coffee and had a great time working with the rest of the team. We started the first day with a brainstorm session which resulted in a task board full of story cards.

My first goal was to get the Mylyn Gerrit connector working with the latest version of Gerrit. Since the early days of Mylyn we have worked bootstrapped feeling the same pains as everyone else using our tools. We know how important it is to eat our own dogfood and now that code reviews in Gerrit have (almost) become routine in our everyday workflows. Updating the tooling to work with the server used by the Mylyn project was an obvious step.

I’m happy that we made good progress during the week in Walldorf and the connector now works with Gerrit 2.2 while maintaining backwards compatibility with Gerrit 2.1.

Since the Mylyn instance is configured for OpenID authentication I also added support for that. It was an interesting exercise to extend the tasks framework to allow authentication through a browser window in a way that works across Windows, Linux and Mac.

Once the connector was working with the latest Gerrit, I took the opportunity to work with Dariusz from EGit Sychronize view fame. Dariusz knew instantly what classes to look at to enable navigating through patch sets from the Synchronize view.

The feature is still a work in progress but basic functionality is already available in the latest weekly build: The compare action in the review editor fetches the patch set and opens the corresponding changes in the Sychronize view.

Another useful enhancement to the Gerrit Connector was committed by Sascha Scholz who added a field for specifying free form queries.

We had lively discussions with Stefan Lay, Matthias Sohn, Benjamin Muskalla, Manuel Donninger and others around automating task-based branching. Not surprisingly everyone in the room had slightly different ways of working when it came to Git and there was no straight forward answer how to best automate this. I believe we settled on a nice workflow that is not intrusive:

1. On task deactivation, the checked out branches for all repositories connected to projects referenced in the task context are remembered
2. On task activation, branches that were checked out on last deactivation (if any) are automatically checked out again restoring the same workbench state

To support that Matthias committed a change in EGit that accelerates creating new branches by making the “Switch To” menu top-level in the popup menu of the Git repositories view. Additionally, Manuel proposed an enhancement to pre-populate the branch name based on the summary of the active task literally reducing the click count for creating a task branch to 4 clicks.

Based on the progress that Manuel had already made, a number of additional changes to persist branch information per task for Mylyn were proposed that are currently under review. If you have any input, please comment on bug 309578.

A number of other features that are beyond the scope of this post were being worked on throughout the week including significant performance improvements for EGit. Of course we didn’t limit our activities to coding but socialising was a big part of the hackathon.

Thanks to Matthias for organizing the meeting. Hopefully we’ll get a chance to repeat this in the future!

• Mylyn Weekly New & Noteworthy
• EGit 1.1 New & Noteworthy

Have you ever committed to the repository and got mail afterwards “Hey, this isn’t compiling!”? Likely you committed only some of the changes you made leaving out files required for a successful build. Let’s take a look at a simple example:

In this model we have a class element Some Class in my.ecore which extends AnAbstractClass in Your.ecore. In this scenario, we essentially have a dependency from My.ecore to Your.ecore. For example, renaming the class AnAbstractClass in Your.ecore also forces an update of the superclass property in My.ecore. This means we need to handle this change atomically across both files. In Eclipse, this is a called a “Logical Model”. A logical model is not necessarily related to EMF but a general concept to represent related files. While we use EMF in this example, the same applies to resources given that there is a corresponding model provider (more on that later).

In the past, using CVS or Git as your SCM of choice, committing only changes for one of these files resulted in a broken repository state. Fortunately the Eclipse Platform has had a solution build-in for exactly this problem for years. Being a platform though, Eclipse only provides the necessary hooks but not the actual implementations. While the Eclipse CVS integration already supports Logical Models, the support in EGit is currently being reviewed for inclusion in the next major release. This means, whenever you’re working with files that are part of a logical model and you’re about to operate on these files, EGit will help you to include all relevant artifacts. Let’s say are about to commit My.ecore to your repository. This will trigger EGit to reach out to the associated model providers asking the question “I want to work on file X, which files are needed to have a consistent model?”. In the case of .ecore files, the corresponding model provider is EMF Compare which answers the question and EGit shows a dialog to widen the scope of the commit operation:

This not only works when committing files to the repository but also when you replace or compare files with an older version.

The features in EGit are only one side of the equation. We also need a tool that identifies the list of resources that are related to a given set of files. In the open source Eclipse ecosystem, EMF Compare is currently the only provider that handles the notation of logical models. With the support in CVS and EGit, I hope more plugins will contribute model providers to help users keep their repositories stable.

If you’re interested what else is coming, such as semantic model merging, please come to our talk at EclipseCon Europe about Logical models. If you want to play around with the new tools, just get an EGit nightly build and use the EMF example I pushed to Github.

Looking forward to hear your usecases for logical model support!