Archive for the ‘Mik on Eclipse’ Category

New Tasktop Data product launched with Tasktop 4.0, unlocks Agile, ALM and DevOps

Monday, October 27th, 2014

From Galileo’s telescope to the scanning electron microscope, scientific progress has been punctuated by the technology that enabled new forms of measurement. Yet in the discipline of software delivery, robust measurement has been elusive. When I set out on a mission to double developer productivity, I ended up spending a good portion of my PhD first coming up with a new developer productivity metric, and then even more time implementing a tool for measuring it (now a core part of Eclipse Mylyn). Over the past few years, while working with the largest software delivery organizations in the world, I’ve noticed almost every one of them going through a similar struggle. All are looking for the best ways to scale or improve their software delivery via enterprise Agile frameworks and tools, DevOps automation technologies, and end-to-end ALM deployments. The problem is that nobody is able to reliably measure the overall success of those efforts because we are missing the technology infrastructure that allows for measurement across software delivery disciplines, methods and tools.

Register for Sync 4.0 and Data Webinar to learn more

With the launch of Tasktop Data we have a single goal: to unlock the data flowing through the software lifecycle. New measurement ideas have recently arrived on the market, ranging from the metrics backing the Scaled Agile Framework (SAFe) to methods for tracking cycle time through the DevOps pipeline originating from Sam Guckenheimer. There’s also no shortage of tools out there to allow you to visualize such data, ranging from generic Business Intelligence (BI) tools, to innovative new DevOps-specific reporting such as the IBM Jazz Reporting Service. The problem that’s plaguing any large-scale software delivery organization is that there’s simply no way to get at the end-to-end data to drive those metrics and reporting tools. Database-driven approaches such as ETL no longer work due to the fact that databases do not contain the complex business logic of modern Agile/ALM/DevOps tools, and are additionally inaccessible for SaaS solutions. Single tool approaches, such as Scrum or CI metrics, only work for one stage of the software lifecycle and cannot deliver end-to-end analytics such as cycle time. We need a new measurement technology in in order to take the next step in improving how software is built. That new technology is Tasktop Data.

Tasktop has created two key innovations that make Tasktop Data possible. The first is our semantically rich data model of the end-to-end software lifecycle. This is at the core of the Tasktop products and allows us to map and synchronize artifacts across the various tools and levels of granularity that define software delivery. The second is the massive “integration factory” that allows us to test all of the versions of all the leading Agile, ALM and DevOps tools that we support. With Tasktop Data, we are leveraging this common model and all our integrations, allowing organizations to stream the data that defines their software lifecycle to the database & reporting solution of choice. What makes this new technology even more profound is that we are exposing the models within the Tasktop platform, enabling software lifecycle architects to author the models that will drive their reports. The end-result is the real-time flow of clean lifecycle data flowing in to your reporting tool of choice. Running Enterprise Agile DevOps analytics and metrics that were previously impossible is now easy. Check out the demo above for a start-to-finish setup of Tasktop Data that connects Rally and HP ALM to Tableau in minutes. Then imagine this working for your entire tool chain, with your reporting solution of choice.

Tasktop 4.0 Connectors

Tasktop Data is being released as part of Tasktop 4.0, which includes significant updates across our entire product portfolio. The most notable is the fact that we’re releasing 6 new Sync connectors (BMC Remedy, GitHub, IBM Bluemix, Polarion ALM, Serena Dimensions RM and Tricentis Tosca) in addition to bringing Tasktop Dev up-to-speed with the latest developer tools (e.g., Eclipse/Mylyn Luna, Jenkins, Gerrit as well as commercial tools that leverage Dev such as HP Agile Manager).

We’re thrilled that the past 7 years of creating the de facto integration layer for software delivery is now materializing in a whole new way of measuring and improving how software is built. This is just the start of a new journey, as the most interesting aspects of data will arise from the way that our customers and partners leverage it in order to create unique and valuable insights in the software delivery process. For more information on how you can become a part of that journey:

Tasktop Sync 3.0 released, service desks get support

Tuesday, December 10th, 2013

Open source projects have it good. Their issue tracker serves as the single system of record for all development, support, quality management and planning activity. The result is a theoretical ideal in terms of a connected software lifecycle. For example, every vote that a user makes for a particular bug is immediately visible to developers. As soon as a new feature is added, users watching the corresponding task are automatically prompted to try the latest build and report back. This kind of real-time connectivity between users, developers and project leaders makes for an incredibly efficient build-measure-learn loop, which explains why so many open source project are able to deliver so much value so quickly. Having lived it day-to-day, it continues to inspire me in wanting to bring these benefits to software delivery in the large, where these benefits can make a tremendous difference.

