Catapult Public Relations

TASKTOP’S MIK KERSTEN PRESENTS WEBINAR ON MODERNIZING ALM ARCHITECTURE WITH TASKTOP SYNC

Thu, 01 Dec 2011 20:09:25 +0000

Webinar provides in-depth overview of Tasktop Sync 2.0 WHO: Mik Kersten â�� CEO and founder of Tasktop Technologies (www.tasktop.com) Kersten is the creator of the Eclipse Mylyn open source project and inventor of the task-focused interface. At Tasktop he provides the technical vision behind Tasktop Dev for developer productivity and tool integration and Tasktop Sync for enterprise ALM synchronization. WHAT: Modernize Your ALM Architecture with Tasktop Sync 2.0 In this must-see webinar, Tasktop CEO Mik Kersten will provide the first in-depth view of Tasktop Sync 2.0. The latest version of Tasktop Sync 2.0 provides a set of industry-first facilities for connecting an ALM stack. Kersten will highlight the new features of Sync 2.0 which connect all stakeholders with real-time traceability and collaboration. The webinar will conclude with a conceptual overview of Tasktop's Task Federationâ�¢ technologies and best practices for connecting and modernizing the ALM stack, from business analyst to developer. An overview of what's new in Tasktop Dev 2.2 will show attendees how to bring this new connectivity and traceability to developers. For example, Tasktop Dev 2.2 builds on HP's Application Lifecycle Intelligence feature to provide instant workspace provisioning for developers using Eclipse. No matter what mix of developer, QA, Agile and requirements management tools, Tasktop Sync and Tasktop Dev empower developers and other stakeholders to use the tools that make them most productive while ensuring that the ALM artifacts are automatically and seamlessly connected to ease collaboration, reporting and traceability. WHEN: Tue., Dec. 6 - 9 â�� 10 a.m. PST INFO: To register for this webinar please visit: (http://tinyurl.com/6lsj8zs). Updates from the webinar will be available by following the live Twitter feed at #TaskSync. To learn more about Tasktop Sync please visit (http://www.tasktop.com/sync). To arrange an interview with Mik Kersten please contact Christie Denniston at 303-581-7760 or by email at (cdenniston@catapultpr-ir.com).

TASKTOP TECHNOLOGIES NEW SYNC 2.0 PROVIDES ALM ARCHITECTURE MAPPING AND APPLICATION LIFECYCLE LINKING VIA OSLC

Mon, 28 Nov 2011 17:27:04 +0000

Tasktop continues to bring order and increased productivity from disparate and disconnected Agile ALM tool stacks within enterprise IT organizations

VANCOUVER , BC Nov. 28, 2011 â�� Tasktop Technologies (www.tasktop.com), creators of Eclipse Mylyn and a global leader in ALM integration and developer tools, today announced Tasktop Sync 2.0, the latest version of its Task Federationâ�¢ platform that allows IT organizations to synchronize existing ALM servers from multiple vendors and open source projects. Tasktop Sync 2.0 makes it even easier for administrators to manage their ALM synchronizations through powerful visual tools and extends integration support via change management artifact linking via the Open Services for Lifecycle Management (OSLC) interoperability protocols.

â��Complex sourcing has become the norm for most companies â�� including off-shoring and open source â�� and deployment across a multitude of platforms, such as mobile, embedded, cloud and on-premise, drives software development challenges,â�� said Melinda Ballou, program director for IDC's Application lifecycle Management (ALM) service. â��In this context, lack of coordination across lifecycle management phases and automation undermines business innovation and agility. Companies urgently need ways to effectively connect a broad range of lifecycle tools to enable visibility, metrics and control.â��

Tasktop Sync is built on the industry-standard Eclipse Mylyn ALM interoperability framework to provide real-time synchronization, automatic and configurable conflict resolution, and support for more than two dozen ALM tools. It unifies heterogeneous ALM stacks by allowing developers, testers, business analysts and managers to work within their best-of-breed tools of choice, while automatically maintaining traceability across ALM artifacts. Built on the companyâ��s Task Federationâ�¢ technology, Tasktop Sync brings task federation to ALM servers, by providing the only real-time, bi-directional and fully automated synchronization between ALM servers. The companyâ��s Tasktop Dev product line supports Tasktop Sync by federating tasks and other ALM artifacts on the developerâ��s Eclipse and Visual Studio desktops.

