Catapult Public Relations

TASKTOP EXPERTS TO PRESENT MULTIPLE CONFERENCE SESSIONS AT ECLIPSECON EUROPE 2011

Mon, 31 Oct 2011 17:58:33 +0000

Tasktop continues to support the Eclipse community through thought leadership and sharing of best practices

WHO: Steffen Pingel â�� Senior Software Engineer, Tasktop Technologies

Benjamin Muskalla â�� Software Engineer, Tasktop Technologies

(www.tasktop.com)

Tasktop Technologies is the company behind the Eclipse Mylyn ALM integration framework and innovative task-focused interface. It provides desktop and enterprise-grade solutions that improve productivity, collaboration and Agile ALM success. Muskalla and Pingel will present the following sessions at EclipseCon Europe 2011.

WHAT: Experiences from Migrating Mylyn to Git and Tycho

November 2, 16:30 - 17:00

Steffen Pingel

Benjamin Muskalla

Until the recent restructuring of Mylyn, numerous committers and contributors have evolved its source code for more than six years in a single CVS module relying on a monolithic command-line driven PDE build, understood by one committer, executable on a single machine. Step-by-step the project was modularized, the build was migrated to Tycho and sources were moved into Git. Hudson jobs now execute on each commit and reproducible releases can be triggered by anyone. This talk highlights decisions taken and discusses lessons learned. Attendees will get an overview of Mylyn's build system, with a focus on knowledge that attendees can apply to their own project.

What the heck are logical models?

Benjamin Muskalla

November 3, 16:00 - 16:30

Did you ever break the code or your models in your SCM? Giving the complexity of today's software systems, physical files are not the only asset in your version control system. During this session Muskalla will give an overview of how Logical Models can better manage the complexity of their systems and how plugin developers can leverage the functionality the Platform provides.

Pimp your Productivity with Git, Gerrit, Hudson and Mylyn

November 4, 10:30 - 11:30

Steffen Pingel

Benjamin Muskalla

The Git distributed versioning system is being increasingly adopted by the developer community. Using Git for version control makes Gerrit the natural choice for code reviews. Besides source code, requirements and build artifacts play an important role in the development cycles that are now often managed in Hudson and Bugzilla. This session will demonstrate how the tools available within the Mylyn project work together to seamlessly integrate development artifacts in Eclipse, while providing traceability all the way from requirement to the final merge into the production branch.

Task-focused modeling with Mylyn, EMF and Papyrus

November 4, 13:30 - 14:00

Benjamin Muskalla

To bring the productivity benefits of the task-focused interface to engineers using Eclipse-based modeling technologies, Mylyn created a â��Context Bridgeâ�� for EMF-based models and diagram editors. The result is a focused mode for diagrams that shows only the elements related to the task-at-hand. This session showcases the use of the task-focused interface within the Ecore Tools and the Papyrus UML Editor. In addition, it outlines the aspects of bringing the task-focused interface to model and diagram editors, and provides a quick overview of how to enable these for each diagram type.

WHERE: EclipseCon Europe 2011, Nov 2-4, Ludwigsburg, Germany