Tasktop Sync 3.0: Defect Unification

The problem is that this open source project management approach doesn’t scale to the enterprise. It’s fine when you’ve got one stakeholder playing multiple roles. For example, on Mylyn I played the role of developer, product manager, tester, and support desk. I spent so much of my time triaging and commenting on bug reports that, in order to help me get through the tickets fast enough to have enough time for coding, I ended up adding features to Mylyn to make it work as a developer’s inbox for triaging tickets. The experience of other open source projects leads that I know is very similar, in that a tremendous portion of their time is spent triaging and responding to users. This direct touch with end users enables open source developers leverage the collective wisdom of their community so quickly.

However, the developer’s issue tracker does not scale to meet the demands of commercial software support, such the need for SLAs and ITIL processes. So a separate help desk tool is required, once that separation is made, real-time collaboration between the developer and support team stops, and reverts to inefficient channels such as email and meetings. The result is a chasm between the people who are user facing and those who are developing the application. The knowledge of the customer’s experience gets siloed into the help desk and voice of the customer gets diffused by the time that the next sprint planning session comes around. Given the increasingly primary role that the service desk plays in the software lifecycle, as evidenced by the amazing growth of ServiceNow, we need to fix this.

Tasktop Sync 3.0: ITSM

Our goal with Software Lifecycle Integration is to unify the ALM stack while allowing software stakeholders to use the systems that make them most productive. With today’s Tasktop Sync 3.0 announcement, we are very happy to reveal that the Sync bus now supports ITSM artifacts such as tickets and problems, and can connect service desk tools to the large and growing number of Agile and ALM tools that we support. Tasktop Sync makes it possible to extend the popular Defect Unification SLI pattern to the service desk, meaning that tickets matching specific criteria, such as those marked as problems, are automatically created as issues in the issue tracker or defects in the quality management system, and synchronized bidirectionally from that point on. For example, if the defect is Synced to IBM’s RTC, developers can schedule them onto a sprint, and the support team will instantly know that it has been assigned. And as soon as it’s completed, the workflow transition will happen on the service desk indicating that the fix is ready to review or deploy to the customer. Comments and activity streams are federated in real-time. And then it’s smiles all around.

We are launching two service desk integrations with Sync 3.0. Our integration for ServiceNow integration is fully certified by ServiceNow, and will support the many uses of the ServiceNow platform ranging across its ITSM and lifecycle capabilities. We are also launching support for Atlassian’s recently announced JIRA Service Desk, which builds on our comprehensive support of JIRA versions including the latest JIRA 6.1. And as usual, there will be more to come so please let us know what other support desks you would like to see integrated.

ServiceNow Visualizer

Connecting the help desk and bridging the task management gap between Dev and Ops is the most exciting Sync 3.0 news in terms of our mission to scale the efficiency of open source development to the enterprise software lifecycle. In other news, we’re releasing new template support for inheriting and extending mappings, making it dramatically easier to manage large numbers of of projects with different schemas. For those customers using Rally and Serena Business Manager, we’re very happy to announce the GA of those Sync connectors along with the Tasktop Dev connector for developers accessing Serena from Eclipse and Visual Studio. We’ve also extended the Sync bus to support time tracking federation between Agile and PPM, enabling time on task to flow between your Agile system and CA Clarity.

Sync 3.0: Example

Finally, the big news for both ALM vendors and customers is a beta program of the new Tasktop Connector SDK. You may think that SDKs should be old news given that Tasktop created and maintained the Mylyn SDK, which became one of the most extended SDKs on Eclipse. But it turns out that in order to support the real-time lifecycle bus architecture of Sync, an entirely new integration extensibility layer had to be created in order to support robust and easy-to-implement 3rd party extensibility. Along with it we created a bridge to support Mylyn connectors, so if you created one of those you’ll have a head start. If you’re interested in being an early adopter partner of the SDK, please get in touch.

Tasktop Sync 3.0 Bus

We’re thrilled that the tremendous customer demand that we saw for connecting the service desk ships today, and look forward to bringing the voice of the customer into the enterprise software lifecycle.

Want to learn more about Tasktop Sync 3.0? Register for an upcoming webinar:

