Tasktop

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!

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

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