Ten Years of Eclipse

Ten years ago today, an open-source Java development environment called Eclipse was released for both Windows and Linux. Eclipse 1.0 is still available for download for Windows (98/ME/2000/NT) and Linux (RH 7.1), along with translation packs (also provided by IBM).

The Eclipse consortium itself wasn't founded until 29th November 2001, and the Eclipse Foundation wasn't created until 2nd February 2004; so today marks the 10th anniversary of the initial release of the software rather than the organisation itself.

Eclipse 1.0 was the result of a $40 million valued donation of source code by IBM. Back at the turn of the millennium, there was a plethora of Java development environments available, such as Symantec VisualCafé, Borland JBuilder and IBM's own Visual Age for Java. However, as predominantly Java-only environments, they did not cope well initially with the advance of Servlets and HTML pages (and later, JSPs). In particular, IBM's Visual Age for Java used an object database to store source code instead of files; so it was not able to develop the nascent Enterprise Java applications that were becoming increasingly popular.

Pre-history

With the initial release of IBM WebSphere in June 1998 (at that time, just a Servlet engine), IBM needed a development tool to be able to complement its existing Java development tools. IBM developed WebSphere Studio to provide the HTML editing, released as far back as September 1998 with the combined release of WebSphere Studio 1.0 and WebSphere Application Server 1.1. WebSphere Studio would go on to form the foundation of Eclipse 1.0, and on 5th November 2001 was announced:

IBM's new WebSphere Studio tools are the first commercially available tools built on open source software, code-named Eclipse, which is being donated by IBM to a new community of software tool vendors. Developers working on WebSphere Studio and other Eclipse-based tools use a common, easy-to-use interface that provides a consistent "look and feel," regardless of vendor, which cuts training costs for customers.

At the time, IBM was losing developers from its flagship Visual Age for Java product. A new breed of development tools – such as Apache Ant, which was publicly released as version 1.1 in 19th July 2000 – operated purely on the Java source files. As a result, Visual Age was not able to take advantage of these or other tools built around creating dynamic websites. Other commercial tools were gaining in popularity, but each offered a slightly different interface and actions. Whether IBM's decision to release the core of WebSphere Studio as open source was driven by a means to increase familiarity with its commercial products, or whether it was a foresighted decision to enable greater collaboration between competitors, the release of Eclipse achieved two specific goals; it became a de-facto Java IDE and went on to become an organisation and tool chain supported by a multitude of different companies.

It's also worth acknowledging that Eclipse wasn't the first open-source IDE for Java; NetBeans was open-sourced in June 2000. However, whilst NetBeans was based on the less powerful (at the time) Swing, Eclipse was based on an entirely new widget toolkit that adopted the OS's own native widget set for displaying the user interface. Over time, this speed discrepancy has reduced; although SWT continues to provide better native integration than Swing renderings as operating systems have evolved.

The only other commercial Java development environment to survive from the period was IntelliJ, released in January 2001. All of the other significant commercial efforts either folded or moved towards running on an Eclipse runtime.

Eclipse Consortium

The Eclipse Consortium initially consisted of Borland, IBM, Merant, QNX Software Systems, Rational Software, RedHat, SuSE, and TogetherSoft. Initially released under the IBM created Common Public License, the platform initially focussed on the Java platform with code taken from the WebSphere Studio product, which itself grew out of Visual Age Micro Edition.

Visual Age for Java was both based on and implemented with Visual Age for Smalltalk. It was not until J2ME development with the re-implementation of Visual Age for Java as Visual Age Micro Edition that the toolset was re-implemented in Java, which went on to become WebSphere Studio and then Eclipse. Visual Age for Smalltalk was inspired by the Interface Builder in Nextstep. It's also worth noting that this was all done by the Ottwa-based Object Technology International, which was acquired by IBM in 1996, which is why many of the Eclipse committers, and indeed subsequent foundation, are based in Ottwa, Canada.

With Borland, Rational and other traditional Java developers behind Eclipse, it quickly took off, reaching an average 4000 downloads/day in the first month. (IBM would later go on to acquire Rational Software during December 2002–February 2003.) QNX aimed at the embedded market, and joined in to provide CDT 1.0 in March 2003, after less than a year's development. Today, Java still leads the development pack with CDT running a close second.