When: Thursday, January 23rd, 2010: 12 noon ET
Presented by: Mik Kersten, CEO of Tastkop
Register now: Webinar – Introducing Tasktop Sync 3.0

Tasktop 2.8 released, Serena partnership announced, death to timesheets

Tuesday, August 6th, 2013

Filling out time sheets is about as fulfilling as doing taxes. This mind-numbing activity is an interesting symptom of what’s broken with the way we deliver software today. What’s worse than the time wasted filling them out is the fact that the numbers we fill out are largely fictitious, as we have no hope of accurately recalling where time went over a course of a week, given that we’re switching tasks over a dozen times an hour. As Peter Drucker stated:

Even in total darkness, most people retain their sense of space. But even with the lights on, a few hours in a sealed room render most people incapable of estimating how much time has elapsed. They are as likely to underrate grossly the time spent in the room as to overrate it grossly. If we rely on our memory, therefore, we do not know how much time has been spent. (Peter Drucker. The Essential Drucker, ch. 16. Know your Time)

Tracking time is not a problem. When done well it’s a very good thing, given that time is our most scarce resource. Done right, time tracking allows us to have some sense for what the burn downs on our sprints are, and to predict what we will deliver and when. It allows us to get better at what we do by eliminating wasteful activities from our day, such as sitting and watching a VM boot up or an update install.

Effective knowledge workers, in my observation, do not start with their tasks. They start with their time. And they do not start out with planning. They start out by finding where their time actually goes. (Effective Drucker, ch 16. Know your Time) (Peter Drucker. The Essential Drucker, ch. 16. Know your Time)

Drucker was a big advocate of time tracking systems for individuals. With Agile, we have now learned how effective tracking story points and actuals can be for Scrum teams. Yet all of this goodness feels very distant when the last thing that stands between you and Friday drinks is a time sheet.

What we need is a way to combine the benefits of personal and team-level time tracking with those needed by the Project Management Office (PMO). With the Automatic Time Tracking feature of Tasktop Dev (screenshot below), we validated a way to combine personal time tracking with team estimation and planning. I still use this feature regularly to be a good student of Drucker and figure out where my own time goes, and many Scrum teams use it to remove the tedious process of manually tracking time per task.

While that automation is useful for the individual and the team, it did not help the PMO, that works at the program, enterprise and product level. PMOs use specialized project and portfolio management software such as CA Clarity PPM. So now, in our ongoing effort to create an infrastructure that connects all aspects of software delivery and to keep people coding and planning to their hearts’ content, we have stepped out of the IDE in order to bridge the divide between the PMO and Agile teams.

The Tasktop Sync 2.8 release includes updates to the leading Agile tools, such as support for RTC 4, HP ALM, CA Clarity Agile and Microsoft TFS 2012. It also ships the first Sync support for Rally and the TFS 2013 beta. The other big news is that we now are announcing a partnership with Serena in which both Tasktop Sync and Tasktop Dev will be OEM’d as part of the Serena Business Manager lifecycle suite. This new integration, which further cements Tasktop’s role as the Switzerland of ALM, will be showcased at Serena xChange in September, and ship this fall.

With Tasktop Sync 2.8, we have finally managed to connect the worlds of Agile ALM and PPM both in terms of task flow, and time reporting. While the support currently works for CA Clarity only, integrating these two worlds has a been a major feat in terms of understanding the data model and building out the integration architecture for connecting “below the line” and “above the line” planning (Forrester Wave). For the individual, it’s like having your own administrative assistant standing over your shoulder filling out the PPM tool for you, only less annoying and easier to edit after the fact. For the Agilistas, it’s about getting to use the methods that make your teams productive while making the PMO happy. And for the organization, it’s the key enabler for something that Drucker would have been proud of: automating the connection between strategy and execution.

Software Lifecycle Integration (SLI)

Monday, March 25th, 2013

Disjointed tools have inundated the application lifecycle. At its roots, tool diversity is a good thing. Over the past few years, it has transformed the way software is built via Agile methods, open source tools and differentiating vendors. But it has also wreaked havoc on the decade-old promise of Application Lifecycle Management (ALM). We need a new kind of infrastructure to deliver on that promise in a world where developers get to choose the tools that make them most productive. The time has come for an integrated lifecycle bus that allows information to flow freely between developers, testers, business analysts and administrators. This infrastructure will enable us to connect the best offerings in ALM in order to create a Lean Software Lifecycle, and implement a build-measure-learn loop that connects business idea to app store, and back again. We need a set of common data models and architectural patterns. Most importantly, we need to establish the common artifact that will connect the lifecycle. We are calling the category of infrastructure that will enable this Software Lifecycle Integration (SLI).

