Application Lifecycle Management at Eclipse

the eclipse foundation has evolved a pretty impressive application lifecycle management story. based on what i’ve observed over the years, i believe that it’s completely reasonable to say that our alm story is one of the best in the world: the envy of hundreds of open source projects and closed source development shops around the world.

i believe that our success comes from a combination of great people, well-defined process, and a powerful stack of open-source tools.

we started from humble beginnings: issue tracking with bugzilla, cvs for source code management, pde build and ant scripts for build, cron for orchestration, and the eclipse development process for guidance. over time, all the the pieces have evolved resulting in the world-class whole that we have today.

process

the eclipse development process describes the structure of projects and teams at eclipse. it provides guidance to help projects run in an open, transparent, and vendor-neutral manner. it provides a framework for processes around releases and other important stages in project lifecycle (e.g. creation, graduation, and termination). from a process point of view, it’s a pretty high-level document that provides a framework for day-to-day work; individual projects, however, are given flexibility to decide how they run their day-to-day development.

eclipse projects have the benefit of the most comprehensive ip management and due diligence process available to open source projects. in fact–based on my experience working with many dozens of companies over the years–it is one of the most comprehensive ip management processes available to anybody.

ip management is important when you care about adoption of your open source project. adopters need to know that they can safely use the output of your open source project in their own projects and products.

tools

the tools story has evolved considerably since those humble beginnings.

we still use bugzilla for issue tracking. we have a second bugzilla instance, called ipzilla, that we use for tracking intellectual property contributions and use of third-party libraries.

and we’ve added a few new pieces:

subversion (svn) was added as an alternative to cvs for source code management, but both are now being phased out in favour of git . in fact, cvs is meeting its end-of-life at eclipse on december 21/2012 and subversion is no longer an option for new eclipse projects. moving forward, it’s git or nothing.

hudson provides build orchestration. as of eclipsecon 2012 , we have 337 build jobs that have run a total of 86,000 times on hudson: ninety-eight run daily, and 218 have run in the last month.

gerrit was recently implemented by our noble webmaster team to provide code review for projects that opt to use it. using gerrit streamlines the contribution workflow : contributors can push their commits directly to gerrit where project committers can quickly and easily process them. gerrit has a lot of very cool tricks including the ability to invoke hudson builds to confirm that new contributions will actually compile (hudson, in effect, gets a vote on whether or not a contribution should be accepted).

with the introduction and subsequent development of tycho –technology that lets maven understand and build eclipse plug-ins and osgi bundles– maven -based builds are quickly becoming the gold standard for eclipse projects.

tying it all together is, of course, eclipse. the mylyn project provides integration from eclipse to bugzilla (along with many dozens of other issue trackers), hudson, and gerrit. the egit project provides integration with git, and the m2e project provides support for maintaining maven build artifacts.

people

none of this would be possible, of course, without people. the implementation of git at eclipse was not a trivial matter. we had a lot of questions that needed to be be answered, and the eclipse committer community stepped up to help us answer those questions. there are similar stories for the other technologies that have been adopted at eclipse.

we’re still working on our maven story . like everything else at eclipse, this isn’t being driven from the top-down, but rather it is being driven by the developer community.

one of the most important things that keeps all this technology and process moving forward is communication. we have a strong ethic of transparent communication and open discussion across all 250+ eclipse projects.

of course people drive both the evolution of technology and process. the eclipse architecture council –a group of old and grizzled veterans of open source development–provides assistance to projects who are just learning the process, and are responsible for evolving the process as necessary. the eclipse development process is considered a living document and so is subject to change. we tweak and adapt our processes and practices on an ongoing basis.

no discussion of the eclipse alm story is complete without discussing the simultaneous release. the simultaneous release, which is coordinated by the eclipse planning council , is as much about people as it is technology. every year, many of projects join together to coordinate their development schedules and combine their releases into a single mega-event. this year’s juno release includes 71 separate eclipse projects and (total swag) 60 million lines of code.

the size of the simultaneous release has been growing over the years. something as massive as the simultaneous release can only happen with free-flowing lines of communication among developers working together with common goals.

evolution

are we there yet?

no. there is no “there”. the alm story at eclipse continues to evolve. it will always evolve. we still need to solve the maven question, and projects are pushing us into the continuous integration space. and there may be more changes ahead.

who knows what the future will bring?