<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">

<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
<title>2013 Annual Eclipse Community Report</title>

</head>

<body lang="EN-US">

<div id="maincontent">
	<div id="midcolumn">
	
		<h1>2013 Annual Eclipse Community Report</h1>
		<br/><strong>Published June 2013</strong><br/><br/>
		
<p>Welcome to the second annual Eclipse Foundation Community Report.
Comments and feedback on the style and
content would be appreciated at <a href="mailto:emo@eclipse.org">emo@eclipse.org</a>.</p>
<p>Other than the financial information, this report will cover the
period April 1, 2012 to March 31, 2013. 
</p>
<h2 class="western">Who We Are</h2>
<p>Our Bylaws define the Eclipse Foundation in this way:</p>
<p style="margin-left: 2cm"><i>The Eclipse technology is a
vendor-neutral, open development platform supplying frameworks and
exemplary, extensible tools (the &quot;Eclipse Platform&quot;).
Eclipse Platform tools are exemplary in that they verify the utility
of the Eclipse frameworks, illustrate the appropriate use of those
frameworks, and support the development and maintenance of the
Eclipse Platform itself; Eclipse Platform tools are extensible in
that their functionality is accessible via documented programmatic
interfaces. The purpose of Eclipse Foundation Inc., (the &quot;Eclipse
Foundation&quot;), is to advance the creation, evolution, promotion,
and support of the Eclipse Platform and to cultivate both an open
source community and an ecosystem of complementary products,
capabilities, and services.</i></p>
<p style="font-style: normal">This makes the Eclipse community a
unique open source community. Not only are we interested in building
open source code, we are equally committed to creating a commercially
successful ecosystem around that code. This combination of interests
has been a key part of Eclipse's success.</p>
<p>In short, our vision for the Eclipse community is:</p>
<p style="margin-left: 2cm"><i>To be the leading community for
individuals and organizations to collaborate on commercially-friendly
open source software </i>
</p>
<h2 class="western">Strategy</h2>
<p>The following are the strategic goals of the Eclipse Foundation
for 2013, as set by the Board of Directors.</p>
<ol>
	<li>Be the developer platform of choice. 
	The goal of Eclipse is to define a development platform that
	is freely licensed, open source and provides support for the full
	breadth of the application lifecycle, in many disparate problem
	domains, and across the development and deployment platforms of
	choice, including both desktop and the web. At least since 2004,
	Eclipse projects have been shipping innovative runtime technologies
	such as Equinox and the Rich Client Platform. The last several years
	have seen steady growth in runtime technologies at Eclipse. At the
	same time, there has been rapid growth in interest in OSGi, which is
	the standard upon which the Eclipse plug-in model is based. Moving
	forward, we expect to see rapid growth in both the projects building
	and the adoption of Eclipse runtime technologies. 
	</li>
	<li>Advance Eclipse technology on high-growth platforms such as web, 
	cloud and mobile. 
	This is not just about the IDE for which Eclipse is
	famous. Rather, this goal is about growing the portfolio of 
	technologies being built within the Eclipse community. Examples
	of new projects which are helping to address these goals include
	<a href="/orion/">Orion</a>,
	and our <a href="http://m2m.eclipse.org">machine-to-machine</a> projects.
	</li>	
	<li>Create value for all its membership classes. 
	The Eclipse Foundation serves many members whose
	primary interest is leveraging Eclipse technologies in commercial
	offerings such as products and services. The Eclipse Foundation will
	focus its energies to ensure that commercial opportunity exists
	within the Eclipse ecosystem. Look for continuous improvements to
	Eclipse Marketplace, and for other initiatives that benefit members.<br/><br/>
	Committers are also members of the Eclipse Foundation and are in
	many ways its backbone. The Eclipse Foundation and its staff will
	continue to look for opportunities to improve services to its
	project community throughout the year. Look for enhancements to our
	web, download, code management, build and other key components of
	project infrastructure in 2013. 
	</li>
	<li>Foster growth of the ecosystem, particularly in verticals. 
	The creation of a large community of
	commercial and open source organizations that rely on and/or
	complement Eclipse technology has been a major factor in the success
	of Eclipse. Each time Eclipse technology is used in the development
	of a product, service or application the Eclipse community is
	strengthened. Our goal in 2013 is to continue to focus our attention on the
	creation of  working groups and new Eclipse projects that
	focus on particular industry segments such as aerospace, automotive,
	and finance. 
	</li>
	<li>Continue to grow a diversified revenue model. 
	Reliance on a
	single source of revenue to fund the Foundation puts us at greater
	risk of being negatively impacted by industry specific business
	cycles. It is a goal of the Eclipse Foundation to ensure revenue
	sources from multiple types of organizations, and seek other sources
	such as events and sponsorships. 
	</li>