When outlined on a whiteboard or diagram, the architecture of today’s ALM stack resembles a half-eaten bowl of spaghetti, with meatballs corresponding to the various tools selected by stakeholders. We have two choices, either find a way back to the homogenous and single vendor solution of the 1990s, or embrace heterogeneity and come up with an infrastructure that provides end-to-end collaboration and traceability across best-of-breed tools.

Not long ago, we witnessed a similar transformation of the app dev stack. Once the services, databases and app server space enabled heterogeneity, the middleware category materialized and the Enterprise Service Bus (ESB) emerged, along with the new title of “Enterprise Architect”. History doesn’t repeat, but it does rhyme. It’s now time to create the role of the Lifecycle Architect, and to define an architectural framework for connecting the software lifecycle. Just as the notion of services was key to enabling the ESB, and file and documents abstractions were to sharing data, we now need an abstraction to connect the software lifecycle and to create a Software Lifecycle Bus. That abstraction is the social task.

Today Tasktop is a kicking off an effort to bootstrap the SLI discipline, with a series of whitepapers discussing the technical architecture, common data model, and technical tools. We are proposing the Eclipse Mylyn m4 open source project as a home for collaborating on a de facto implementation of the SLI data model, which will leverage what has been learned from the adoption of Mylyn, integrations that build on it, and new efforts around the open standards of Linked Data and OSLC. Later this week we are also launching an SLI integration patterns catalog, based on existing input from our customers, and open for all to contribute to. By the end of the week, with input from key thought leaders present at the ALM Connect subconference of EclipseCon, we plan to release a first draft of the SLI manifesto. To learn more and to participate, see:

Whitepaper: Building the Business Case for Software Lifecycle Integration
Whitepaper: Software Lifecycle Integration Architecture
Software Lifecycle Integration landing page
Eclipse Mylyn m4 Project Proposal Draft
SLI Patterns Catalog Wiki (to come)


Learn more about SLI

Tasktop turns 6, plays well with others

Thursday, January 17th, 2013

January 17th marks the 6th anniversary of Tasktop’s inception, and has given me an opportunity to think about the past 6 years, and the next. All technological revolutions require a new kind of infrastructure. This decade will mark the shift to the software economy, with traditional companies turning into software delivery organizations. The problem is that, outside of ISVs who have glued together their own ALM processes, we’re not all that efficient at building software.

The generation before ours mastered building cars, managing just-in-time inventories of parts, as well as complex supply chains. And yet we’re still seeing software collaboration across companies and departments being done via spreadsheets and email threads, today’s equivalent of carrier pigeons. While the rest of the ALM industry sorts out the new generation of systems of engagement to make developers, Agile project managers and other stakeholders happy, Tasktop’s mission is to create the infrastructure that glues together this new breed of tools, with tasks as the new currency of planning and collaboration.

When staring out the window at our new Vancouver HQ, I often fixate on the orchestrated flow of cargo ships routing containers–the abstraction that has come to define the shipping industry. Rob Elves, co-founder of Tasktop, joins me in the picture below, as we were reflecting on our journey of the past six years. We validated the need for a layer of infrastructure between the developer and the various ALM servers by shoehorning it into the Eclipse desktop client and giving it a single and collaborative UI called Mylyn. That paved the way for our first commercial product, called Tasktop Dev, whose success was not just in laying our commercial foundation and revenues that drove our growth, but in allowing us to learn what a mess software development outside of the IDE really is. In our mission to connect the world of software delivery, the next step became overwhelmingly clear. A new infrastructure for connecting the software siloes within the organization, and increasingly across the chain of software suppliers, is now the bottleneck. Even the cars that previous generations learned to build so well now depend on dozens of software suppliers working together. Without automating the interaction between these suppliers in a way that supports collaboration and lean delivery across organizations, innovation is being stifled.

As Neelan reported in the Tasktop Year in Review, 2012 was huge for us with with 250% growth since our last birthday. A portion of the year went to thinking about what shape this new task “container” has in the software lifecycle. But it’s now clear that the problem is not the container, as the Mylyn model is nearly expressive enough, and our work with IBM in OSLC and W3C Linked Data is a good start to defining things like common query APIs. It turns out that the biggest gap is the lack of infrastructure for shipping this information between people and tools, and supporting the many previous attempts by each vendor in defining their own APIs specific to their specialization in the software lifecycle.