Eclipse Foundation

The Eclipse Foundation was launched on 2nd February 2004, a little under 2½ years after the consortium was created. This gave Eclipse a not-for-profit corporation, with an independent body of directors and ecosystem that supported a significant number of both strategic partners and add-in providers. This creation demonstrated that even with the dot-com bubble burst and other problems of 2001, the Eclipse foundation was growing in size and membership.

The creation of the Eclipse Foundation led to the introduction of the Eclipse Public License. This, combined with Eclipse 3.1's release in 2005 and the growth to 100 member organisations helped to underline Eclipse's early growth, less than four years after it was announced.

The CPL would remain a part of Eclipse until 25th February 2009, when after failing to convince all contributors to re-assign from CPL to EPL, IBM assigned the Agreement Steward for the CPL to the Eclipse Foundation, who promptly then designated the EPL 1.0 to be the follow-on version of the CPL 1.0. As a result, all Eclipse CPL software was able to be transitioned fully to EPL under the existing rights.

EclipseCon

Perhaps more than anything, the launch of EclipseCon, in Anaheim during February 2004 has been an indicator that Eclipse is more about the ecosystem than any one software product. The inaugural EclipseCon was the place where the creation of the Foundation was announced, and has been an annual conference ever since. In 2005 it was located in the Hyatt Regency in Burlingame, and from 2006 to 2011 the conference was held in the Santa Clara Convention Centre. With 2012, EclipseCon has moved to Reston, Virginia.

Whilst NetBeans didn't have its own conference – being covered at various times at Sun's JavaOne – the NetBeans Girls made a singular appearance at EclipseCon. Despite a bug being raised they were not seen again.

The success of EclipseCon in the United States gave rise to October 2007's Eclipse Summit Europe in Ludwigsburg, Germany and subsequently turned into an annual event for 2008, 2009 and 2010. For the recently-finished 2011 session, the conference was renamed from Eclipse Summit Europe to EclipseCon Europe.

The EclipseCon conferences allowed otherwise competing companies to meet on neutral territory and discuss in person improvements and future plans for open-source projects, as well as providing a means to distribute news and announcements for the Eclipse ecosystem.

Release Trains

No retrospective would be complete without looking at the benefits of a consolidated release train has brought to the platform. Although Eclipse has promised (and delivered) reliable software releases over a decade, it was the introduction of the release trains with Callisto in 2006 that brought them all together. Until that point, the base project (consisting of the Java development tools and the Rich Client Platform) was the only main download, and other plugins had to be added piecemeal together. Unfortunately, slight inconsistencies meant that this was a challenge at best; some of the releases simply needed newer bug-fixes than were available via public downloads, and getting a correct working combination together proved problematic.