</ol>
<h2 class="western">Some Key Decisions</h2>
<p>Over the past year, the Board has made a number of strategic
decisions that will impact how Eclipse evolves in the future. A brief
summary of these is listed below. More details can be found in the
<a href="http://www.eclipse.org/org/foundation/minutes.php">minutes</a>
of the Board, found on our website.</p>
<ul>
	<li><b>Signing the Oracle TCK Agreement:</b> After a long
	process, the Eclipse Foundation signed the Java TCK agreement, allowing
	Eclipse projects who require access to TCKs the ability to acquire them.
	The process of doing so is going to be tightly controlled, as the
	TCK licenses do place a number of encumberances on opens source
	projects.<br/><br/>
	For a project to request access to a Java TCK, it must meet the 
	following criteria:
	<ol>
	<li>The Project PMC has publicly discussed and approved a Projectâ€™s request for TCK access, and requests access from the EMO;</li>
	<li>A Strategic Member supports the Projectâ€™s desire to use the TCK; and</li>
	<li>The Board has approved the use of the TCK by the Project by a super-majority vote of the Board.</li></ol>
	To date, the EclipseLink and Virgo projects have been approved by the Board to request TCKs. 
	</li>
	<li><b>Implementing Contributor License Agreements:</b> Historically, the 
	Eclipse Foundation's projects have not relied on Contributor License Agreements (CLAs)
	to ensure that we acquired all of the rights necessary to accept a contribution. 
	Instead, the project committers would ask each contributor three questions 
	regarding the provenance of their contributions. However, as the Eclipse community
	moved to git, and adopted code review tools such as Gerrit, it became increasingly
	clear that this process was impeding contributions. Accordingly, in 2013 the 
	Eclipse Foundation will be <a href="/legal/CoO.php">implementing CLAs</a> for it's contributors.
	<br/><br/>
	At the same time, the Eclipse Foundation will be implementing the use of 
	signed-off-by for contributions made via git, and has published a 
	<a href="/legal/CoO.php">Certificate of Originality</a> which documents
	what the use of signed-off-by means for contributors.
	</li>
	<li><b>Reviewing the Eclipse Public License:</b> The Eclipse Public License
	was drafted some 15 years ago. The Board has decided that it will ask
	the Eclipse and open source communities for feedback on how the license could
	be improved and updated. A transparent and community-led discussion will commence
	in 2013.
	</li>