In 2012, Sync became the lifecycle integration platform of choice for numerous Fortune 100 companies. We got to learn what it was like to be building infrastructure and digging canals between vendors while becoming a mission critical component of the stack, which resulted in Sync’s transition to an enterprise-scale lifecycle integration bus. We’re looking forward to scaling this new kind of collaborative infrastructure in 2013, and making your software lifecycle as orchestrated as the flow of container ships through Vancouver’s magnificent harbor.

Deep inside an Eclipse Hackathon, where the future Eclipse submitters are born

Friday, November 16th, 2012

Eclipse Hackathon 2012 A room full of developers and students, cans of beer loosely scattered around the room, along with bags of chips, pop and pizza. It’s a setup that would make more sense for a party, were it not for everyone clustering around power cords and loud finger tapping of engineers ripping up their laptops.

Sticking to traditional hackathon culture, there was a whole lot of coding, lots of beer, and happy chit chat mixed with serious faces betraying some heavy problem solving, in a word: hackathon-fun!

Eclipse Hackathon 2012

In attendence: several experienced Eclipse submitters, students from SFU and UBC, and other Eclipse enthusiasts. Projects hacked on: JDT UI, Scripted, Orion and Mylyn (for project details see the wiki page).

Eclipse Hackathon 2012It was great to have Ian Skerrett from the Eclipse Foundataion attend and hack away with all the others. Great many ideas were thrown around and many a bug got fixed. Newbies got to learn a lot about Gerrit & Mylyn and how to contribute to open source. Thanx to all who attended and made the night that much better!

See more photos from the event.

Tasktop 2.4 released, requirements rejoice

Tuesday, August 14th, 2012

In Total Quality Management, the 1-10-100 rule states that prevention is 10x cheaper than correction, and 100x cheaper than failure in the field. We usually apply this principle to our thinking around defects and as a driver for continuous delivery and feedback loops. However, in much of the Agile discourse these days, the traditional requirement gets left behind.

Development has been transformed, from the bottom up by open source and inexpensive tools like JIRA, and from the project management level down by the Agile movement. But in large-scale software delivery involving very complex products and supply chains, requirements are the tasks that connect strategy to shipping software. The trouble is that the tools that we use for requirements management are completely disconnected from the modern Agile delivery process.

Consider a requirement to add a web service API to an app. Sounds great when expressed in Microsoft Word with direction from the CIO. After being passed to development, SOAP technology is selected on the merit of being present in other parts of the product line. A few developers comment on the corresponding user story that SOAP is inefficient and could cause serious CPU overhead, but both the business analysts (BAs) and the Ops folks are well out of the loop as they never log into JIRA where the discussion is happening. The solution is deployed, passes basic scalability tests, then after going into production it becomes clear that the SOAP solution will not scale to support the projected user base without a massive new infrastructure investment. So three months after the requirement was defined, the business analyst gets to realize all of this, learns a new acronym (REST) and another round of implementation is scheduled for the upcoming sprints. That’s the 100x cost scenario that we see all too often. Had the BA seen some of the comments in JIRA, a lot of waste could have been prevented.

This problem was partly addressed a decade ago with the Rational Unified Process (RUP), which created a homogenous Application Lifecycle Management (ALM) stack from requirements right down to development. But that approach constrained developers to the point where the Agile and lightweight ALM tool rebellion transformed the landscape. We now know that an efficient application lifecycle is capable of leveraging best-of-breed tools, with stakeholders such as Developers, Business Analysts, Project Managers and Testers working in the individual tools that make them most productive. Until today, only a few brittle point-to-point integrations existed between requirements management tools and the rest of the ALM stack. With today’s release of Tasktop Sync with integrations for IBM Rational Requirements Composer (RRC), IBM RequisitePro (ReqPro), CA Product Vision, and improvements to our existing integrations for HP ALM and QC Requirements Module as well as Accept 360, requirements are now a first class citizen that can span the lifecycle.

While the new support for sync’ing requirements is the biggest part of the story of our ongoing quest to connect the world of software delivery, there are many more highlights to the Tasktop 2.4 release, including major new features for ALM integration administrators such as a web dashboard for monitoring and IBM ClearQuest support. To learn more see:

Towards Lean ALM, with Dave West on Board

Thursday, April 26th, 2012