â��Medium and large organizationsâ�� ALM stacks have become so diverse and disconnected that the lack of traceability and cross-stakeholder collaboration has become the bottleneck of large-scale software delivery,â�� said Mik Kersten, CEO of Tasktop and creator of the open source Eclipse Mylyn project. â��Tasktop has spearheaded a new approach to connecting stakeholders in the application lifecycle, making it possible to capture an organizationâ��s ALM architecture in a single tool and deliver real-time connectivity and traceability across a wide variety of open source, commercial and legacy ALM systems.â�� (To read Mik Kerstenâ��s blog post on this announcement please visit: (http://tasktop.com/blog/news/tasktop-sync-2-0-released)

Tasktop Sync 2.0 includes several innovations for connecting ALM stacks and stakeholders. It provides new visual tools that allow ALM architects and administrators to connect to ALM repositories, conduct introspective analysis of repository schemas and intelligently connect previously disconnected tools via ALM artifact mappings. In addition to artifact synchronization, Tasktop Sync 2.0 provides a new software lifecycle artifact linking facility built on the OSLC ALM interoperability protocols to serve as a broker for linking ALM artifacts

Based on Tasktopâ��s continued collaboration with IBM to define the OSLC protocols, Tasktop Sync 2.0 provides OSLC-based REST API access to more than 20 Tasktop Certifiedâ�¢ Mylyn connectors as well as dozens of other community-driven or in-house Mylyn connectors. For example, organization using IBM Collaborative Lifecycle Management (CLM) tools in the ALM stack, such as Rational Team Concert and Rational Requirements Composer, can now link with artifacts from a broad range of third-party and open-source ALM tools, such as HP ALM and Quality Center, Atlassian JIRA and Mozilla Bugzilla. OSLC linking extends Tasktop Syncâ��s synchronization facilities to support live connectivity and embedding of ALM artifacts in a similar way that social networking tools can embed each otherâ��s feeds (e.g., Twitter within Facebook).

New Features in Tasktop Sync 2.0 include:

â�¢ Sync Quick start wizard to dramatically reduce the time to set up the first synchronization.

â�¢ Visual editor for configuring synchronization mappings.

â�¢ Fine-grained and automated conflict resolution and handling.

â�¢ Full support for custom fields, rich text and wiki transformations, attachments and user mappings.

â�¢ Synchronization support for all common ALM artifacts, including defects, tasks, work items, test summaries and requirements.

â�¢ Unlimited mappings and repositories to connect large-scale ALM stacks with numerous servers and tools.

â�¢ Bi-directional synchronization of task associations, ALM artifact hierarchies, and complex fields

â�¢ Groovy-based scripting support for complex field transformations.

â�¢ For IBM CLM users, full support for IBM Rational Team Concert (RTC) synchronization rules and mappings, allowing administrators to update mappings within RTC.

In addition, Tasktop announced the availability of Tasktop Dev 2.2 that brings new connectivity for developers using HP ALM and Quality Center. Tasktop Dev 2.2 builds on HPâ��s Application Lifecycle Intelligence (ALI) feature to provide instant workspace provisioning for developers using Eclipse. Now, developers can simply connect to a release in HP ALM, and Tasktopâ��s Task Federation facilities load into the workspace the SCM and Continuous Integration (CI) artifacts needed to work on the release, for example, source code from Subversion or builds from Hudson/Jenkins. Tasktop Dev 2.2 also extends HP ALI traceability automation to ClearCase.

Availability

Tasktop Sync 2.0 and Tasktop Dev 2.2 are both available for download tomorrow. Tasktop Sync is offered through perpetual licenses with annual support and maintenance, or annual subscriptions. As a limited-time introductory offer, Tasktop Sync is available as a bundle with Tasktop Dev (Enterprise Edition) for $199 per user, per year. More information is available at (http://tasktop.com/sync).

About Tasktop Technologies

Tasktop Technologies aims to transform the productivity of software delivery by unifying Application Lifecycle Management (ALM) and empowering developers with task-focused tools. Tasktop invented the task-focused interface and created the popular Eclipse Mylyn project, which transformed the developerâ��s IDE experience to center around ALM tool-based collaboration. Building on top of Mylyn, Tasktop has been unifying the ALM landscape with its broad ecosystem of ALM partnerships that connect disparate tools from leading Agile, enterprise ALM and open source offerings. Tasktopâ��s Task Federationâ�¢ technology builds on this ecosystem to unify heterogeneous ALM stacks by allowing developers, testers and managers to work within their best-of-breed tools of choice, while automatically maintaining traceability and visibility across ALM artifacts. The companyâ��s Tasktop Sync provides the only real-time bidirectional and fully automated synchronization between ALM servers. Tasktop Dev is the developer-centric ALM interface for the Eclipse and Visual Studio IDEs, making it dramatically easier for developers to work and collaborate, while keeping ALM tools up-to-date with development activity. For more information visit http://tasktop.com

# # #

Media Contact:

Christie Denniston

Catapult PR-IR

cdenniston@catapultpr-ir.com

O: 303-581-7760, ext. 13

M: 303-827-5164

TASKTOP’S MIK KERSTEN TO OUTLINE AGILE ALM STRATEGIES WITH HP’S RAZIEL TABIB AT HP DISCOVER VIENNA 2011

Thu, 17 Nov 2011 18:38:48 +0000

Development professionals will learn how to manage the increasingly complex and heterogeneous set of tools and processes that make up todayâ��s ALM practices

WHO: Mik Kersten â�� CEO and founder, Tasktop Technologies (www.tasktop.com)

Raziel Tabib â�� product line manager, Software, HP

(www.hp.com)

WHAT: Managing Application Lifecycle Management (ALM) Strategies

The reality of todayâ��s development world is agility; speed and time to market are no longer a luxury but are essential ingredients to maintaining market leadership. Organizations have to move fast and embrace changes without any compromise on quality. In order to execute successfully on such goals, organizational process and culture will need to adjust. During this session, Kersten and Tabib will outline and demonstrate how HP and Tasktop provide development managers with visibility and traceability across heterogeneous tools, processes and technologies to address challenges and provide best practices for organizations. Wherever development teams are located and whatever tools or technologies they work with, HP ALM solutions can serve as a single system of record, providing development managers with the intelligence they need to increase quality and shorten release cycles.

WHEN: Thurs., Dec. 1, 2011 â�� 12:30 p.m. CET

WHERE: HP Discover 2011

Vienna, Austria

INFO: For more information and to arrange an interview with Mik Kersten please contact Christie Denniston at 303-581-7760 or by email at (cdenniston@catapultpr-ir.com).

TASKTOP’S MIK KERSTEN TO OUTLINE OPEN SOURCE APPROACHES TO ENTERPRISE AGILE AT AGILE BEST PRACTICES CONFERENCE EAST

Fri, 04 Nov 2011 16:27:40 +0000

Many facets of open source development that align with dynamics and challenges of enterprise Agile processes can be leveraged by development teams

WHO:Â Â Â Â Â Â Â Â Â Â Â Â Mik Kersten â�� CEO and founder of Tasktop Technologies (www.tasktop.com)

Kersten is the creator of the Eclipse Mylyn open source project and inventor of the task-focused interface. At Tasktop he provides the technical vision behind Tasktop Dev for developer productivity and tool integration and Tasktop Sync for enterprise ALM synchronization.

WHAT:Â Â Â Â Â Â Â Â Â Â â��Ten Great Practices Learned from Open Source Projectsâ��

Open source development combines distributed teams, resource constraints and an overload of end-user input. Despite these challenges, the velocity of many popular open source projects is measurably higher than that of their enterprise counterparts. The time has come to take the lessons learned from open source and adapt them to enterprise Agile. Kersten begins with an examination of successful open source projects and their approaches to Agile delivery. He will then outline the overlap of open source approaches and Agile methods, identifying 10 great practices that Agile practitioners can apply to improve their collaboration and productivity. Each practice is grounded in empirical data that Kersten collected from public open source websites. To provide an intuitive appreciation for the open style of Agile delivery, he will illustrate with graphics and visual aids how open source collaboration evolves and grows over time. Attendees will learn novel strategies for connecting the Lean/Agile methodologies and open source development for large-scale enterprise projects.

WHEN:Â Â Â Â Â Â Â Â Â Â Wednesday, Nov. 9, 2011, 2:30 p.m. Eastern

WHERE:Â Â Â Â Â Â Â Â Agile Development Practices Conference East

Rosen Centre Hotel, Orlando, FL

INFO:Â Â Â Â Â Â Â Â Â Â Â Â For more information or to arrange an interview with Mik Kersten please contact Christie Denniston at 303-581-7760 or by email at (cdenniston@catapultpr-ir.com).

TASKTOP’S MIK KERSTEN TO SHARE INSIGHTS INTO ALM AUTOMATION AND JAVA BUILD AND CONTINUOUS INTEGRATION AT JAVAONE 2011

Mon, 03 Oct 2011 18:07:19 +0000

Kersten to outline ALM Automation with Mylyn and Hudson, and moderate panel discussion on the Future of Java Build and Continuous Integration

WHO: Mik Kersten - CEO and founder of Tasktop Technologies (www.tasktop.com)

WHAT: "Future of Java Build and Continuous Integration"

Mon., Oct. 3, 2011, 11 a.m. Pacific in Hotel Nikko - Nikko Ballroom II/III

Not long ago, developers built and deployed Java applications with brittle scripts and builds invoked from developers' desktops. Given the complexity of today's applications and the shift of the deployment destination from data center to cloud, Java build is due for an overhaul. The increased roles of DevOps, Agile planning and Application Lifecycle Management (ALM) are putting new requirements on the automation needed in the modern build stack, while the rapid adoption of Hudson is making clear the central role of Continuous Integration (CI) as the hub of a Java application development and deployment. This panel will debate approaches to modernizing the build, CI and ALM infrastructure to help scale the productivity of development teams and leverage the latest array of build, test and deployment solutions.

"ALM Automation with Mylyn and Hudson"

Tues., Oct. 4, 2011, noon - 1 p.m. Pacific in Parc 55 - Divisidero

With the shift to PaaS and a new breed of open source ALM tools, the deployment loop of enterprise apps is going through its biggest transition since the creation of Java. Kersten will explore connecting the enterprise Java stack to cloud deployment via task-focused continuous integration based on Hudson. Distributed version control systems, code review and Agile planning, based on the Eclipse Mylyn interoperability platform, can be used to create a new level of connectivity and automation between the team and the running application. This talk outlines a roadmap for transforming productivity by connecting developers' desktops to the release, and automating all the steps in between, from provisioning the IDE to monitoring the running application.

WHERE: JavaOne 2011 booth (#5004)

San Francisco, CA

INFO: Tasktop is exhibiting at JavaOne in booth #5004. For more information and to arrange an interview with Mik Kersten please contact Christie Denniston at 303-581-7760 or by email at (cdenniston@catapultpr-ir.com).

TASKTOP’S MIK KERSTEN PRESENTS WEBINAR ON DEPLOYING TASKTOP SYNC TO UNIFY HETEROGENEOUS ALM STACKS

Tue, 27 Sep 2011 23:16:50 +0000

Webinar outlines how enterprise software organizations can integrate and synchronize heterogeneous ALM stacks to remove silos and improve collaboration and productivity

WHO: Mik Kersten - CEO and founder of Tasktop Technologies (www.tasktop.com)

WHAT: Synchronizing the ALM Stack for Enterprise Development Webinar

In modern application development and delivery, heterogeneous best-of-breed ALM stacks have become the norm. Driven by open source, outsourcing, remote development and testing, Agile tools, IT decentralization, and in larger organizations, mergers and acquisitions, tool fragmentation is here to stay. In today's competitive environment, there is little incentive for software vendors to provide more than check-box integration solutions, making it nearly impossible for organizations to gain traceability and visibility - from requirements to source code. During this webinar, Kersten will outline successful strategies and demonstrate how Tasktop Sync solves these challenges. He will show how Tasktop Sync connects development, QA, and Agile project management together through its industry-standard Eclipse Mylyn ALM integration framework. Unlike previous approaches to ALM synchronization, Tasktop Sync provides real-time synchronization, automated conflict resolution and support for more than two dozen ALM systems. Building on Tasktop's Task Federation^TM technology, Tasktop Sync ensures that each stakeholder has access to the data that they need within their tool of choice.

WHEN: Wed., Sept 28, 9 - 10 a.m. PST

INFO: To register for this webinar please visit: (http://tinyurl.com/3o4a5dw). Updates from the webinar will be available by following the live Twitter feed at #TaskSync. To learn more about Tasktop Sync please visit (http://www.tasktop.com/sync). To arrange an interview with Mik Kersten please contact Christie Denniston at 303-581-7760 or by email at cdenniston@catapultpr-ir.com.

TASKTOP EXECUTIVES TO KEYNOTE AND PRESENT AT JAX 2011

Tue, 03 May 2011 01:14:06 +0000

TASKTOP EXECUTIVES TO KEYNOTE AND PRESENT AT JAX 2011

In keynote, Kersten to explore Continuous Integration and how cloud computing is creating a shift in software development and lifecycle management

WHO:  Mik Kersten
CEO of Tasktop Technologies
  Creator of the open source Eclipse Mylyn project
  Tasktop Technologies
  www.tasktop.com

  Steffen Pingel
  Senior Software Developer
Tasktop Technologies
  www.tasktop.com

  Benjamin Muskalla
  Software Developer
  Tasktop Technologies
  www.tasktop.com

WHAT: The following presentations will be given at JAX 2011

Keynote - Mik Kersten
Task-focused Continuous Integration: Bringing Code to Cloud and Back Again
(May 3, 2011 - 8:15 p.m. - 9 p.m.)

The deployment destination for enterprise applications is going through its biggest transition since the creation of Java. Cloud infrastructure is changing the game for both application deployment and lifecycle management. Over the past decade, open source technologies such as Spring and Tomcat have defined how we build and run enterprise Java applications. Recent developments in open source collaboration Application Lifecycle Management (ALM) tools are now transforming how we evolve and manage those applications.

Kersten will explore connecting enterprise Java stack with cloud deployment via a task-focused continuous integration loop. The SCM, code review, and Agile ALM technologies, based on the Eclipse Mylyn ALM interoperability platform, will be used to demonstrate how to achieve this new level of connectivity and automation between the team and the application. The talk will conclude with a roadmap of how we can apply these new lessons to define the next decade of enterprise Java productivity.

Q & A: State of Continuous Integration - Mik Kersten
(May 4, 2011 - 5:30 p.m. - 6:30 p.m.)

The latest changes in the Hudson/Jenkins case cause quite a stir. But how important are these changes for Continuous Integration? What is the technical roadmap? Kohsuke Kawaguchi, Steffen Schluff, Mik Kersten and Björn Feustel will give some advice and answer your questions.

Git, Gerrit, Hudson and one Mylyn to Rule Them All - Steffen Pingel and Benjamin Muskalla
(May 5, 2011 - 11:45 a.m. - 12:45 p.m.)

Git, Gerrit and Hudson are being increasingly adopted. While these tools enable exciting improvements for developers, learning how to push, pull and fetch can be daunting. For tasks, Mylyn already streamlines workflow by providing first-class integration with the IDE. The recent project restructuring now enables the same integrated workflows for code reviews, builds and version control systems.

Mylyn 3.6: Agile, ALM and Task-Focused Continuous Integration - Mik Kersten
(May 5, 2011 - 2 p.m. - 3 p.m.)

A decade ago, heavyweight ALM tools did more to impede developers than to support collaboration. With the move to Agile methodologies, the time has come to embrace lightweight collaboration and social coding tools to increase our velocity. For many Java developers, Mylyn has become the tool of choice for connecting team communication with coding. In 2010, Mylyn became a top-level Eclipse project and grew to support the entire Application Lifecycle Management (ALM) stack. This talk will outline how Mylyn can double Java coding output by bringing the entire workday into the place where developers are most productive - the IDE. Demos will showcase how Mylyn's task-focused interface integrates all leading task and Agile tools, SCM tools such as SVN and Git, and build/CI tools including Hudson. We will then review productivity best practices learned from deploying Mylyn at scale both in open source projects and large organizations. The talk will conclude with a vision of how realigning collaboration around a unified notion of tasks can yield a measurable productivity and knowledge capture benefit across the entire organization.

WHERE: JAX 2011 - The Conference for Java, Enterprise Architecture & SOA
Rheingold Halle Mainz
Rhein Strasse 66
55116 Mainz
Germany

CONTACT: For more information or to set up an interview with Mik Kersten please contact Christie Denniston at Catapult PR-IR 303-581-7760, ext. 13 or (cdenniston@catapultpr-ir.com)

TASKTOP TECHNOLOGIES’ EXPERTS TO PRESENT LATEST MYLYN UPDATES AND BEST PRACTICES AT ECLIPSECON 2011

Wed, 16 Mar 2011 02:00:06 +0000

TASKTOP TECHNOLOGIES' EXPERTS TO PRESENT LATEST MYLYN UPDATES AND BEST PRACTICES AT ECLIPSECON 2011

Six presentations look at the continued adoption of open source development tools in the enterprise and how Mylyn drives ALM productivity

WHO: Mik Kersten
CEO of Tasktop and creator of the open source Eclipse Mylyn project

Neelan Choksi
President and COO, Tasktop

Benjamin Muskalla - software developer, Tasktop
Steffen Pingel - software developer, Tasktop

Tasktop Technologies
(www.tasktop.com)

WHAT: With Mylyn now a top level project within Eclipse there is continued innovation and thought leadership around the Tasktop task-focus interface and ALM integrations that are available through the Eclipse IDE. At EclipseCon 2011 in Santa Clara, CA, March 21 - 24, the following six presentations will be conducted by both Tasktop team members and contributors to the Eclipse Mylyn project.
Monday, March 21 13:30 - 13:50

Tired of CVS? Pimp your productivity with Git, Gerrit, Hudson and Mylyn
by Tasktop's Benjamin Muskalla and Tasktop's Steffen Pingel
Tuesday, March 22 14:00 - 14:20

The Mylyn Reloaded
by Tasktop's CEO Mik Kersten (and Chris Aniszczyk and Wayne Beaton)
Tuesday, March 22 14:30 - 15:10

The Business of Selling Free Software
by Tasktop's Neelan Choksi
Tuesday, March 22 19:30 - 20:30

Mylyn - Application Lifecycle Tools BoF
with Tasktop's Kersten, Pingel, Muskalla, and Choksi
Tuesday, March 22 10:40 - 11:00

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

Mylyn meets Intent : Documentation made fun and useful
by Cedric Brun

WHERE: EclipseCon 2011
Hyatt Regency Santa Clara
Santa Clara, Calif.

CONTACT: For more information or to set up an interview with any of the speakers listed above, please contact Christie Denniston at Catapult PR-IR 303-581-7760, ext. 13 or (cdenniston@catapultpr-ir.com).

Prediction #2: ALM tools become the gateway drug for hooking developers on cloud and PaaS

Fri, 11 Mar 2011 02:31:25 +0000

Prediction #2: ALM tools become the gateway drug for hooking developers on cloud and PaaS

by Mik Kersten, March 3rd, 2011

The productization of DOS by Microsoft in the 1980s kicked off the trend of platform vendors clamouring for developer mindshare. Apple's App Store may only generate 1% of the company's profit, but it drives the platform that sells Apple hardware. One of the best examples of the value of a developer platform is Microsoft's Visual Basic (VB), which is yet to see a rival in terms of breadth and pace of adoption. In 2010, VB ranked as the 5th most popular programming language on the Tiobe index, still well ahead of iOS's Objective-C. Microsoft's investment in developers goes well beyond paying homage to the company's roots, since Microsoft knows the sheer number of Windows license sales that can be attributed to each developer that they won over with VB.

Developers drive the success of platforms. Whenever a platform shift occurs, such as the shift from proprietary to open source or from desktop to mobile, interest in gaining developer mindshare is renewed. While we may all be overloaded with atmospheric-condition-related acronyms, we are in the middle of a fundamental shift in enterprise software platforms. The VMware hypervisor has replaced Dell blade server as the hot new technology. Application architectures are being transformed by REST-based services. Over the course of the year, support for multi-tenanting Java applications will result in more significant changes to the programming model that any of the incremental features coming in Java 7. The shift to cloud and Platform as a Service (PaaS) has ramifications beyond the change in the deployment model. One of the most important changes coming down the pipeline is the convergence of open source, PaaS and ALM. The continuous integration and delivery loop, becoming increasingly popular in Agile deployments, will put a new set of requirements on both ALM tools and the connection between the running application and the developer's workbench.

All of this is good news for developers. There will be an increase in competition, choice, and budgets which are dedicated to bringing developers to new application hosting destinations and PaaS solutions. Over the course of the year, early adopters of PaaS will help to harden these new offerings in order to get them ready for the on-premise and private cloud primetime. If you are an early adopter and running a greenfield project, you're bound to see some cool hosting and services thrown your way. But there are a few things you will need to watch out for when migrating to the bleeding edge. Beware the snake-oil pitch that moving your Java app into the cloud will be as easy as choosing a hosting provider. When migrating existing applications, you are likely to discover that achieving a scalable and cost effective architecture will involve significant efforts such as reconsidering your data storage, implementing multi-tenancy and porting the application to new ready-made services. This migration is similar to moving from a rural homestead to a downtown condo-it will take more than just a moving truck, your lifestyle will change, and you will spend less time worrying about your plumbing.

We have transitioned from thinking about applications as static entities that we build and deploy to living entities whose evolution is punctuated by releases and sprints. Given the turnkey automation promised by PaaS, developers will demand integration between the running application and the lifecycle tools used to manage it. This will drive one of the most important developer-centric trends in ALM, the convergence of application hosting and monitoring with ALM. The core ALM services of change management and continuous integration will become the hub between the developer's desktop and the running application, with tasks as the unit of abstraction. An application failure or problem will automatically create a defect that includes the application state that is related to the problem encountered. The product owner will schedule that defect into the appropriate sprint, and when the developer picks it up, all of the code relevant to the defect will be instantly retrieved from the SCM system and brought into focus. The commit of the fix will automatically spin up a build in a staging environment, deploy it, and then pass it on to production or Ops when tests pass. This future needs a new level or coordination between the core services of the ALM stack and PaaS offerings.

Vendors that tie together the programming model, frameworks, virtualization, hosting and ALM will be the winners in the battle for developer mindshare. To capture a meaningful snapshot of a hosted application, the runtime must understand the programming model. To present this to the developer, the IDE tools must be capable of be effective in displaying that information alongside the code. And at each step of the way, it's the ALM tools that will facilitate communication between the various stakeholders in the process: monitoring by Ops identifies a problem, that problem's state is captured in the issue tracker, the issue pops up on the developer's desktop, and then all subsequent changes are attached and captured on the corresponding task and reported in the build that was triggered. Workflows of this sort will require significant changes from ALM stacks, which have generally ignored the details of application build and deployment to date.

ALM services will also facilitate the migration of applications to the cloud. As we saw from the $212M acquisition of Heroku, supporting developer workflow provides a great on-ramp for application hosting. In the land of enterprise Java this is considerably more complex than a Git-based push and deploy of Ruby apps. But the need to bring this kind of simplicity to the Java application lifecycle is the same, and tasks provide the link necessary to scale continuous integration and delivery to large Java applications with a broader range of stakeholders ranging from dev, to Ops and QA.

Connecting the IDE to an ALM hub and using the hosted source and builds to drive deployment will provide a convenient on-ramp to application hosting offerings, and will significantly reduce the configuration and administrative burden currently placed on developers. While it can be fun to play around with configuring deployment environments and continuous integration servers, this level of busy work gets very tedious after a few months. A new level of automation is needed to help us focus on delivering application features and business value in the face of increasing platform complexity. Source, issue tracking and continuous integration will be a welcome gateway drug to cloud and PaaS application hosting. While having an app store claim 30% of all enterprise application revenues is not something we are likely to see this year, a Steve Jobs-like focus on turnkey simplicity of deployment and lifecycle management will help win the hearts and minds of developers making the move to the cloud.

To view more blog postings, please visit: (http://tasktop.com/blog/)

Click here to Watch Tasktop webinars

Prediction #3: Git and distributed version control invade the enterprise, widespread panic and benefits follow

Thu, 24 Feb 2011 21:55:58 +0000

Prediction #3: Git and distributed version control invade the enterprise, widespread panic and benefits follow

by Mik Kersten, February 23rd, 2011

Three years ago, in his presentation on the Git Distributed Version Control Systems (DVCS), Linus Torvalds provoked developers by declaring that "if you actually like using CVS... you should be in some mental institution." Since then, awareness of and discussion around both DVCS and mental health have grown rapidly. For many considering a migration to DVCS, discussions of trade-offs are filling coffee breaks. After the first migration steps are taken, the conversations get more heated and circle around getting DVCS best practices under control. For teams and organizations modernizing their ALM stack, this year will involve deciding whether to begin moving to a DVCS system. This post discusses the fundamental benefits that DVCS will bring to your Agile ALM stack, and identifies the gaps in tools and best practices that need to be addressed in order to avoid having the inmates get overly annoyed with the management of their asylum.

In 2009, the Eclipse Community Survey showed that 20% of respondents used CVS and 58% used Subversion (SVN), with CVS coming in at 24% for companies over 5,000 employees. While DVCS usage has been growing, the portion claimed by CVS and SVN has also grown in the 2010 survey. The mental model of CVS and SVN is entrenched for the average enterprise developer and builds on decades of the knowledge, tools and best practices that have built up around centralized version control. Tools built on top of CVS and SVN, such as the Eclipse and Mylyn team support, have also modernized these dated protocols and servers. But what the rapid rise of Git in open source has made clear is the limitations of traditional file-based change tracking and the centralized model for commit access control. The current adoption rate of Git is sufficient evidence that DVCS works and scales for open source development. The question then turns to how those benefits can be realized by your teams and organizations.

The key benefit of DVCS is that the collaboration rules and conventions captured by the version control system align with the trust network that forms organically between developers. The centralized version control model relies on component boundaries and restrictions on committer rights for managing the division of labour required for software configuration management (SCM) of complex systems. This perspective falls into the same trap as thinking that a modular, object-oriented decomposition of software is sufficient to manage the complexity of a large system. It is not. Dependency injection, aspect-oriented and declarative programming are key components of the modern programming model. In other words, concerns that crosscut the hierarchical decomposition of any large system need to be captured in order to evolve the implementation of that system effectively.

Tasks, whether in the form of user stories, features or defect fixes, are what define the planning and lifecycle management of large applications. Tasks crosscut the system's modularity by capturing the discussions between developers and end users around the software, not the API and component boundaries of the software. Aggregations of tasks into user stories, plans and releases drive the evolution of the software over time and define the boundaries that naturally form between developers. Centralized version control systems have focused entirely on changes and components, and ignored this more social dimension of coding. Managing a large system meant breaking a system into components and managing access control with commit rights. This aligned version control with the system's modularity, not with the way that developers work on the system in terms of experimenting with and collaborating on changes to the system. The crosscutting nature of developer collaboration and review activities needed to be captured and facilitated, and DVCS provides us just that.

In the video above, a visualization of directory structure corresponds to the modularity of the open Mylyn project. After watching the video for a few moments, we see that the activity of the developers themselves layers on top of the software's modularity and has a structure of its own. This structure corresponds to the tasks, change sets and patch reviews done by the Mylyn committers. By facilitating the common operations needed to support this workflow between developers, such as task-based branching and merging, DVCS changes the game by making it easy for developers to capture their activity within the SCM system itself rather than tracking it through external tools, or not capturing it at all. By expressing the collaboration, review and trust patterns common with open source developers, DVCS has fundamentally transformed SCM.

That's the good news. The bad news is that it will take the better part of this decade for many organizations to consume the benefits of DVCS. That timeframe may seem pessimistic given that some large organizations are already in the midst of deploying Git and Mercurial. But DVCS is a discontinuous innovation. It both provides a transformational benefit over centralized version control and requires a fundamental shift in developer practices that previously used a considerably simpler model. Consider the introduction of object-oriented programming (OOP). The core ideas were already baked in the 1970s, but it took decades and truckloads of books to turn the ideas into a scalable development practice in the enterprise. OOP introduced polymorphism and type hierarchies, neither of which supported the older style search and grep-based code navigation. A whole new breed of tool support needed to be created in order for developers to get a handle on navigating OOP system structure.

While the switch from centralized to distributed version control is a smaller paradigm shift than the switch from procedural to object-oriented programming, the scope of the change should not be underestimated. Problems will arise in three categories. First, the mental switch required from the average developer, accustomed to committing to the main line of the code with branches being few and far between, will be a source of friction and costly in terms of developer training. Second, tool support for discontinuous integrations tends to lag the initial deployments. For the near future, developers accustomed to full-featured graphical or IDE-based clients will find themselves back in the command-line when working with Git and Mercurial. Those with some muscle memory for command-line version control operations will still need to retrain their brains, since Git's command line options are more complex. Finally, the biggest challenge organizations adopting DVCS in 2011 will face is a lack of clear best practices. If you are launching a new project with the social dynamics of the Linux Kernel, you're all set and don't need to look beyond the best practices that Linus has forged. But if you are a medium or large organization, you will need to define the various practices around branching, merging, rebasing, reviewing and staging that are needed to effectively map tools like Git onto your development processes. The higher complexity of DVCS introduces a broader variability of best practices. Today we are using different Git practices for developing the Mylyn and the Tasktop codebases.

Organizations pushing the bleeding edge of Git adoption will discover that these problems cascade. Neither the change in developer mind-set nor best practices are encapsulated by the Git tool support available today. This means that many developers will struggle to get a handle on needing to gain a sufficient level of Git expertise and best practices, and these will have to be learned individually rather than being captured in the repeatable process provided by tool support. That approach scales to a few dozen motivated developers, but much less so with a few thousand. The top technical people at these organizations will invariably push for DVCS migration, provided they see the fundamental productivity benefits as attainable. But until DVCS is further along the technology adoption lifecycle, for most organizations the move must be made stepwise, starting with non-core and greenfield projects establishing the best practices and conventions. On Tasktop and Mylyn development we have migrated 1/5th and 1/3rd of the codebases respectively, allowing ourselves time to refine the best practices suitable for each of those, and add the EGit support needed for our developers and contributors to be productive.

By architecting version control around the social structure of the software development process, distributed version control has aligned the Agile and task-focused planning process with the versioning and change operations that we use to manage our software's history. Since both the task-focused and the DVCS movement have focused on the natural cadence of coding and developer collaboration, there has been convergent evolution between tools like Mylyn and Git. In the not-too distant future, the developer will activate a task, the appropriate Gerrit change or topic branch will be created, stashed when the task is deactivated, and a continuous integration build for the topic branch spun up, with failures percolated back to the developer's desktop as updates to the task. As DVCS best practices evolve, we will see more of this natural mirroring between the Agile planning loop and the DVCS mechanisms converging, lined up with tool-supported best practices.

Successful open source projects have a community and contribution driven planning loop, and can already reap the benefits of DVCS. But the enterprise software planning loop is more complex. In his dogmatic focus on open source software, when proclaiming that everyone using centralized version control was insane, Linus ignored the work required to bring the benefits of open source technologies to the software development community at large. The average developer's training needs to be accounted for, best practices for incorporating DVCS into the planning loop must be defined, and tool-based automation is needed to bridge the gaps.

Watch Tasktop webinars