</ul>
<h2 class="western">Financials</h2>
<p>The Eclipse Foundation's fiscal year end is December 31. Our
auditors are the firm Deloitte &amp; Touche, LLP. The Eclipse
Foundation is incorporated in the State of Delaware, USA as a 501(c)6
not-for-profit. Its headquarters is located in Ottawa, Canada.</p>
<p>2012 was another solid year financially for the Eclipse
Foundation. Google raised their membership level to Strategic
Developer, website advertising continues to be strong, and working
group revenue continues to grow. Despite originally budgeting a $0.3M
loss, the Eclipse Foundation lost only $0.1M, and was able to
contribute to its cash reserves. The organization continues to be on
a solid financial footing.</p>
<p>A summary of the past three years of audited financial results
are contained in the table below.</p>
<table WIDTH=370 BORDER=0 CELLPADDING=4 CELLSPACING=0>
	<col width=80>
	<col width=80>
	<col width=25>
	<col width=80>
	<col width=25>
	<col width=80>
	<tr valign=top>
		<td width=80 HEIGHT=34>
			<p><font size=3>In US $ millions </font></p>
		</td>
		<td width=80>
			<p style="text-align:right"><font size=3>2010 </font></p>
		</td>
		<td width=25>
			<p style="text-align:right"><br/>
			</p>
		</td>
		<td width=80>
			<p style="text-align:right"><font size=3>2011</font></p>
		</td>
		<td width=25>
			<p style="text-align:right"><br/>
			</p>
		</td>
		<td width=80>
			<p style="text-align:right"><font size=3>2012</font></p>
		</td>
	</tr>
	<tr valign=top>
		<td width=80>
			<p><font size=3>Revenue</font></p>
		</td>
		<td width=80>
			<p style="text-align:right"><font size=3>4.0</font></p>
		</td>
		<td width=25>
			<p style="text-align:right"><br/>
			</p>
		</td>
		<td width=80>
			<p style="text-align:right"><font size=3>4.1</font></p>
		</td>
		<td width=25>
			<p style="text-align:right"><br/>
			</p>
		</td>
		<td width=80>
			<p style="text-align:right"><font size=3>4.1</font></p>
		</td>
	</tr>
	<tr valign=top>
		<td width=80>
			<p><font size=3>Expenses</font></p>
		</td>
		<td width=80>
			<p style="text-align:right"><font size=3>4.1</font></p>
		</td>
		<td width=25>
			<p style="text-align:right"><br/>
			</p>
		</td>
		<td width=80>
			<p style="text-align:right"><font size=3>4.0</font></p>
		</td>
		<td width=25>
			<p style="text-align:right"><br/>
			</p>
		</td>
		<td width=80>
			<p style="text-align:right"><font size=3>4.2</font></p>
		</td>
	</tr>
	<tr valign=top>
		<td width=80>
			<p><font size=3>Net Income</font></p>
		</td>
		<td width=80>
			<p style="text-align:right; border-top: 1.00pt solid #000000; border-bottom: 2.60pt double #000000; border-left: none; border-right: none; padding: 0.05cm 0cm">
			-0.1</p>
		</td>
		<td width=25>
			<p><br/>
			</p>
		</td>
		<td width=80>
			<p style="text-align:right; border-top: 1.00pt solid #000000; border-bottom: 2.60pt double #000000; border-left: none; border-right: none; padding: 0.05cm 0cm">
			0.1</p>
		</td>
		<td width=25>
			<p><br/>
			</p>
		</td>
		<td width=80>
			<p style="text-align:right; border-top: 1.00pt solid #000000; border-bottom: 2.60pt double #000000; border-left: none; border-right: none; padding: 0.05cm 0cm">
			-0.1</p>
		</td>
	</tr>
</TABLE>
<h2 class="western">Membership</h2>
<p>The Foundation finished 2012 with a total of 186 members. By the
end of March 2013, that number had increased to 190. Some of the companies
who joined in the past year include: Architexa, Checkmarx, Combitech, Coverity, 
DevBoost, Eucalyptus Systems, HP, Intecs, Itpearls, Lucierna SL, OpenGeo, 
and WireframeSketcher.
</p>
<p><IMG SRC="../../../images/reports/2013_AR_membership.png" NAME="Membership" ALT="2013 Membership Numbers" ALIGN=BOTTOM WIDTH=600 HEIGHT=409 BORDER=0>
</p>
<h3 class="western">Long Term Support</h3>
<p>An important new program for Eclipse Members was launched in 2012. The 
<a href="http://lts.eclipse.org/">Long Term Support</a> initiative is intended to:
	<ol>
		<li>Enable organisations to collaborate when providing support and maintenance for Eclipse technologies.</li>
		<li>Enable support and maintenance of Eclipse technologies for Long Term (years) and Very Long Term (decades) durations.</li>
	</ol>