Every now and then you have a conversation that changes your view of the world. I’ve now had a dozen of those with one person, Dave West, in his role as Forrester analyst, VP, and Research Director. The common thread in our dialogue has been the need for application lifecycle glue that connects the software lifecycle stakeholders within the organization, as well as across the multi-company and increasingly open source based software supply ecosystem. Both of us realized that it would be more effective to make this vision a reality than to discuss it endlessly. So today, I’m thrilled to announce that we’ll be doing just that, with Dave West joining Tasktop as Chief Product Officer.

The very rapid growth that our products have seen lately is indicative of the need to look beyond any single tool in the evolving ALM stack, and consider the flow of information between the people that define the disciplines of the software lifecycle. Tasktop got to where we are today by placing a manic focus on the needs of the individual software developer, who was getting completely overloaded with the disconnected morass of ALM tools that failed to connect to the source code that defines delivery. That forced us to create a new model of social tasks that emphasized autonomy, transparency and integration across the increasingly diverse tool chain. With Tasktop Sync, our Task Federation has migrated from supporting Agile delivery on the developer’s desktop to connecting the rest of the software lifecycle in order to bring about a “Lean ALM”.

Driving a change in the way that software is built takes like-minded people filled with passion and purpose. Dave’s mission is to help people build software just a little bit better, and with our shared values, we expect that goal to materialize very quickly. In his role as an analyst, Dave has heard the software delivery needs and gaps of countless software organizations that build the products and services that we all rely on day-to-day. In his role as Chief Product Officer, responsible for transforming that need into our product vision and roadmap, you can expect Dave to accelerate our pace of customer-centric innovation even further as we work with our partners and open source community to connect the software lifecycle.

Read more in Dave’s post and Neelan’s post.

EclipseCon keynote: The Future of ALM – Developing in the Social Code Graph

Thursday, April 12th, 2012

EclipseCon 2012 was my favorite to date, and I’ve been attending since the prototype—beers and demos at Thirsty Bear during JavaOne 2002. What made it so interesting was finally getting all the Eclipse devs in the same space as key folks from Agile and ALM. Developers are the engine of the software economy. But that engine is becoming part of such a complex ecosystem of vendors and open source that to scale software delivery, we need to break down organizational and departmental silos. We need to move towards what Forrester analyst Dave West has coined a Lean ALM. And that’s what my keynote was all about. Connecting devs to project managers, to testers, and eventually to @DEVOPS_BORAT.

Some have objected to my statement that Linus Torvalds’ bigger contribution to our planet is going to be Git, not Linux. Yes, Linux is everywhere. But Linux was a creative imitation, whereas I was focusing on the true innovations that are moving us towards the social code graph, and that’s precisely where Git fits in. Also, early in the talk I mention that Eclipse has gone from 1.5M to 2.5M downloads between January 2011 and January 2012. That’s monthly downloads, and with Vietnam surpassing Germany, a clear sign of the times.

Watch the keynote here, and I look forward to hearing your feedback and ideas.

Running for the Eclipse Board of Directors

Wednesday, February 29th, 2012

For the past few years I have served on the Eclipse Board of Directors as an elected representative. I’m running again this year in the sustaining member category to help represent ecosystem of organizations that have made Eclipse successful, and to continue to refine the constructive dynamic that we have created in marrying commercial and community interests.


2012 marks the start of the second decade of Eclipse’s existence. I’ve been a committer on Eclipse for the past decade and have watched as an IBM initiative created a platform that now dominates the tooling space for professional developers outside working outside the VS/.NET stack. The leadership and innovation of Eclipse have created the modern pluggable IDE, innovated the code editing and navigation experience, fostered modern modeling technologies, and led the way in connecting the developer to the Agile, ALM and social coding movements. With the recent announcement of the VS 11 beta we’re reminded again that innovation can be cyclical. The first release of Eclipse from a dacade ago, visible above with its monochrome UI and toolbars, looks strikingly similar to latest version of VS 11 just announced (image from the Visual Studio blog).

While the strength of Microsoft is packaging a seamless end-to-end developer experience on a monolithic stack, the strength of Eclipse comes from the innovation driven by the large number of vendors leveraging Eclipse for gluing together the developer experience on heterogeneous stacks. For this next year of Eclipse’s evolution, both adapting the way that we build that tool stack in the social coding context, and improving ways to support our ecosystem of both community and vendor contributions, will be my priority if elected.

See my full vision statement on the Eclipse Board Elections page.