(http://eclipsecon.org/)

INFO: For more information or to arrange an interview with Steffen Pingel or Benjamin Muskalla, please contact Christie Denniston at +1 303-581-7760 or by email at (cdenniston@catapultpr-ir.com).

Tasktop’s Task Federation Achieves ‘Ready for IBM Rational Software’ Validation

Mon, 06 Jun 2011 19:14:00 +0000

Tasktop Enterprise builds on OSLC services to bring ALM interoperability between RTC and other ALM tools

VANCOUVER, BC, AND ORLANDO, FL (Booth # 408) June 6, 2011 - Tasktop Technologies (www.tasktop.com), creators of the Eclipse Mylyn open source tools and a leader in Agile ALM interoperability and developer productivity, today announced that its Task Federation^TM offering, which synchronizes ALM artifacts, such as defects and tasks, between various issue tracking systems, has successfully completed "Ready for IBM Rational Software" technical validation for interoperability between Rational Team Concert (RTC) and HP Quality Center.

"Tasktop's Task Federation is a catalyst for organizations deploying heterogeneous and best-of-breed ALM environments" said Mik Kersten, CEO of Tasktop and creator of the open source Eclipse Mylyn project. "Unlike other synchronization solutions, Tasktop's Task Federation can be deployed as either a server-based or desktop client-based application and supports fine-grained access control, and user-based conflict resolution. Tasktop provides interoperability with more than 60 ALM tools and solutions including in-house systems."

The Tasktop Enterprise RTC Mylyn Connector, which is also Ready for IBM Rational Software validated, enables Mylyn's task-focused interface technology within Rational Team Concert to improve developer productivity by displaying only the source code that is relevant for each work item. When used with RTC and another ALM solution via Task Federation, it enables end-users to seamlessly interact with either system and generate reports based on information from both solutions. It also can be deployed in a scalable and secure fashion without requiring any new servers, while maintaining all levels of traceability, security and audit capabilities.

"The full fidelity bi-directional synchronization provided by Tasktop's Task Federation is a key enabler for organizations deploying RTC tools to heterogeneous and best-of-breed ALM environments," said Kersten. "Tasktop has become a leading supplier of cross-vendor and cross open source project ALM interoperability and developer productivity solutions, and has collaborated with IBM on the Open Services for Lifecycle Collaboration (OSLC) specification in order to bring about improved levels of interoperability for ALM tools."

"Tasktop's productivity-oriented offerings, when integrated with Rational solutions, collectively work to streamline the entire ALM process for customers," Michael Loria, vice president, IBM Rational Business Development. "We work to continually bring innovation and value to the Rational development community through deeper and robust levels of integration."

Tasktop created its task management tools to help developers be more productive by making it effortless for them to organize their work around tasks. Serving as an ALM integration and automation suite, Tasktop Enterprise has become a key tool for integrating disparate development tools and platforms that are the reality for today's enterprise software development organizations. By providing traceability and knowledge sharing between tools and platforms that are often provided by separate companies, Tasktop helps reduce the complexity and challenges of successfully scaling Agile programs beyond small teams.

In addition to its existing RTC, ClearQuest and ClearCase integrations, Tasktop also announced the availability of its Mylyn integration solutions for the Rational Synergy and Change ALM tools; Ready for IBM Rational validation for these solutions is in progress.

Tasktop will demonstrate its latest integrations in the Jazz Interoperability Center at the upcoming Innovate 2011 conference in Orlando, June 5-9 Booth #408 (http://www-01.ibm.com/software/rational/innovate/). In addition, Kersten will be delivering a talk, titled "IBM Rational Team Concert Support for Application Lifecycle Management Environments with Eclipse Mylyn and Open Services for Lifecycle Collaboration," at the event. To see Tasktop Enterprise firsthand, please visit the Jazz Interoperability Center or the Tasktop booth at Innovate 2011.

About Tasktop Technologies

Tasktop Technologies created the Eclipse Mylyn ALM integration and automation framework and its revolutionary task-focused interface technology. The task-focused interface is proven to make developers more productive by showing only the relevant information for each task, dramatically reducing search time and facilitating multitasking. Tasktop Enterprise is the company's commercial product based on Mylyn, with task-focused support for web browsing, time tracking, documents, email, calendars and commercial ALM integrations. Tasktop also provides consulting, connector development services and training to the growing number of companies adopting the task-focused paradigm and tools. For more information, please visit (www.tasktop.com).

# # #

Media Contact:

Christie Denniston

Catapult PR-IR (Tasktop)

303-581-7760

cdenniston@catapultpr-ir.com

Tasktop and SmartBear Partner to Unite Task-focused Development and Peer Code Review for Eclipse

Tue, 22 Feb 2011 19:05:01 +0000

Tasktop and SmartBear Partner to Unite Task-focused Development and Peer Code Review for Eclipse

Streamline the Peer Review Process as Part of Regular Development Workflow

Vancouver, Canada and Beverly, MA, Feb. 22, 2011 - Tasktop Technologies (http://tasktop.com), creators of the Eclipse Mylyn project and a leader in Agile Application Lifecycle Management (ALM) integration and productivity, and SmartBear Software (http://smartbear.com/) today announced the Eclipse Mylyn Connector for SmartBear CodeCollaborator. Available in Tasktop Enterprise, the new connector brings task-focused interface technology to code reviews managed in CodeCollaborator, making code reviews a regular part of Eclipse-based development activities. The integrated Tasktop and CodeCollaborator offering helps development teams develop higher quality software that is delivered to market faster and more efficiently.

"This latest Tasktop Enterprise connector is the result of our collaboration with SmartBear and a joint enterprise customer who needed to improve developer productivity by taking advantage of the task-focused interface to get the most out of the code review process," said Mik Kersten, CEO of Tasktop Technologies and founder of the open source Eclipse Mylyn project. "Many organizations deploying Agile practices will find the task management and automated knowledge capture provided by Tasktop to be a developer-friendly on-ramp to SmartBear's leading code review tool."

Tens of thousands of software developers, systems analysts, firmware and hardware designers use SmartBear's CodeCollaborator to conduct peer reviews on code, images, design documents and schematics, and identify software defects early in the development lifecycle. The Tasktop Enterprise task management and ALM integration tool helps software developers using Eclipse become more productive by making it effortless for them to organize their work around tasks and automatically present the most relevant source code and project management information associated with each task. Together, Tasktop Enterprise and CodeCollaborator help streamline the code review process, increase software quality and reduce time-consuming and expensive bug fixes that frequently occur late in the product development cycle.

Features and benefits of the Eclipse Mylyn Connector for CodeCollaborator include:

Ability to quickly and easily conduct code reviews as the Eclipse IDE only shows the source code that needs review.
Task list integration that provides in-IDE awareness of new reviews and status changes for existing reviews, helping developers incorporate reviews into their regular work flow.
Ability to have code reviews linked to relevant defects and stories, making it easy to learn more about the bug or feature under review, or to determine which features have been reviewed.
Combined Tasktop and SmartBear product also is available from the Mylyn Connector Discovery tool, making it effortless to download and install from within the Eclipse IDE.

"Integrating the CodeCollaborator code review process in Eclipse creates a seamless experience for developers," said James Wang, GM and VP, CodeCollaborator Products. "The new certified Tasktop Mylyn Connector for Eclipse combines task-focused development best practices with CodeCollaborator's peer and code review capabilities, providing users with a proven method for improving their software quality."

This new collaboration extends Tasktop's benefits by incorporating the important code review process as part of an integrated and task-focused Agile ALM stack. The connector is Tasktop Certified and can be downloaded directly as part of Tasktop Enterprise. For more information visit: (http://tasktop.com/codecollaborator).

About SmartBear Software
SmartBear Software provides enterprise-class yet affordable tools for development teams that care about software quality and performance. Our collaboration, performance profiling and testing tools help more than 100,000 developers and testers build some of the best software applications and websites in the world. Our users can be found in small businesses, Fortune 100 companies, and government agencies. For more information about SmartBear Software, our award-winning tools, or to join our active community of developers and testers, visit http://www.smartbear.com.

About Tasktop Technologies
Tasktop Technologies is the company behind the Eclipse Mylyn ALM integration framework and its revolutionary task-focused interface technology. The task-focused interface is proven to make developers more productive by showing only the relevant information for each task, dramatically reducing search time and facilitating multitasking. Tasktop Enterprise is the company's commercial product based on Mylyn, with task-focused support for web browsing, time tracking, documents, email, calendars and commercial ALM components. Tasktop also provides consulting, connector development services and training to the growing number of companies adopting the task-focused paradigm and tools. For more information please visit (www.tasktop.com).

# # #
Media Contacts:

Christie Denniston Alex Forbes
Catapult PR-IR SmartBear Software
cdenniston@catapultpr-ir.com
aforbes@smartbear.com
O: 303-581-7760, ext. 13 978-236-7918
M: 303-827-5164

TASKTOP TECHNOLOGIES NAMED FINALIST FOR CANADA’S SUCCESSFUL YOU AWARD

Fri, 18 Feb 2011 00:27:27 +0000

TASKTOP TECHNOLOGIES NAMED FINALIST FOR CANADA'S SUCCESSFUL YOU AWARD

Company recognized as one of the best employers in British Columbia's Successful You Awards

VANCOUVER, Feb. 17, 2011 - Tasktop Technologies (www.tasktop.com), creators of the Eclipse Mylyn project and a leader in Agile Application Lifecycle Management (ALM) integration and productivity, today announced that the company has been named a finalist in the best employer category for 8th Annual Small Business British Columbia Successful You Awards (http://www.successfulyou.ca/). The awards are a province-wide event that recognizes and celebrates the important contributions BC's entrepreneurs make to their local communities and global economy.

"These awards celebrate the excellence of successful small companies in British Columbia just as the small business community itself exemplifies the entrepreneurial spirit of our province," said Colin Hansen, minister of finance and minister responsible for small business. "Fifty-seven percent of British Columbia's private sector jobs are with small businesses and the sector accounted for almost a third of total provincial GDP, the highest of all provinces."

Tasktop created Tasktop Enterprise task management and ALM integration tools to help software developers become more productive by making it effortless for them to organize their work around tasks and automatically present the most relevant source code and project management information associated with each task. The end result is that developers and other stakeholders in organizations no longer have to waste time repeatedly searching and scrolling for the information they need to get work done, since Tasktop Enterprise shows only the information relevant to the task-at-hand.

The concept of a task-focused interface was developed over several years of university research conducted by Tasktop co-founders, Dr. Mik Kersten and Dr. Gail Murphy at the University of British Columbia. During that time, Kersten and Murphy refined and validated the technology through a large-scale peer-reviewed study which demonstrated with statistical significance that programmers using the task-focused interface code more and click less, getting more done.

"The recognition of Tasktop by Small Business BC indicates the world class talent and passion of our employees and the rapidly growing demand for our productivity and collaboration tools," said Kersten, CEO of Tasktop Technologies and creator of the open source Eclipse Mylyn project. "This award also exemplifies the benefits provided by the Canadian government's R&D programs and reinforces the ability for BC-based high tech companies to make an impact on the global marketplace."

Winners in each of the award categories will gain prestigious local, regional and national exposure and recognition and will be revealed at the Awards Ceremony at the Hyatt Regency Vancouver on March 29, 2011.

# # #
Media Contact:
Christie Denniston
Catapult PR-IR
cdenniston@catapultpr-ir.com
O: 303-581-7760, ext. 13
M: 303-827-5164

Elevating the Status of Task Management

Thu, 10 Feb 2011 21:00:43 +0000

By Jason Brooks, eWeek

Tasktop Pro 1.8 stitches together application-lifecycle-management systems with the Web-browsing, document, calendar and e-mail activities that form the context of a specific task.

Task management, while no less central to one's workday than e-mail or calendaring, is the ugly stepchild of productivity applications. At worst, tools for managing to-do-list items tend to occupy some unnoticed corner of a larger application. At best, these capabilities are pushed off into separate products that integrate only weakly into a user's desktop environment. Most often, tracking tasks across a team ends up as yet another chore piled onto an e-mail system not designed for the job.

Tasktop Technologies is out to elevate the status of task management, starting with software developers. Through their use of issue-tracking systems, software developers tend to be more tuned to collaborative task management than most, though they still depend heavily on Web-based applications and e-mail for accessing these systems. Tasktop Pro 1.8, based on the open-source Eclipse Mylyn project, elevates task management for developers by stitching together various application-lifecycle-management systems with the Web-browsing, document, calendar and e-mail activities that form the context of a specific task.

However, more than simply stitching together views of the many different information sources that are required to work on a project into an unwieldy developer dashboard, Tasktop only displays the pieces of information relevant to an active task. In my tests of the product, Tasktop dutifully watched as I opened documents, Web pages and specific source-code files, and added these elements to the context of my active task.

Tasktop 1.8 is available as a stand-alone application or as an Eclipse plug-in. Tasktop Technologies is working on a version of the product, currently in beta, that's delivered as a plug-in for Microsoft's Visual Studio. Tasktop integrates with external issue-tracking and product-management systems through connectors. I tested Tasktop 1.8 with Mozilla's Bugzilla issue tracker, and with the connector for Google Apps. A list of supported connectors, which include Jira, Rally and CollabNet, is available.

Tasktop 1.8 Pro is $99 per seat, and the stand-alone version of the application is available in Windows, Linux and 64-bit Linux versions. I tested the product in its stand-alone Linux 64-bit version, and as a plug-in to Eclipse on both Windows and Linux.

Tasktop 1.8 in the Lab

I tested Tasktop in a couple of different scenarios. I used the product in a hosted environment provided by Tasktop Technologies and pre-populated with Bugzilla and Hewlett-Packard Quality Center repositories. I used this environment to collaborate on a handful of tasks with my contact from the vendor. I also tested the product on my production notebook with a handful of pending projects, including a project for the writing and testing required for this review. For this latter scenario, I mostly stuck to a local task repository that ships with the product, and I integrated my Tasktop installation with my Google calendar and e-mail accounts to test those integration points.

The first step in configuring Tasktop is adding a task repository via one of the available connectors, and configuring the repository with your account information for the system. Next, you create a query to grab some portion of the tasks stored in the repository.

With Bugzilla, for instance, I could create queries using the same dropdown options and search fields that appear in the system's standard Web interface, or I could provide a URL to define the query. Since each repository type stores different information, the interfaces for building queries and for individual tasks look a bit different. However, once configured, tasks from various sources all automatically synchronize with the local Tasktop installation, with each appearing in the product's task list under a folder for each query. I could also apply my own categories to each item so that tasks from different sources could appear together in my list.

In addition, I could schedule due dates for my tasks and synchronize those events with my external calendar-in my case, a Google calendar, though I could also synchronize with an Exchange-based calendar from a Windows machine running Outlook. My tasks appeared alongside other events on my calendar in a schedule applet docked at the bottom of the Tasktop interface. Also on the scheduling and time-management front, I was able to track the amount of time I spent working on each task, create reports based on this information, and export the reports in CSV (comma-separated values) or HTML format.

When I selected a task to activate, Tasktop tracked the files, Web pages and source packages I used while working on the tasks, and stored that information alongside the task. I could remove elements from the stored context, and adjust, with a slider control, the amount of context displayed. When I was working on tasks backed by an external task repository, I was able to attach the task context I'd assembled to the external task source, so that people collaborating with me could access that context.

For the Web-browsing tracking, I could use a browser embedded within Eclipse. Or I could use Firefox 3.6, which (combined with a Tasktop extension) would track the pages I browsed while working on a particular task and add them to my task context. When I switched to a new task, Tasktop directed Firefox to close the set of tabs and open the tabs from my newly activated task.

I ended up writing this review into Google Docs, using the embedded-Web-browser configuration. When I was ready to work on the story, I would activate my Tasktop review task, and my review document at Google would open in the middle pane of my Eclipse instance.

I configured my Tasktop instance to connect to my Gmail account-although I could have similarly accessed any IMAP-based mail account-and created a query that matched messages with a "task" label. I could then label mail messages I wished to act on, and those messages would automatically sync to my task list. From there, I could categorize and edit the e-mail-based tasks, but unlike the issue-tracker-based task repositories, the editing relationship was one-way. I couldn't see the modifications I'd made in Tasktop from Gmail, nor could I attach comments or context back to the Gmail messages.

To the original article on eWeek, please click here: (http://www.eweek.com/c/a/IT-Management/Elevating-the-Status-of-Task-Management-466228/)

Prediction #5: Open source ALM tools continue to gain market share, give the development manager a migraine

by Mik Kersten, February 8th, 2011

The influence of open source on software development is often measured by the impact of successful libraries and frameworks. It's hard to imagine building a modern web application without open source components. A similar trend is now unfolding in the Application Lifecycle Management (ALM) space, driven by tools created by projects needing to support their own open source software delivery. While ALM tools are often associated with the heavyweight workflow characteristics of enterprise application development, successful open source projects are a great example of the transformation underway in ALM, towards lean methods and lightweight, developer-centric tools.

In contrast with the application development tools which we use for writing and debugging code, ALM tools assist us with an application's evolution over time. At their core, ALM tools track tasks and changes, help manage builds and releases, and support the dialogue that defines an application's evolution. This subset of ALM is sometimes referred to as Application Development Management (ADM). On top of this core feature set layer tools for project and product management. Large organizations add additional tools to the stack to handle program and project portfolio management.

Thanks to a combination of resource constraints, a preference for using open source technologies for open development, and the common desire for developers to sharpen and extend their own toolset, the past decade has delivered a critical mass of the open-source ALM tools. Consider the scale of ALM on Eclipse.org: 33M lines of code in the last coordinated release (733 installable features/components), 330K total Bugzilla reports (3K new each month), 15K Bugzilla users, 1K committers (400 active), 300 projects and 173 Hudson build jobs. Add to that dozens of interdependencies between Eclipse projects and other open source projects such as the popular Apache libraries. ALM on Eclipse is managed entirely with open source tools including Bugzilla, CVS, Git, Hudson, MediaWiki and Mylyn.

The 1,948 respondents to the 2010 Eclipse Community Survey provide an overview of the degree to which open source tools have percolated into commercial software development. Only a small fraction of the survey respondents were directly involved with Eclipse, and half were from organizations with over 100 employees. The striking pattern is that the core open source ALM tools, when combined, have the market lead in each of three key ALM categories visible in the figure below. In 2010 for these categories, open-source ALM has taken the market lead from closed-source solutions. While surveys of this sort are always skewed towards the type of developer who bothers to answer surveys, this result remains indicative of a shift in application development practices and open-source ALM market share. In 2011, I predict that this trend will continue and that open source tools will percolate into the ALM stacks of more conservative organizations. A degree or two of separation from their open source counterparts, many of those developers will not recognize the term DVCS before it is force fed to them.

The attraction to open source ALM is not just price point, but the amount of innovation that has been driven by open source developers building tools to support their own productivity patterns. The ecosystem of extensions that forms around popular open source projects is another key driver of adoption. Those ecosystems are also likely to produce the most interesting integrations, since open source has proven itself as the most effective mechanism for growing both the community and APIs needed for innovative extensions. Finally, organizations with long application and product lifecycles are attracted to open source ALM tools because a suitable open source license gives them confidence that they will be able to access and extend the knowledge base represented by their issue tracker ten years from now, when the landscape of ALM vendors will much different than it does today.

Open source ALM tools are built on developer-centric principles. Transparency is favoured over hierarchy, with every task and bug on Eclipse and Mozilla being editable by anyone. It relies on asynchronous collaboration and a consistent use of the task or issue tracker to capture all discussion relevant to changes in the software. It encourages lining up modularity and framework boundaries with team boundaries, allowing API layers to facilitate dependencies and collaboration. There are also things missing from the stack. Responsiveness to the community often takes precedence over planning, and after the fading away of XPlanner, there has been a distinct gap in project management features within the open source tool space. There is also no single integrated open source ALM stack, instead open source projects glue together their own best of breed solutions, and layer customizations on top, as is the case with the numerous tools built on the Eclipse Bugzilla repository. Integration with product, project and portfolio management tools is typically non-existent, as this is not something that even large open source projects need.

While open-source developers will continue working very happily with their increasingly slick tool set, this impedance mismatch with large-scale ALM implies major problems for organizations who are planning to get a lot of ALM functionality for free. There mismatch between both the toolset and the cultural aspects of open source ALM tools and what's needed by the enterprise. Agile and lean development have the opportunity to bridge some of the cultural gap, but still have a considerable way to go in order to incorporate the lessons learned from open source. There is enough of a gap in the toolset that organizations already deploying open-source tools at the enterprise ALM scale have needed to set up their own ALM tool engineering teams. These teams create enterprise-level authentication and access control, provide third-party ALM tool integrations, and implement support for features such as linking existing Project Portfolio Management (PPM) tools. Due to the pace of change in open source ALM tools, they are fighting a losing battle. While wasteful, this exercise is currently necessary. Large organizations that fail to integrate already deployed open source tools into their existing ALM and PPM infrastructure will see a dramatic reduction in the predictability of their development process, since their process relies on a connectivity between development and planning tools that was present in the more traditional ALM tool stack.

There is hope. First, the benefits of open-source ALM tools are fundamental as the ease with which they allow developers to work makes us happier and more productive. The velocity of successful open-source projects demonstrates how good these tools are at supporting the delivery of high-value software that is responsive to the needs of the community and customer. On the flipside, Enterprise ALM tools provide management and planning facilities which are critical for predictability of delivery as well as the longer-term planning that is necessary for organizations to thrive. These two worlds must be integrated into a cohesive whole, especially as more Agile teams find themselves at the intersection of open source and enterprise ALM.

After I presented my keynote on open source ALM at W-JAX last November, a colleague from one of the world's largest software companies commented that the same developers that worked on open-source projects were twice as productive as when they worked on closed source projects. We discussed the usual issues of motivation and incentive structure, but nailed down the key issue being the sheer friction generated by traditional ALM tools which has been removed from open source ALM tools. It is time to reconnect the software planning process to a new breed of open source ALM tools that support lean and high velocity delivery, connect them to the planning and management tools needed for software delivery at scale, and bring some of the benefits of open source development to the enterprise.

For more blog entries from Mik Kersten or Tasktop Technologies, please visit: (http://tasktop.com/blog/).

Click here to Watch Tasktop webinars

Prediction #6: Continuous integration becomes central to deployment, Jenkins attacks Hudson with a chicken

by Mik Kersten, February 3rd, 2011

How does a continuous integration (CI) tool named after a butler or two grab such a large market share when much more feature-rich and polished commercial counterparts exist? The naïve answer is that it's free. If you dig a bit deeper, the success of Hudson can be seen as part of a larger trend in developer-centric application lifecycle tools. A growing number of open source tools have hit the mark in capturing developer collaboration and Agile lifecycle management practices. What has caused these tools to snowball in popularity is the rich ecosystems of extensions that they support. That combination has become lucrative to larger organizations wishing to increase the productivity of their developers. When an open source community starts smelling of money-making potential, a different breed of dog moves in. This can be a very good thing, as it is often the catalyst needed to move the project across the chasm to broad industry adoption.

The challenge for popular open source projects is to create a governance model that marries the interests of the project's community with those of vendors supporting the project. The most successful open source projects are ones that manage this dichotomy without alienating either party. Spring, JBoss and MySQL won by having a single dedicated vendor managing commercial and community interests. Eclipse and Apache have created governance models that support the overlapping interests of multiple vendors. In the case of Hudson, with Kohsuke's departure from Oracle, a split formed. In recent blog posts we've seen Kohsuke Kawaguchi, creator of Hudson, highlighting the community and the ecosystem of extensions that have made Hudson successful to date. On the public forums, Oracle's Ted Farrell has emphasized the importance of versioning, consistency and stability, which are relevant for taking Hudson to the next level of enterprise adoption. Both of these concerns need to be addressed.

Over the coming year, extensible continuous integration is going to play a key role in both on-premise ALM stack modernizations and cloud-hosted ALM solutions. If you have a few grey hairs on your head, this may not sound new or noteworthy. A decade ago, we set up a CI build for AspectJ.org with CruiseControl and Ant and it is still running today. More modern Mylyn CI builds are very similar, but running Hudson and Tycho. What's interesting is that over the past decade the continuous integration loop has become the underpinning of build automation in the Agile development process. Easy extensibility has made CI servers a convenient hub for plugging a variety of ALM tools into the Agile build loop. We are moving away from a world where realses, code metrics, testing tools and deployment destinations are being configured by each developer within his or her IDE. Instead, the CI server is becoming the hub that holds the authoritative build specs, with developers attaching to the portion of the ALM artefacts that they need to work on for the current release. Testing, quality, and metrics tools will increasingly use the CI server as the place to hook into the development process. In an upcoming prediction, I'll discuss how combining task-focused workflow with continuous integration will prove to be a convenient abstraction for tool support that facilitates knowledge capture and sharing between Planning, Dev, Ops and QA.

All of this potential means that Hudson is a hot topic, and that Hudson's consumers are scratching their heads on what to do about the Jenkins fork. Hudson's success to date comes from the typical mix of passionate community leadership, open source extensibility and a vendor-sponsored marketing investment that helped create that community. The latter is often omitted from developers' discussions, but now that we are in the later stages of open source maturity, a project's access to marketing resources has become a key component to success. A case in point is the significant marketing budget of successful open source foundations, or that of the Mozilla Foundation's, which is in the millions.

In open source, community-centric passions drive projects to their initial critical. Then comes the point at which enterprise support, stability, and the ability for other vendors to invest in a project become relevant. These help a project to graduate from an early adopter community to the pragmatists who can establish an open source project as a de facto standard. For that to happen, a project must be bigger than the cult of personality around its founder, just as any organization must be bigger than its leader to thrive. But with the heart of the contributor community in his hands, and his brain more wired to the technical vision of the project than any other person's on the planet, the founder is often required to drive major downstream innovations.

In the year ahead, the existing consumers of Hudson will vote with their feet whether to go with the forked Jenkins codebase or with Hudson. The question will largely boil down to how stable the core of Hudson is, and whether upcoming changes to the core of Hudson that happen within Jenkins, and its key extensions, warrant a migration. In the closer-knit community there will be a tendency to Jenkins, as represented two hundred community votes, the majority of which were in favour of the fork. But in the much larger end-user community the default will be resistance to change in the absence of major and clear value add to making the move. We've seen this on Eclipse with the overly slow migration of many plug-ins to e4, which brings incremental value add and only benefit.

The large and more conservative consumers of Hudson will look to which corporate sponsor, Oracle for Hudson and the CloudBees startup for Jenkins, is providing better long-term assurance for their build infrastructure investment. There will be questions about Jenkins' promise of neutrality. In the past, genuine open source project neutrality has only been achieved by large open source foundations with sufficiently diverse funding sources, and even then with mixed success. As such, while Jenkins is likely to see activity, Oracle's Hudson is unlikely to go away and I predict that it will continue to be a major target of CI deployments through the year.

In the interim, as with the Emacs vs. XEmacs fork of the 90s, there will be some confusion and annoyance from those less interested in the drama. Thankfully John Ferguson Smart wrote his Continuous Integration with Hudson book in open source fashion, making it easier to refactor. If the divergence between the two projects is sufficient to fragment and fracture the community, there could be a large enough gap for a new open source CI system to join the scene, but it would take time for it to build up momentum. In the meantime, the usual API-level federation layer is likely to form so that plug-ins can support both tools, and we're invariably going to be asked to create one in Mylyn. Most of the internet associates the name Jenkins with a certain Leeroy who went into a World of Warcraft battle wielding little more than an attitude and a chicken. I hope that in this battle less damage is done to the consumers of this otherwise winning CI technology.

For more blog entries by Mik Kersten or Tasktop Technologies, please visit: (http://tasktop.com/blog/).

Click here to Watch Tasktop webinars

Prediction #7: Web-based code editors become viable, cloud-based IDE platforms remain a pipe dream

by Mik Kersten, February 1st, 2011

A couple of years ago, a web-based code editor called Bespin was the rage at EclipseCon, and has been reborn in the form of the Cloud9 IDE for JavaScript. Eclipse re-embraced the push towards web-based IDE technologies with the introduction of a new code editor named Orion. While activity is again heating up on this front, do not expect the enterprise developer's IDE to be running in the browser this year. What we will see is web-based advances in specific IDE use cases, ranging from code editors for DevOps to GUI builders for mobile, with most developers staying within the comfort and native UI of their desktop IDE.

Apart from the OS, the IDE may now be the most complex piece of software running on your desktop computer. Eclipse pushes the limits of the UI element handling of the desktop OS as well as the classloader model of common JVMs. What makes an IDE platform even harder to port into the browser is the need for extensibility, ranging from interaction with the filesystem to shared data models of the large variety of code and ALM artefacts that constitute an application.

Just as mobile applications are constantly pushing the limits of the hardware behind our 3.5" handheld screens, the IDE tool suite continues to push the limits of the hardware driving dual 24" displays. Third party plug-in developers need to be very aware of the performance of their extensions to Eclipse so that they don't bring an Intel Core i7 CPU with 8GB of RAM to a crawl. The current generation of browser-based JavaScript runtimes is not up to the task of running the IDE platform as we know it. But we are starting to see the first crop of high-performance web-based code editors. Between the drive towards cloud hosting of applications and the push to lower the barrier to entry for mobile development, there will be plenty of incentive for vendors to provide SaaS offerings that incorporate key parts of the application development experience.

The 15M or so professional developers (Evans Data, 2009) will spend their day in Eclipse and Visual Studio, but these IDEs will begin to feel more like a connected Rich Internet Application (RIA) than a desktop-bound dinosaur. The data accessed by the open source developer, including source code, tasks and builds, is already cloud hosted. Eclipse extensions like Tasktop Enterprise mash up the web browser experience with the rich IDE experience. The professional IDE will start feeling more like a connected and offline capable Mozilla Thunderbird or Microsoft Outlook, with collaboration and planning facilities taking a front seat alongside social coding tools. Just as iOS has found the sweet spot between native experience and web service-based data sources, so will the IDE.

Outside of enterprise application development, domains where a simplified tool stack is applicable will start seeing web-based IDE features. Xcode is one or two order of magnitude less complex than a full-blown enterprise Java IDE. Palm's Ares project was the pioneering example of how effective combining Bespin functionality with a JavaScript GUI builder for webOS could be for providing a simple user experience to hobbyist mobile developers. Even our Smalltalk forefathers would be impressed with an environment that supports authoring JavaScript widgets in a JavaScript-based GUI builder. Given the lack of a clear winner for JavaScript development environment on the Eclipse front, JavaScript will continue to be a natural target driving progress on moving IDE functionality into the browser. But the amount of work here should not be underestimated, as a lot of what already exists in the desktop-based IDE will need to be re-created to get to the sort of fidelity and breadth of tool support that's now taken for granted.

Cloud ALM hosting with the connected IDE and Browser-based clients

On the cloud hosting front, key parts of ALM data such as source code, builds and tasks, are already starting to be hosted in a unified manner, as exemplified by the upcoming Code2Cloud offering. Some stakeholders in the development process, such as DevOps and QA engineers, will start to benefit from Eclipse Orion-style code editors accessing and fixing entries in Spring config files without launching the IDE. This will lead to easier management of production since the need for console access for these sorts of tweaks will be removed.

Looking further out, the increasingly connected IDE will have all of its configuration data hosted, making the experience of the first launch of Eclipse similar to that of the first launch Skype, where entering credentials causes the rich client to instantly provision the user's desktop. The division of labour between web and desktop based access of software artefacts will improve, with some content that was previously browser-bound, such as Scrum task boards, being supported within the IDE. The mobile hobbyist, casual web developer, and specific stakeholders such as the DevOps engineer, will see nearer term benefits from the growing convergence of the browser and the IDE.

For more blog entries from Mik Kersten or Tasktop Technologies, please visit: (http://tasktop.com/blog/).

Click here to Watch Tasktop webinars

Prediction #8: Eclipse and Visual Studio dominate the IDE market, become even more boring

by Mik Kersten, January 31st, 2011

I miss the heyday of the IDE wars. Seeing David Intersimone's demo of JBuilder at OOPSLA 1998 opened my eyes to the way that tools can multiply our productivity. The competition that ensued between Borland, Microsoft and others brought us code assist, refactoring, structured editing, GUI builders, and a far more integrated developer workbench than the windowing system and command line could provide. In 2001, the landscape changed dramatically when IBM killed a significant part of the developer tools business by open sourcing Eclipse (later re-entering the tools business by acquiring Rational). The open sourcing of Eclipse was a success and created an unprecedented platform for tool innovation. But Java developers started expecting their IDE to be free, and the IDE business was gone for all but the most inspired tool builders, such as JetBrains.

The base IDE feature set has now been standardized and commoditized. In other words, it has become a lot more boring. To get buzz on Twitter, vendors have to pull zany moves like running a thin subset of IDE functionality in a web browser. The bleeding edge aside, we won't see any dramatic departures from the base IDE feature set anytime soon. However, we'll continue getting many nice tweaks and features, as you would expect with mature tools like cars or can openers. As with other commodities that need to differentiate their extremely similar feature sets via slick dashboards and sophisticated cup holders, we will see some welcome improvements on the fronts of eye candy and usability. This kind of tweaking is already surfacing in Visual Studio 2010, which saw an investment in user experience and graphic design refresh that put it ahead of the curve.

While the base feature set of code editing, building, debugging and deployment solidified, tool innovation will now occur on top of the commoditized IDE platform. The major shift in the IDE over the last decade has been to shift from end-user tool to tool platform. And like any software platform, the IDE now needs to evolve more slowly because the innovation is happening on top of it. Beneath the IDE we're swapping out the deployment model to be cloud-based, as with the SpringSource Tool Suite's (STS) direct cloud deployment. Atop the IDE we are layering on all sorts of collaboration features, recognizing that developers spend as much time collaborating around code as they do hacking it. I can no longer imagine working without having rich and IDE-based access to a task board and release plan.

The IDE has multiplied productivity by integrating, then personalizing developer's workbench

The maturity of the Eclipse 3.6 and Visual Studio 2010 platforms has made it possible to bring the developer's entire coding and collaboration activity into a single workbench built on plug-in APIs and shared data models. In 2011, we will see the remaining APIs completed, such as Mylyn's new APIs for IDE-integrated code reviews, distributed version control, continuous integration and documentation. Whereas last decade's IDE was all about integration and helping developers stay in the flow of their work, the next decade of the IDE will be about personalization. We are shifting from the IDE being a view on the entire system to the IDE being a view of the parts of the system and planning that are relevant to the developer. The shift might sound less exciting, but its impact on developer productivity will be just as pronounced, and is necessitated by the steady growth of software complexity. The integration of Agile, ALM and a task-focused workflow will drive the IDE's shift from an integrated workbench to a highly personalized one, incorporating the focus and flow needed to keep developers working on extremely complex software happy and productive.

Boeing's 787 Dreamliner is reported to run 6.5 million lines of code, approximately the same number as the core Eclipse platform. The whole of the 2010 Eclipse Helios release train was 33 million lines of code. Add to this all of the third party extensions, and today's IDE platform ranks with some of the most complex artefacts produced by humanity. Due to the scale of investment, marketing and ecosystem management, as with commercial aerospace, we will see the two big players dominate the IDE market. The small and niche players will continue to exist, ranging from the boutique IntelliJ to JDeveloper for database development. But for those rolling out an IDE across their organization in 2011, the number and availability of third party extensions will be a more important decision factor than the base IDE feature set. ISVs and cloud/PaaS vendors will increasingly use the IDE as an on-ramp for their offerings, with Eclipse and Visual Studio as the clear targets for their integrations. Following the user-centric success of the Embraer E-190, which provides a superior cabin experience to similar offerings by the two aerospace giants, a renewed focus on developer productivity and Agile collaboration needs to be the driver of change in the IDE over the coming years.

For more blog entries by Mik Kersten or Tasktop Technologies, please visit: (http://tasktop.com/blog/).

Click here to: Watch Tasktop webinars

Prediction #9: Majority of developers demand access to Agile/ALM tools from IDE, look elsewhere for pretty colours and oversized fonts

by Mik Kersten, January 27th, 2011

Back when we worked on systems that were tens of thousands of lines of code, Integrated Development Environments (IDEs) were a nice option, but often ignored by the alpha geeks living in Emacs and vi. Now that even mid-sized enterprise applications are close to a million lines of code when both the application and its dependent libraries are considered, the majority of professional developers see the structured editing and navigation facilities of an IDE as a fundamental requirement.

The initial evolution of the IDE and of Application Lifecycle Management (ALM) tools was independent. A decade ago, the OTI folks at IBM, master tool builders with their roots in the Smalltalk era, created an Eclipse integration layer that made CVS feel like a modern SCM system. That seemingly impossible feat taught tool builders an important lesson. Even if you had a grossly antiquated service, you could provide a modern and high fidelity experience in the client. A few years later, the initial Mylyn release signalled the next step of the convergence, by providing a modern task and issue tracking experience in Eclipse for Bugzilla. The migration from disparate web and command line UIs into an integrated coding-centric IDE was well underway.

Since that time, countless developers have recognized the time wasted by switching to a web browser in order to update an issue or to start investigating the latest must-fix defect. Application switching itself is relatively small time sink, adding up to an extra coffee break or two in the workday (i.e., 4% of the pie in the figure below). A far greater problem is that browser-based applications are ignorant of the system's structure. This means that the burden of mapping between the code and the tasks driving our programming activity is placed on our already over-taxed brains. If a stack trace appears in a defect, we have to copy the stack frame, paste it into a search box, and iterate this process until we've found and fixed the issue. If this turns out to be something which must be handed off to someone else, then all of the research, analysis and other task-related state which has been built up during the exploration gets tossed out when we reassign the task, and the wasteful process is repeated. It all feels very 1990s. In my PhD research I measured the impact of this repeated searching, task-related context switching and redundant code navigation. These numbers were similar to the more recent ones visible in the figure below. Around half of a developer's day is going to waste. That's before accounting for meetings.

Time-based breakdown of a developer's day, gray is waste

On the SCM side, we still have command line clients. If you've got time to burn, switching between the command line or shell extension to work with your SCM system may not pose a problem. If you're a top-notch developer, you may even have the spare brain cycles available to work effectively in this way. But that doesn't mean that it makes sense to do so. Many of the early pioneers of Smalltalk showed us the path towards integrated tooling long ago: everything should be explicitly present and directly manageable from within the developer's workbench. Today, that workbench is the modern IDE, and the benefits of the IDE to the Agile and ALM workflow go far beyond having an embedded rich client. The deeper benefits come from the rich linking and data sharing that's possible once the developer's entire toolset is built on the same integration platform. Tasks, contexts, commits, builds and reviews can now all get automatically linked as we work, and all collaboration activity takes place alongside the code, where it belongs.

Similar benefits arise in moving developer-specific workflow from browser-based Agile project tracking tools into the IDE. The web browser has been a great vehicle for helping Agile tools take shape and for introducing them to the masses. The Web 2.0 trend helped issue trackers get more colourful with slick stylesheets and a visual refresh with the large and simple styling popularized by 37signals. However, there is a reason that desktop-based applications still dominate the productivity tools landscape. The modern IDE is capable of putting all but your desktop's hardware, except the graphics card, to full good use. It is now common to access Twitter, email, and instant messaging have gone back to the future by providing a growing number of native desktop and mobile clients. Given the complexity of the way we collaborate on the application lifecycle front, the benefits of a native client are even more pronounced. . Over the course of the year, as Agile ALM tools continue to mature, IDE-based access will cease to be an afterthought and minor check-box on the ISV's feature matrix, and high fidelity IDE tools will become the client of choice for developers accessing the Agile ALM stack.

Innovation on the browser-based application front will continue, and in the following predictions I'll discuss the state of web-based IDEs. For 2011, we can safely consider the desktop-based IDE to be the place where most coding gets done. Web UIs for Agile and ALM will continue to serve an important role, for example, as the primary interface for management-level stakeholders and product owners. What's exciting is that that we will also see additional convergence between Agile tools and the IDE. Minutes before the daily Scrum the developer will be able to instantly pop up an embedded task board showing all things assigned to them for the current sprint, and with a click activate a user story they were collaborating on with a colleague, automatically share progress and update time remaining, and come out looking like a rock star in the Scrum. Sadly it may take longer before we're updating task boards with Xbox Kinect based Minority Report type gestures, but this is progress.

For more blog entries by Mik Kersten or Tasktop Technologies, please visit (http://tasktop.com/blog/).

To watch Tasktop Webinars, please visit here: http://tasktop.com/about/webinars/