</p>
<p>Fundamentally, LTS is intended to save time and resources for companies who 
have built Eclipse-based products, and require the infrastructure to support and 
maintain those products. Historically, building and fixing older Eclipse releases 
has been a difficult task. Worse, each company with this need was required to 
develop the necessary skills and processes necessary on their own. The goal of 
the LTS working group is to provide a single, shared service to make it easier 
to support and maintain older releases of Eclipse technologies that are embedded 
in commercial products.
</p>
<h3 class="western">Working Groups</h3>
<p>As the Eclipse community has grown, it has become clear that there is
a lot of demand for the Eclipse "style" of open source development, where there 
is a significant focus on enabling a commercial ecosystem as well as 
developing code. This has given rise to the <a href="../../industry-workgroups/">Eclipse Working Groups</a>, which
are separate, identifiable communities of interest with their own consortium
and projects. In some cases, working groups maintain their own separate forge,
website, and brand. However, all working groups operate under the the 
auspices of the Eclipse Development Process and Intellectual Property Policy
of the Eclipse Foundation.
</p>
<ul>
	<li><b>Automotive: </b>Innovation
	in the automotive industry is mostly achieved by electronics and
	software functions. The system automobile is becoming increasingly
	complex, an open developer tool workbench that extends throughout
	the supply-chain is becoming a must for the industry. Improvements
	and innovations to these software development tools are required to
	accelerate product development, create high quality software
	features and improve integration across the automotive supply chain.<br/><br/>
	In the past year, the <a href="http://wiki.eclipse.org/Auto_IWG">Eclipse
	Automotive Working Group</a> has been defining and releasing its own
	package for Automotive Software Developers. This release provides a
	stable platform for tool providers in the domain to build on. Other
	projects of the group target build enironments, tools certification
	processes and extensions for various other tools. The group has
	currently 9 members, including BMW Group, Continental AG adn Robert
	Bosch GmbH.</li>
	<li><b>LocationTech:</b> The <a href="http://locationtech.org/">LocationTech working group</a> is focused on 
	enabling broaden adoption of location aware technologies. The group has 
	chosen 4 areas of focus to start:
	<ul>
		<li>Storage and processing of massive data volume</li>
		<li>Model driven design</li>
		<li>Desktop, Web, and mobile mapping</li>
		<li>Real time analysis of business critical data</li>
	</ul>
	The LocationTech working group launched 
	February 5th, 2013 and continues to grow and demonstrate increasing momentum. 
	Founding Strategic members include IBM, Oracle, Actuate, and OpenGeo. 
	Participating members include OSGeo and Carleton University's Geomatics 
	and Cartographic Research Centre. There were 4 projects and proposals in place 
	for launch. 
	</li>
	<li><b>Machine-to-Machine (M2M):</b> The Eclipse <a href="http://m2m.eclipse.org">M2M Working
	Group</a> has made significant progress in developing a platform of
	frameworks, protocols and tools for building M2M applications. There
	are now 3 active Eclipse open source projects that target the M2M
	industry: 1) Koneki provides Lua development tools, 2) Paho provides
	open source reference implementation of the MQTT client and 3)
	Mihini provides frameworks for device management.  Eclipse is also
	participating in the OASIS Technical Committee to standardized the
	MQTT protocol. The active members of the M2M WG are Sierra Wireless,
	IBM, Eutrotech and Axeda. 
	</li>
	<li><p><b>Polarsys: </b><SPAN STYLE="font-weight: normal">The
	goal of <a href="http://polarsys.org/">Polarsys</a> is to build and
	maintain an open source tools chain that is used by organizations
	building safety-critical and software intensive embedded systems.
	Industries such as aerospace, defense, transportation,
	telecommunications, energy and healthcare require development tool
	chains with a number of specific requirements, including very long
	term support and maintenance requirements.</SPAN></p>
	<p><SPAN STYLE="font-weight: normal">In the year after its creation
	Polarsys has issued its first roadmap and is currently working on
	the first release of the Polarsys IDE which is due in October 2013.
	Aside from that, other projects have been started by the POlarsys
	members. The current member list consists of Airbus, CEA List,
	Ericsson, Thales, Atos, Intecs, Obeo, Combitech and SoyaTec.</SPAN></p>