The creation of the release trains – named initially for moons of Jupiter – started following an alphabetic progression after the release of Ganymede and Gallileo in 2008 and 2009 respectively. To provide a more consistent ordering, Helios followed on in 2010 and Indigo in 2011. (Next year's release will be named Juno.)

The planning of the releases (and trains) follows a strict schedule, which owing to its agile roots, maintains a consistent time whilst allowing the content to be managed. As a result, the software has been delivered on time and on plan, every year, over the last decade:

The Juno release plan calls for the simultaneous release to happen on or around 27th June 2012; if past history is anything to go by there should be no doubt that this target will be met.

OSGi and modularity

Eclipse always had a plug-in model, going back to Eclipse 1.0, and it was designed around the ability for companies to be able to plug-in components that were either open-source, commercial, or a mixture of both. Other IDEs also had plug-in models; both NetBeans and (subsequently) IntelliJ had the ability to add external components in to the main application. Unlike IntelliJ (which has a distinction between code that makes up the IDE and plug-ins which extend it), Eclipse has always been designed with modularity in mind.

It was in 2004 with the release of Eclipse 3.0 that Eclipse really changed an entire industry. It changed its self-built modularity system to one that ran upon a little known framework called OSGi, which was an acronym at the time:

Eclipse was adapted to add support for the OSGi (www.osgi.org) framework specification when constructing functionally extensible applications. This open standard for plug-in extensions supports installation and dynamic activation under program control, permitting fine-grain conservation of resources like memory in complex integrated tools and client environments. In addition, the Eclipse Plug-in Development Environment now supports component integration for platforms that incorporate very large numbers of plug-ins.

This openness and scalability allowed Eclipse to grow much larger than before, as well as propelling OSGi into the limelight and attracting a whole swathe of developers. Unlike the ill-fated JSR 198: a standard API for IDEs, OSGi went to power the core of all Eclipse-based IDEs and now powers all of the major JavaEE application servers. With the ability to dynamically add new modules as well as being able to replace existing models on the fly, OSGi has been to places that it would never have otherwise reached thanks to Eclipse's choice of runtime seven years ago.

As a by-product of that symbiotic relationship, the annual OSGi DevCon is co-located with EclipseCon. The Eclipse 'kernel' (Equinox) has even been moved into its own top-level project (EclipseRT) where it joins forces with other runtime based tools for IDEs and headless server programs alike.

Modelling, Mylyn and More

The Eclipse Foundation has also become home to a number of projects which were unlikely to have been envisioned when Eclipse was first released.

The top-level Modelling framework has become both a de-facto core implementation of UML tools as well as a fertile research ground for new technologies, such as graphical modelling and model based development.

Mylyn brought a way of focussing the IDE's otherwise limitless scrolling lists to just show semantically interesting components at one time, but has gone on to become the integration point for open-source and commercial issue tracking tools alike. It has since branched out into code review tools (such as Gerrit) and aims to become the de-facto application lifecycle management tool suite.

Xtext provides a parser generator tool with built-in support for creating an IDE that is co-hostd within Eclipse. A recently launched website, www.xtend-lang.org demonstrates a language built with Xtext. When the source file is saved, Java code is automatically generated and compiled, which allows introspection and debugging when issues arise.

BIRT provides business intelligence and reporting tools, and forms the open-source core of Actuate's commercial product. The reporting tools allow charts to be generated and reports created automatically based on configured data sources.

There are many more projects in the Eclipse foundation; at the last count, over 170 member companies spanning 270 projects with over 1000 committers all contribute to the 50 million lines of code under Eclipse Foundations stewardship.

The next ten years…

If Eclipse has made this much of a difference over the past decade, what of the next decade? Clearly the foundation has something right – a place where commercial products can be built whilst being based on solid IP guidelines. But it's likely to be the unpredictable changes, such as the move to OSGi, that create the biggest impact.

The next release of Eclipse will be moving towards e4, a way of building UIs declaratively and styled with CSS instead of having to be coded explicitly. Although Juno will be shipped (as Indigo did) with both e4-based and 'traditional' based UIs, Juno will be the first Eclipse train release to use e4 by default.

This also highlights one other key strength of Eclipse, which is to bend over backwards to be backward compatible with previous releases; other than a handful of issues mentioned in the plug-in migration guide. It is expected that the majority of plugins developed for 3.7 will be able to run in e4-based Eclipse installs.

The other significant change since Eclipse's initial release is that of the web development. With the increasing popularity of AJAX typified with Google Maps' release in Feburary 2005, it has been a challenge to find what the next evolution of IDEs will be. One such avenue is Eclipse Orion, a web-based editor for the web.

Finally, languages and source code control systems evolve and therefore so do the editors themselves. When Eclipse was first released, it lived in a CVS server where some of its code still resides today. The advent and adoption of SVN resulted in newer projects starting there, but it was with the adoption of Git that started this year that the number of both CVS and SVN repositories are dropping at Eclipse. As the number of projects in Git grows, and are mirrored to social hubs like GitHub, it has become easier than ever for others to contribute to projects at Eclipse.

Finally, as new languages come into vogue – whether Scala, Groovy, (J)Ruby, Kotlin or Ceylon – and are built upon new platforms – Android/Dalvik or Dart/Go in the future – Eclipse has been a cornerstone of the IDE world and will continue to offer a high starting point for any new system.

However, it is likely to be creations that can't be predicted, such as the move to OSGi or the creation of Mylyn, that have the biggest impact in the future.