</ul>
<h2 class="western">Conferences and Events</h2>
<p>No description of the Eclipse Foundation's activities can fail to
mention our community's successful conferences. EclipseCon and
<a href="http://eclipsecon.org/europe2012/">EclipseCon Europe</a>
were both enormously successful. Both events were beyond our
expectations with regard to participants, sponsors, and positive
attendee feedback. As but one sample metric, the EclipseCon Europe
2012 attendees gave the conference an overall rating of 1.77 (1 =
&ldquo;Excellent, 2 = &ldquo;Very Good&rdquo;), the highest rating of
any conference we've ever run. New in 2013 will be our first
<a href="http://eclipsecon.org/france2013/">EclipseCon France</a>.</p>
<p>The EclipseCon conferences, <a href="http://wiki.eclipse.org/Eclipse_Day">Eclipse
Days</a> and <a href="http://wiki.eclipse.org/Eclipse_DemoCamps_Kepler_2013">DemoCamps</a>
are the primary events that the Eclipse Foundation supports to help
foster the strong personal relationships in the community that only
face-to-face contact can create. We highly encourage all Eclipse
community participants to participate in these events.</p>

<h2 class="western">Intellectual Property Management</h2>
<p>During the time period spanning April 1, 2012 to March 31, 2013,
the Eclipse Foundation received 920 requests for code review and
completed review of 740 requests.   Resource constraints in the
Intellectual Property (IP) arena were alleviated this past year with
the hiring of Pablo Jacubovich who joined the IP Group as an
Intellectual Property Analyst.   
</p>
<p>The addition of Pablo to the IP Group, together with a lower
volume of requests for code review for the Kepler simultaneous
release (27) as compared to Juno the previous year (136) enabled the
IP Group to reduce the backlog of code review requests to an all time
low. As of the time of this writing, the backlog of requests for code
review stands at 70.</p>
<p>With increased activity in the Working Group arena and larger
pre-existing open source projects moving to Eclipse, it is expected
that we will see a rise in the backlog of requests for code review in
the coming year and modest increases in turnaround time for requests
for code review.  Due to the modest growth anticipated, no further
hiring is expected in the IP Group in 2013.    
</p>
<h2 class="western">Innovation</h2>
<p>The past year has seen an enormous amount of innovation within the
Eclipse community. 
A few key projects and technology areas are listed
below, with comments on both their recent past, and their future
direction. This is certainly not intended to be exhaustive, but will
hopefully provide some of the highlights of the exciting technologies
being built by the Eclipse community.</p>
<p>2012 saw a modest decline in the number of active projects and committers
at Eclipse, 
however, there was at the same time an increase in the total number of 
commits. (This data is coming from an analysis of our repositories'
activity.)
</p>
<p><IMG SRC="../../../images/reports/2013_AR_active_projects.png" NAME="Active Projects" ALT="2012 Active Projects" ALIGN=BOTTOM WIDTH=565 HEIGHT=335 BORDER=0></p>
<p><IMG SRC="../../../images/reports/2013_AR_active_committers.png" NAME="graphics4" ALT="2012 Active Committers" ALIGN=BOTTOM WIDTH=565 HEIGHT=335 BORDER=0></p>
<p><IMG SRC="../../../images/reports/2013_AR_number_of_commits.png" NAME="Number of Commits" ALT="2012 Number of Commits" ALIGN=BOTTOM WIDTH=565 HEIGHT=335 BORDER=0></p>
<h3 class="western">Juno Simultaneous Release</h3>
<p>In June, 2012 the Eclipse community shipped Juno, its seventh
annual simultaneous release. Including previous releases of the
Eclipse Platform, this was the ninth release that was shipped on time
to the day. Seventy-one projects participated in the Juno
simultaneous release, comprising 60 million lines of code. 
</p>
<p>This predictable release process has been a key part of Eclipse's
success over the years, and is an important part of the success of
the Eclipse ecosystem.</p>
<p><IMG SRC="../../../images/reports/2012_AR_release_train.png" NAME="graphics3" ALT="2012 Release Train Numbers" ALIGN=BOTTOM WIDTH=600 HEIGHT=300 BORDER=0>
</p>
<p>With the Juno release, Eclipse 4.2 became the default platform for
the Eclipse community, marking the first major revision of the Eclipse platform
since 2004. The major goals of the 4.x release stream of the Eclipse platform
include:
	<ul>
		<li>Making it easier to write plug-ins (e.g. making Eclipse an
		even better Rich Client Platform)</li>
		<li>Allowing better control over the look of Eclipse based
		products</li>
		<li>Increasing diversity of contributors to the platform</li>
		<li>Maintaining backward compatibility for API-clean clients</li>
	</ul>
</p>
<p>With the release of Kepler in 2013, the Eclipse 3.x stream will no longer
be supported.</p>
<p>Other Eclipse Juno highlights include:</p>
<ul>
	<li><p style="margin-bottom: 0cm">The new Koneki project provides
	world-class Lua development tools for M2M application development.</p>
	<li><p style="margin-bottom: 0cm">Equinox provides the reference
	implementation for the new OSGi R5 specification.</p>
	<li><p style="margin-bottom: 0cm">Eclipse Virgo 3.5 will deliver the
	new Virgo Nano which allows developers to deploy very small and fast
	OSGi-based applications.</p>
	<li><p style="margin-bottom: 0cm">Xtend, a new language for Java
	developers, will introduce support for debugging, improved IDE
	support and new language features, including properties, data
	classes and type inference for fields.</p>
	<li><p style="margin-bottom: 0cm">Xtext 2.3 will now support
	integrated debugging of JVM-based DSLs created using Xtext and
	tighter integration with the Java Development Tools (JDT).</p>
	<li><p style="margin-bottom: 0cm">Eclipse Code Recommenders makes
	developers smarter about using APIs. Based on a knowledge-based and
	advanced analytics of existing API usage, Code Recommenders provides
	intelligent API recommendations to Eclipse developers building Java
	applications.</p>
</ul>
<p>The complete list of new projects that joined the release train
for the first time include</p>
<ul>
	<li>Orion</li>
	<li>Graphical Modeling Framework (GMF)
	Tooling</li>
	<li>Model Focusing Tools</li>
	<li>Intent</li>
	<li>Virgo</li>
	<li>BPEL Designer</li>
	<li>Koneki</li>
	<li>Code Recommenders</li>
	<li>Sapphire</li>
	<li>Xtend</li>
</ul>
<p>It should be noted that significant performance issues were reported after the
release of Eclipse Juno. Most of these were related to particular combinations 
of plug-ins and usage which were difficult to test for. The Eclipse platform 
team <a href="http://wiki.eclipse.org/Platform_UI/Juno_Performance_Investigation">responded quickly</a> and the February 2013 4.2.2. service release addressed
most of the known issues.</p>

<h3 class="western">Interesting New Projects</h3>
<p>The Eclipse Foundation attracted a number of interesting new projects over the past
year. A small sample of those would include:</p>
<ul>
	<li><b>Vert.x:</b> The Vert.x project decided to move to the Eclipse Foundation in February 2013. 
	Vert.x is a very interesting new JVM-based polyglot runtime project. Although vert.x will be joining
	the EclipseRT community, the project will not be making use of OSGi.</li>
	<li><b>Eclipse Bundle Recipes:</b> The EBR project will provide "recipes" in the form of 
	template files which can be used to convert open source library Jar files into OSGi Bundles. 
	EBR will be a subproject of the EclipseRT and will leverage the 
	functionality of existing projects. </li>
	<li><b>uDig:</b> uDig is our first LocationTech project and is an open source desktop application framework, 
	built with Eclipse Rich Client (RCP) technology. uDig provides a complete Java solution for desktop 
	GIS data access, editing, and viewing.</li>
	<li><b>Sirius:</b> Sirius aims at providing specific multi-view workbenches through graphical, table 
	or tree modeling editors. Users can easily define their own modeling workbench, even with very 
	little technical knowledge of Eclipse, while still being able to deeply customize it when needed.</li>
	<li><b>Mihini:</b> The Mihini project provides an open source implementation of an embedded runtime exposing 
	high-level Lua API that can be used to develop portable M2M applications easily. It is one of our first
	Lua language projects hosted at Eclipse, and is closely related to the Koneki project, which provides an
	Eclipse-based Lua IDE.</li>
</ul>
<h2 class="western">Committer and Project Community</h2>
<p>The EMO is committed to providing steadily improving services to
the Eclipse Committers and the projects they work on. Here is a
sampling of some infrastructure metrics, plus some improvements we've
put into place over the past year.</p>
<ul>
	<li>The Eclipse community has migrated
	from CVS to Git as their source code management tool. CVS was
	shutdown on December 21, 2012, and SVN has been deprecated.  Today,
	git.eclipse.org has over 500 repositories.</li>
	<li>Overall service availability was
	99.94% for our three mission-critical services: Bugzilla, Git and
	our website, www.eclipse.org.  Bugzilla and Git reached four-nines
	availability (99.99%) whereas a DDoS attack on our Forums reduced
	availability of our website to 99.83%.</li>
	<li>Our entire server infrastructure
	was moved to a new data center, providing us additional cabinet
	space, improved cooling, a 42% bandwidth increase and more AC power,
	at a lower cost to the Foundation.</li>
	<li>New servers were deployed: virtual
	hosts for additional CBI capacity (build and test), a new database
	server was added to the pool and a new 2 TB storage unit for
	build-related tasks replaced an 8.5 year old unit.</li>
	<li>As of September 2012, we've been
	relying on an in-house backup and restore system based on open
	source software. This solution, in addition to being more economical
	than our previous system, has proven itself to be dependable and
	very flexible.</li>
</ul>

<h3 class="western" STYLE="page-break-after: avoid">Common Build Infrastructure</h3>

<p>The Common Build Infrastructure (CBI) is a service offered by the Eclipse 
Foundation to its projects. It is primarily a collection of technologies and 
services which enable Eclipse projects to build their code on Eclipse Foundation
servers. The technology stack includes Maven, Tycho, Hudson and Nexus.
Core services include a Jar signing facility, MacOS signing facility, and Windows 
signing facility. 
</p>
<p>CBI has been deployed for a number of projects. 
For example, the projects using CBI are contained in 60+ git repositories. Notable 
in the list is the Eclipse Platform. The feedback for CBI has been extremely positive. 
People are impressed that for the first time, they can build the Eclipse Platform in 
minutes with very little effort.
</p>
<p>The goals of CBI are primarily around further reducing barriers to contribution
to Eclipse projects. By making it easier to build and test Eclipse code, we hope
to encourage more developers to contribute to Eclipse projects. Efforts continue 
to roll out CBI as widely as possible to Eclipse projects.
</p>

<h3 class="western" STYLE="page-break-after: avoid">Project
Management Infrastructure</h3>

<p>In late 2012, the Eclipse Foundation completed the initial release
of a new effort to replace the existing project management
infrastructure &ndash; which includes the Developer Portal &ndash;
with a new unified infrastructure with the intent of making project
management activities more consistent and generally easier for all
involved. The initial release was rolled out for Eclipse Projects and
LocationTech in early 2013.</p>
<p>Themes of this effort include:</p>
<ul>
	<li><b>Improved consistency: </b>We implemented
	configuration/data-driven project web presence, and direct linkage
	among releases, reviews, and plans. Information &ndash; including
	basic project metadata, project plans, and release review
	information &ndash; is captured and retained in a consistent (and
	easily leveraged) data- based format (rather than in multiple
	documents in arbitrary formats).</li>
	<li><b>All-in-one-place</b>: Committers are able to edit
	information in place on the project information pages.
	Text/information in one place with links in another is eliminated
	wherever possible. Comments and discussion related to reviews,
	elections, etc. are connected directly to the item being discussed.</li>
	<li><b>Get started faster:</b> By default, projects are provided
	with a data-driven website that includes consistent links to project
	releases, reviews, downloads, etc. Projects can opt to override the
	default and provide their own customized web presence.Setting up a
	project presence is a matter of configuration, not PHP programming
	against proprietary APIs.</li>
</ul>
		
	</div>
</div>

</body>

</html>