<!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>2016 Annual Eclipse Community Report</title>

</head>

<body lang="EN-US">

<div id="maincontent">
	<div id="midcolumn">
	
		<h1>2016 Annual Eclipse Community Report</h1>
		<br/><strong>Published June 2016</strong><br/><br/>

<p>
	Welcome to the fifth annual Eclipse Foundation Community Report. Comments and feedback on the style and content would be appreciated at 
	emo@eclipse.org.
</p>
<p>
	Except where noted this report will cover the period April 1, 2015 to March 31, 2016.
</p>
<h2>
	Who We Are
</h2>
<p>
	Our Bylaws define the Eclipse Foundation in this way:
</p>
<blockquote><i>
	The Eclipse technology is a vendor-neutral, open development platform supplying frameworks and exemplary, extensible tools 
	(the "Eclipse Platform"). 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 "Eclipse Foundation"), 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></blockquote>
<p>
	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&rsquo;s 
	success.
</p>
<p>
	In short, our vision for the Eclipse community is
</p>
<blockquote><i>
	To be the leading community for individuals and organizations to collaborate on commercially-friendly open source software.
</i></blockquote>
<h2>
	Strategy
</h2>
<p>
	The following are the strategic goals of the Eclipse Foundation for 2015, as set by the Board of Directors.
</p>
<ol>
	<li>
		<b>Be the developer platform of choice.</b> 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 embedded, desktop and the web.
	</li>
	<li>
		<b>Promote the Eclipse community as the place to collaborate in emerging technology domains.</b> Obviously this is an ambitious goal, 
		as new technology domains and trends are constantly evolving. The Eclipse Foundation staff and leading members of our community 
		work steadily to recruit new projects in emerging technology areas.
	</li>
	<li>
		<b>Recruit and foster Eclipse projects in those domains.</b>It is an important part of the Foundation&rsquo;s role to be recruiting new 
		projects in areas outside of Eclipse&rsquo;s historical strengths in tools and IDEs. Some recent successes would include the surge 
		in new projects related to the model-driven tools for systems engineering, the Internet of Things (IoT), science, and location-aware 
		or geospatial technologies.
	</li>
	<li>
		<b>Create value for all its membership classes.</b> The Eclipse Foundation serves many members whose primary interest is leveraging Eclipse 
		technologies in proprietary 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 continuous improvements 
		to our development and intellectual management processes, as well as our web, download, code management, build and other key project 
		infrastructure components in 2016.
	</li>
	<li>
		<b>Foster growth of our communities and ecosystems.</b> 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 2016 is to focus our 
		attention on the success of our working groups and new Eclipse projects that focus on particular industry segments such as IoT, web 
		development, mobile, automotive, science, and finance.
	</li>
	<li>
		<b>Continue to grow a diversified revenue model.</b> 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>
	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="https://www.eclipse.org/org/foundation/minutes.php%23board">minutes of the Board</a>, found on our website.
</p>
<ul>
	<li>
		<i>Code of Conduct:</i> In June 2015, the Eclipse Foundation Board of Directors approved a community-wide 
		<a href="https://www.eclipse.org/org/documents/Community_Code_of_Conduct.php">code of conduct</a>. The Eclipse Foundation 
		is committed to making participation in the Eclipse community a harassment-free experience for everyone, regardless of level of 
		experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, 
		age, religion or analogous grounds.
	</li>
	<li>
		<i>Funding Eclipse Platform Development:</i> In early 2015 the Eclipse Foundation started accepting corporate donations to provide targeted 
		funding of Eclipse project enhancements. Later in the year, and into Q1 2016 we extended this concept in several important ways:
		<ul>
			<li>
				We hired a <a href="https://dev.eclipse.org/mhonarc/lists/ide-dev/msg01077.html">full-time developer</a>&nbsp;to work on the Eclipse IDE platform.
			</li>
			<li>
				We started allocating 100% of the <a href="http://www.eclipse.org/donate/">donations</a>&nbsp;we receive to funding additional development on the 
				Eclipse IDE platform.
			</li>
			<li>
				We implemented a community-driven <a href="http://www.eclipse.org/contribute/dev_program.php">Rriends of Eclipse Enhancement Program</a>&nbsp;
				(FEEP) to prioritize the work that we are doing with our projects.
			</li>
		</ul>
	</li>		
	<li>
		<i>Project branding requirements:</i>&nbsp;The Board instructed the Eclipse Management Organization (EMO) to create a set of project branding 
		requirements for all Eclipse Foundation projects which require:
		<ul>
			<li>
				consistent use of &ldquo;Eclipse&rdquo;, and
			</li>
			<li>
				the use of eclipse.org infrastructure for project web sites, wikis, and downloads.
			</li>
		</ul>
	</li>		
	<li>
		<i>Simultaneous release cadence:</i>&nbsp;The Eclipse community has for many years shipped a simultaneous release in June, followed by 
		two update releases in September and and February. For many years the update releases were expected to contain only bug fixes and minor 
		enhancements to the projects included in the June release. Developers today expect a faster release cadence, and as a result starting 
		with the Neon release in June 2016 the simultaneous release will be followed by quarterly updates (e.g. Neon.1 in September 2016). 
		More importantly, new projects may join, and participating projects may add new features or APIs to update releases. This will help 
		the Eclipse community get enhancements and few features to our users faster.
	</li>
	<li>
		<i>Getting closer to our users:</i>&nbsp;In 2015, the Eclipse Foundation developed a plan to offer storage service for Eclipse projects 
		hosted on eclipse.org infrastructure. The goal is to allow Eclipse IDE users the ability to store artifacts for Eclipse projects in a 
		user storage service (USS). In the Neon release we expect the first Eclipse projects to be integrated with USS.
	</li>
</ul>
<h2>
	Membership
</h2>
<p>
	The Eclipse Foundation welcomed two new strategic members to the Board of Directors in 2015, and another two in the first quarter of 2016. &nbsp;
	Both RedHat and CEA List joined the board last year, as noted in last year&rsquo;s annual report. &nbsp;In January 2016, Robert Bosch GmBH increased 
	its membership level from Solutions to Strategic Developer, and leads the Eclipse Vorto, Hawkbit and Hono projects. &nbsp;In February, 2016, 
	Ericsson also increased its membership level from Solutions to Strategic Developer, and leads the Eclipse eGerrit, Titan and Trace Compass 
	projects. &nbsp;
</p>
<p>
	The Foundation finished 2015 with a total of 246 members. By the end of April 2016, that number had increased to 250. A total of 36
	companies joined as new members of the Foundation from second quarter of 2015 through April 2016, including:
	Adocus AB, Ancit Consulting, ASAM eV, Azul Systems Inc, Bachmann electronics GmbH, b-data GmbH, CartoDB, Compex Systemhaus GmbH, 
	Develop BASYS GmbH, Ecole Technologie Superieure, EfficiOS Inc., Flanders Make vzw, Flex Alert Company, GE Digital, Huawei, IncQuery Labs 
	Research and Dev Ltd, iSencia Belgium NV, itema As, Microsoft, NorCom IT AG, NumberFour AG, One Fact Inc, Open Analytics NV, O&rsquo;Reilly, 
	Queen&rsquo;s University at Kingston, SAAB AB, Sencha, SensorUp Inc, The Goldman Sachs Group, The Radiant Group, TM Forum, Typefox, Verisign Sarl, 
	vogella GmbH, XDEV Software Corp, Zend Technologies and Zolertia SL.
</p>
<h2>
	Working Groups
</h2>
<p>
	The recruitment of new projects and members has been greatly assisted by the strategy of creating working groups (WG). As participation in 
	WGs grows, our membership has grown and diversified into different industries such as automotive, aerospace, geospatial, and the 
	Internet of Things.
</p>
<p>
	<b>Automotive:</b> The Eclipse Automotive Working Group has been dormant for the last year, with the exception of the Amalthea4Public research 
	project and the related APP4MC Eclipse project. In February Continental AG disengaged with the group. We have discussed the state of the 
	group with some of the remaining players: By the middle of 2016 we shall publish a plan for continuation or dissolve the working group.
</p>
<p>
	<b>Internet of Things (IoT):</b> The Eclipse IoT Working Group continued to gain momentum in 2015 towards its goal of creating an open source community for IoT. &nbsp;The community has grown to 21 open source projects, 2 million lines of code, 150 developers making contributions and 28 member organizations participating in the Working Group.
</p>
<p>
	The new projects in the IoT community include:
</p>
<ul>
	<li>
		Tinydtls - an implementation of the DTLS protocol
	</li>
	<li>
		Tiaki - an implementation of DNS-SD and DNS-SEC
	</li>
	<li>
		Hawkbit - a provisioning platform for IoT devices
	</li>
	<li>
		Edje - a Java api for microcontrollers
	</li>
	<li>
		Hono - a telemetry and command/control IoT platform
	</li>
</ul>
<p>
	The membership of the IoT working group grew to 28 members, including IBM, Eurotech, Sierra Wireless, Azul Systems, Bosch, Canonical, CA Technologies, Huawei, Red Hat, itemis, SMB, openHab, Opentext Analytics, Siemens, Verisign, Cisco, IS2T, Deutsche Telekom, ibh Systems, bitreactive, M2M Alliance, DC Square, Gadget Keeper, MicroEJ, Litmus Automation, Generative Software, Solair, Zolertia and LAAS-CNRS.
</p>
<p>
	In 2015, the IoT WG organized a number of community outreach programs, including:
</p>
<ol start="1">
	<li>
		An IoT Developer Survey that resulting in publish a report on the trends and opportunities for IoT developers.
	</li>
	<li>
		The Open IoT Developer Challenge to encourage developers to build IoT Solution based on open source software and open standards.
	</li>
</ol>
<p>
	<b>LocationTech</b>, hosted by the Eclipse Foundation, is a working group developing technologies with spatial awareness. LocationTech 
	continued to grow, and upon celebrating its 3rd birthday has grown to 20 members and 18 projects.
</p>
<p>
	Strategic members of the LocationTech working group include: Boundless, IBM, Oracle, Google Red Hat
</p>
<p>
	Participant members include: Azavea, CartoDB, CCRi, Glob3 Mobile, MapGears, Mousebird Consulting, OGC, Ordnance Survey, Planet Labs, 
	RadiantBlue, SensorUp, and VividSolutions
</p>
<p>
	New members in the past year were: CartoDB, RadiantBlue, Red Hat, SensorUp, and Planet Labs.
</p>
<p>
	LocationTech has become well known for the community of &ldquo;big geo&rdquo; technology projects including GeoTrellis, GeoMesa, GeoJinni, and GeoWave. 
	The GeoBench and SFCurve projects, new this year, provide complementary capabilities for benchmarking and creation/transformation/ and querying 
	space filling curves. Important libraries such as JTS and Spatial4J made progress on their incubation, with JTS doing much work to re-license 
	from LGPL to BSD+EPL.
</p>
<p>
	The GeoMesa project and Spatial4J projects were the first ever projects to do releases at LocationTech. GeoMesa released version 1.
	2.0, and Spatial4J released version 0.6.
</p>
<p>
	LocationTech projects participated in Google Summer of Code and Facebook Open Academy (FOA) again this year. The FOA program has been an 
	especially useful source of talented &amp; motivated students.
</p>
<p>
	The Eclipse Foundation organized FOSS4G North America 2016 on behalf of LocationTech &amp; OSGeo. The conference was a huge success, drawing 
	more than 400 people. For the first time at a FOSS4G event of this size, the program featured 30% women speakers, and attendance was 30% women.
</p>
<p>
	LocationTech organized FedGeoDay 2015, hosted in Washington D.C.. This event hadn&rsquo;t been held for a few years, so its return was viewed 
	positively by many. The event was hosted at the Woolly Mammoth Theatre Company, and featured an excellent program balancing speakers from 
	government and industry.
</p>
<p>
	The 3rd annual LocationTech Tour was a big success. There were 10 events globally with over 1,000 people participating. The number of events 
	and people was slightly lower than the previous year, as staff time to help support events maxed out due to the group&rsquo;s rapid growth. There 
	are plans to hire in 2016 to enable further growth.
</p>
<p>
	<b>Science Working Group&nbsp;(SWG)</b>, hosted by Eclipse, works to solve the problems of making science software interoperable and interchangeable. 
	It was founded in June 2014 and is now in it&rsquo;s second year of operation. It has now grown to 15 members and 8 projects.
</p>
<p>
	The group has the following members:
</p>
<ul>
	<li>
		Steering Committee members: Oak Ridge National Laboratory, Diamond Light Source, IBM and Itema.
	</li>
	<li>
		Participant Members: Lablicate, MARINTEK, Clemson University, The Facility for Rare Isotope Beams, Kichwa Coders, Uppsala University, 
		TechAdvantage, IFP Energies nouvelles and iSencia Belgium.
	</li>
</ul>
<p>
	New members this year include: Airbus, Open Analytics
</p>
<p>
	The Science Working Group hosts the following projects:
</p>
<ul>
	<li>
		DAWNSci, which defines Java interfaces for data description, plotting and plot tools, data slicing and file loading. It defines an 
		architecture oriented around OSGi services to do this. It provides a reference implementation and examples for the interfaces.
	</li>
	<li>
		ICE, which provides capabilities for modeling and simulation including setting up the model, launching the job, analysing t
		he results and managing the input and output data.
	</li>
	<li>
		ChemClipse, an Eclipse RCP chemistry application designed to handle analytical data from chromatographic/spectrometric systems like GC/MS 
		or GC/FID. These systems are used e.g. to identify environmental pollutants, in forensics, to ensure the harmlessness of groceries or in 
		the area of industrial quality control processes.
	</li>
</ul>
<p>
	In its second year the following projects joined the working group:
</p>
<ul>
	<li>
		Eclipse Advanced Visualization Project, Visualization is a critical part of science and engineering projects and has roles in both 
		setting up problems and post-processing results. The input or "construction" side can include things like constructing 3D geometries
		or volume meshes of physical space and the post-processing side can include everything from visualizing those geometries and meshes to 
		plotting results to analyzing images to visualizing real data to almost everything else imaginable.
	</li>
	<li>
		Eclipse Rich Beans, This project allows user interface to be created from beans or graphs of beans. The user interface available has 
		standard widgets which have few dependencies to reuse. For instance there are widgets for editing numbers with bounds validation, units 
		and that allow expressions of other boxes. There are widgets for entering a range of values and expanding out bean graphs to complete 
		Design of Experiments work.
	</li>
	<li>
		Triquetrum, which delivers an open platform for managing and executing scientific workflows. The goal of Triquetrum is to support a 
		wide range of use cases, ranging from automated processes based on predefined models, to replaying ad-hoc research workflows recorded 
		from a user&rsquo;s actions in a scientific workbench UI. It will allow to define and execute models from personal pipelines with a few steps 
		to massive models with thousands of elements.
	</li>
	<li>
		A new project proposal was submitted in January 2016. The project is coincidentally called January, which is short for 
		JAva NUmerical ARraYs and seeks to provide Java implementations of numerical data structure such as multi-dimensional arrays and matrices.
	</li>
</ul>
<p>
	The group participated in a number of events including for the first time, Science tracks at EclipseCon France, Europe &amp; North America. 
	The number of presentations has grown steadily from five in France, six in Europe and a jump to 12 in EclipseCon North America.
</p>
<p>
	A full day meetup was hosted by MARINTEK in August 2015. Much of the discussion was focussed on establishing a foundation for the group&rsquo;s 
	software. This has resulted in the January project proposal.
</p>
<p>
	The steering committee decided to elect a chair and a secretary to help with running the group, and a set of job descriptions was established 
	for these roles. Jay Jay Billings of Oak Ridge National Laboratory was elected chair and Torkild U. Resheim of Itema was elected secretary. 
	Both will serve for a period of one year, until the next election.
</p>
<p></p>
<p>
	The <b>Eclipse Long-Term-Support Working Group</b> reports slow progress. No new members have been joining the group, and with 
	EclipseSource/Innoopract the group has lost one of its founding members. The LTS infrastructure is now successfully used by some 
	organizations, the signing infrastructure for LTS builds is in place. Reports about successful support contract deals have been mentioned 
	by group members, but details have not been disclosed to the public. For 2016 we expect new members to join the group.
</p>
<p>
	<b>openMDM</b> The Eclipse openMDM (measured data management) Working Group has made reasonable progress in the past year. Membership was growing 
	as expected when ASAM e.V., Siemens, Tata Motors, Norcom IT &nbsp;and itemis joined the group. Technical work is progressing. The group expects 
	to provide the first technology demonstrator in the 3rd quarter of 2016.
</p>
<p>
	<b>PolarSys</b> The PolarSys Working Group made significant progress with a focus on marketing the PolarSys solutions, increasing PolarSys 
	visibility and the creation of the first Industry Consortium dedicated to Papyrus.
</p>
<p>
	The PolarSys Working Group created datasheets for each PolarSys solutions to promote them as industry-grade, ready to deploy, extensible tools. 
	In 2016, PolarSys will focus on the creation of case studies that document the deployment of PolarSys solutions by end-users. In 2015, PolarSys 
	introduced EGit/EGerrit as a new solution in PolarSys portfolio to support configuration management.
</p>
<p>
	The PolarSys Working Group participated to several international events to increase PolarSys visibility: Embedded World Conference 2015 and 2016, the Incose Symposium 2016 in Seattle with a large booth and demonstrations of the Capella and Papyrus solutions, and Models 2015 in Ottawa.
</p>
<p>
	In terms of membership, the Polarsys Working Group has 24 members. Leading industry players are Airbus (including civil aircraft, defence and 
	space and Helicopter divisions), CEA LIST, Ericsson, Thales and SAAB. Participating members are Adocus, Artal Group, Atos, Combitech, ESI Group,
	Flanders Make, Fraunhofer Fokus, Obeo, One Fact, Soyatec, Tecnalia and Zeligsoft. And Guest members are Ecole Polytechnique de Montreal, 
	Ecole de Technologie Superieure de Montreal, Queen&rsquo;s University, TM Forum, and University of Skovde.
</p>
<p>
	The most important event of last year is the creation of the Papyrus Industry Consortium (Papyrus IC) as a sub group of PolarSys that 
	brought 5 new members to the Working Group. The Papyrus IC gathers a group of members companies interested in financing and guiding the 
	development of products based on the open-source Eclipse Papyrus project. Those end-users companies collaborate with service providers, 
	and researchers to create a complete customizable and extensible industrial-grade open source Model Based Engineering (MBE) tool suite for 
	companies developing software-based systems, from Enterprise Software &nbsp;to Internet of Things (IoT) and Cyber-Physical Systems (CPS).
</p>
<p>
	The Papyrus IC is led by Airbus Helicopter, CEA LIST, EclipseSource, Ericsson, OneFact, SAAB and Zeligsoft. They collaborate with Adocus, 
	Airbus Defence and Space, Atos, Combitech, Flanders Make, Fraunhofer Fokus and a number of universities.
</p>
<h2>
	Conferences and Events
</h2>
<p>
	The EclipseCon conferences, Eclipse Days and DemoCamps 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 members 
	to participate in one or more of these events.
</p>
<p>
	<a href="https://www.eclipsecon.org/france2015/">EclipseCon France</a>&nbsp;was held in June 2015 and had 267 attendees. &nbsp;Based on the 
	success from the previous year, the conference continued with the model of a full day of Unconference where many of the Foundation&rsquo;s 
	Working Groups met, followed by two days of main conference activities. 
</p>
<p>
	<a href="https://www.eclipsecon.org/europe2015">EclipseCon Europe</a> celebrated its tenth anniversary in November, 2015, with 600 
	people in attendance. &nbsp;This event was co-located with the OSGi Community event, and included a great collection of technical sessions, 
	BoFs, keynotes, including a great talk by Sabine Hauert on Swarming Nanomedicine, a return of the IoT Playground, as well as many social 
	activities. The conference also hosted a number of dedicated events, including the IoT Summit, the Papyrus Summit, Project Quality Day and 
	LocationTech Day. Feedback from the conference from both attendees and sponsors remains strong year over year. &nbsp;
</p>
<p>
	In March, 2016, <a href="https://www.eclipsecon.org/na2016/">EclipseCon North America</a> returned to the Reston, VA area, where the 
	conference was previously held in March, 2012. &nbsp;This year&rsquo;s event saw a return to EclipseCon NA being stand-alone, as opposed to the 
	joint event with FOSS4G in 2015, and with a return to the number and quality of tracks seen at traditionally offered at EclipseCon NA. 
	The conference also hosted the IoT Summit, a CDT Summit and a LocationTech code sprint. Feedback from the conference&rsquo;s 277 attendees was 
	very positive overall, with many noting the quality of the talks and the interaction within the community being very strong. However, there 
	was also general feedback from both attendees and sponsors of a need to make changes to the conference in order to attract new people into 
	the event. &nbsp;
</p>
<p>
	For the 2nd consecutive year, the Eclipse Foundation and LocationTech acted as host and organizer for 
	<a href="https://2016.foss4g-na.org/">FOSS4G NA</a>, held this year in Raleigh, NC in May, 2016. &nbsp;The conference saw another significant 
	increase in attendance, growing from last year&rsquo;s 430 to 558 this year. Like EclipseCon North America, the number of tracks and speakers 
	were increased year over year, with very positive feedback being received. &nbsp;The conference included a poster and map session, 
	a Postgres Day, and a two day code sprint. &nbsp;Approximately 30% of the attendees were women, which is more than double the historical 
	proportion for FOSS4G conference. &nbsp;
</p>
<h2>
	Financials
</h2>
<p>
	The Eclipse Foundation&rsquo;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.<br>
	<br>
	Membership renewals remained strong, working group revenue and website advertising both continued to grow. Despite originally budgeting 
	a $0.4M loss, the Eclipse Foundation controlled expenses to result in a breakeven year. The organization continues to be on a solid financial 
	footing.
</p>
<p></p>
<p>
	Looking forward to 2016, the Board has approved a budget forecasting a $0.5M loss, and a significant growth in headcount.
</p>
<blockquote>
<table>
	<tbody>
		<tr>
			<td colspan="1" rowspan="1">
				<p>
					In US $ millions
				</p>
			</td>
			<td colspan="1" rowspan="1">
				<p>
					2013
				</p>
			</td>
			<td colspan="1" rowspan="1">
				<p>
					2014
				</p>
			</td>
			<td colspan="1" rowspan="1">
				<p>
					2015
				</p>
			</td>
			<td colspan="1" rowspan="1">
				<p>
					2016 Budget
				</p>
			</td>
			<td colspan="1" rowspan="1">
				<p></p>
			</td>
		</tr>
		<tr>
			<td colspan="1" rowspan="1">
				<p>
					Revenue
				</p>
			</td>
			<td colspan="1" rowspan="1">
				<p>
					4.5
				</p>
			</td>
			<td colspan="1" rowspan="1">
				<p>
					4.3
				</p>
			</td>
			<td colspan="1" rowspan="1">
				<p>
					4.9
				</p>
			</td>
			<td colspan="1" rowspan="1">
				<p>
					5.5
				</p>
			</td>
			<td colspan="1" rowspan="1">
				<p></p>
			</td>
		</tr>
		<tr>
			<td colspan="1" rowspan="1">
				<p>
					Expenses
				</p>
			</td>
			<td colspan="1" rowspan="1">
				<p>
					4.4
				</p>
			</td>
			<td colspan="1" rowspan="1">
				<p>
					4.7
				</p>
			</td>
			<td colspan="1" rowspan="1">
				<p>
					4.0
				</p>
			</td>
			<td colspan="1" rowspan="1">
				<p>
					6.0
				</p>
			</td>
			<td colspan="1" rowspan="1">
				<p></p>
			</td>
		</tr>
		<tr>
			<td colspan="1" rowspan="1">
				<p>
					Net Income
				</p>
			</td>
			<td colspan="1" rowspan="1">
				<p>
					0.1
				</p>
			</td>
			<td colspan="1" rowspan="1">
				<p>
					-0.4
				</p>
			</td>
			<td colspan="1" rowspan="1">
				<p>
					0.0
				</p>
			</td>
			<td colspan="1" rowspan="1">
				<p>
					(0.5)
				</p>
			</td>
			<td colspan="1" rowspan="1">
				<p></p>
			</td>
		</tr>
	</tbody>
</table>
</blockquote>
<h2>
	Intellectual Property Management
</h2>
<p>
	During the time period spanning April 1, 2015 to March 31, 2016, the Eclipse Foundation received 1,563 requests for code review and completed 1,321 reviews. &nbsp;As more Projects come on board, 
	the need for code review continues to grow, particularly for the Eclipse Foundation&rsquo;s working groups. In March 2016, the backlog of IP review requests reached an all-time high of 331 edging 
	out the previous 2015 high of 307. &nbsp;<br>
	<br>
	The Eclipse Foundation is currently in the process of hiring another analyst to address this growing demand.
</p>
<p>
	<img alt="" src="/images/reports/2016_iprequests.png" title="IP Rquests By Project">
</p>
<h2>
	Innovation
</h2>
<p>
	In 2015, we posted twenty-six new project proposals across our three forges. This is down from the thirty-four that we posted in the previous year. The proposals span an impressive range of technology, from cloud development tools, Internet of Things, programming languages, and more.
</p>
<h3>
	Cloud
</h3>
<p>
	The Eclipse Plug-ins for Cloud Foundry project enables developers to deploy and test their applications on Cloud Foundry without leaving their Eclipse integrated development environment. The introduction of this project pulls the Eclipse IDE into our cloud development story, joining the Eclipse Che, Eclipse Dirigible, and Eclipse Orion projects (which was moved into the Eclipse Cloud Development top-level project in 2015).
</p>
<h3>
	Science
</h3>
<p>
	We are pushing towards the critical mass required to create a Science&nbsp;top-level project as a complement to the working group. In 2015, we created several projects, including Eclipse Rich Beans, Eclipse Advanced Visualization, and Eclipse Triquetrum which all join the Eclipse DawnSci, Eclipse Integrated Computational Environment, and others in the Technology top-level project.
</p>
<h3>
	More
</h3>
<p>
	The Eclipse Buildship project provides tools for the popular Gradle build technology in the Eclipse IDE. Eclipse Collections is a set of highly-efficient object and primitive data structures for Java (e.g. List, Set, Bag, Multimap, BiMap, Stack), and Eclipse Golo&nbsp;is a dynamically-typed programming language for the Java Virtual Machine which supports imperative and functional programming patterns.
</p>
<p></p>
<p>
	In addition to the projects noted above, the following projects were proposed at Eclipse in 2015:
</p>
<p></p>
<ul>
	<li>
		Eclipse hawkBit&nbsp;(IoT) provides a software update management service for the Internet of Things;
	</li>
	<li>
		Using Eclipse Tiaki&nbsp;(IoT), devices can securely discover this configuration over either the Internet or a private network and then validate the source of the configuration to ensure that it has come from a trusted party;
	</li>
	<li>
		Eclipse tinydtls&nbsp;(IoT) is a library for Datagram Transport Layer Security (DTLS) covering both the client and the server state machine;
	</li>
	<li>
		LocationTech GeoBench&nbsp;provides a methodology and toolset for evaluating the performance of geospatial databases;
	</li>
	<li>
		LocationTech GeoWave&nbsp;leverages the scalability of a distributed key-value store for effective storage, retrieval, and analysis of massive geospatial datasets;
	</li>
	<li>
		The LocationTech SFCurve&nbsp;library is a Scala library for the creation, transformation, and querying of space-filling curves;
	</li>
	<li>
		Eclipse Formal Modeling&nbsp;provides a series of formal analysis tools;
	</li>
	<li>
		Eclipse Layout Kernel&nbsp;(Elk) provides layout algorithms and the basic framework to connect graphical editors to layout algorithms;
	</li>
	<li>
		Eclipse Papyrus-RT&nbsp;is an industrial-grade, complete modeling environment for the development of complex, software intensive, real-time, embedded, cyber-physical systems;
	</li>
	<li>
		Eclipse Presentation Modeling Framework&nbsp;(PMF) provides the basic functional concepts of user interaction in a platform-independent model;
	</li>
	<li>
		The Eclipse Web Modeling Framework&nbsp;provides a framework to develop any online model and diagram editor based on an EMF meta-model;
	</li>
	<li>
		PolarSys OpenCert&nbsp;is a product and process assurance/certification management tool to support the compliance assessment and certification of safety-critical systems in sectors such as aerospace, railway, and automotive;
	</li>
	<li>
		Eclipse Product Lifecycle Management Platform&nbsp;(PolarSys) is a comprehensive, robust open source product lifecycle management solution to manage the entire lifecycle of products from inception to market and disposal;
	</li>
	<li>
		The Eclipse APP4MC&nbsp;project provides a tool chain environment and de-facto standard to integrate tools for all major design steps in the multi- and many-core development phase;
	</li>
	<li>
		The Eclipse MDM|BL&nbsp;project covers the basic framework to build an application to work with openMDM data based on the ASAM ODS standard;
	</li>
	<li>
		The Eclipse Model Driven Health Tools&nbsp;project supports the specification and implementation of healthcare interoperability standards by creating UML profiles, model transformations, publication, code generation, and model editing tools for clinical informatics users;
	</li>
	<li>
		The Eclipse openK Platform&nbsp;consolidates energy and water infrastructure software (EWIS) onto a shared technical platform;
	</li>
	<li>
		Eclipse Package Drone&nbsp;is an OSGi based, web enabled repository for software artifacts with special considerations for the necessities of OSGi bundles and its metadata; and
	</li>
	<li>
		Eclipse RDF4J&nbsp;is an Java toolkit that provides functionality for efficient and scalable storage, querying, and reasoning with Resource Description Framework data.
	</li>
</ul>
<h2>
	Mars Simultaneous Release
</h2>
<p>
	In June 2015 the Eclipse community shipped Mars, its tenth annual simultaneous release. Including previous releases of the Eclipse Platform, this was the twelfth release that was shipped on time to the day. Seventy nine projects participated in the Mars simultaneous release, comprising 65 million lines of code, and produced by 380 committers from 50 member companies.
</p>
<p></p>
<p>
	This predictable release schedule has been a key part of Eclipse&rsquo;s success over the years, and is an important part of the success of the Eclipse ecosystem.
</p>
<p>
	<img alt="" src="/images/reports/2016_neon.png" title="Simultaneous Release">
</p>
<p>
	Seven projects joined the Mars Simultaneous release: Eclipse SWTBot, Eclipse RCP Testing Tool, Eclipse e(fx)clipse, Eclipse Thym, Eclipse Trace Compass, Eclipse Oomph, and Eclipse Lua Development Tools (LDT). Four projects that had participated in the previous releases dropped out: Eclipse Mylyn Intent, Eclipse Model Focusing Tools, Eclipse Paho, and Eclipse Koneki. The Eclipse Buildship project, which provides Eclipse Platform tools for working with Gradle-based builds, joined the first update of the Mars release in September 2015, and is not included in the chart.
</p>
<h2>
	Research
</h2>
<p>
	Since 2013, the Foundation increased its collaboration with academics, researchers and industries by participating to several European projects. The Foundation main objective on such projects is to help the consortium in dissemination and in building an Open Source community around the EU project.
</p>
<p>
	The positive side effects are in:
</p>
<ul>
	<li>
		Eclipse Foundation recognition as an expert in building OS communities,
	</li>
	<li>
		The opportunity to bring new academic and industrial members into the Foundation,
	</li>
	<li>
		The occasion to promote and disseminate existing Eclipse projects into such international consortiums.
	</li>
</ul>
<p></p>
<p>
	Today the Eclipse Foundation Europe is a partner in 3 large European research projects:
</p>
<ul>
	<li>
		<a href="http://www.amalthea-project.org/">Amalthea4Public</a>: Started in fall 2013. This project is building an Open Platform for Embedded Multicore Systems,
	</li>
	<li>
		<a href="http://agile-iot.eu/">AGILE-IoT</a>: Started in January 2016. This project is building an Adaptive &amp; Modular Gateway for the Internet of Things (IoT),
	</li>
	<li>
		<a href="http://www.amass-ecsel.eu/">AMASS</a>: Started in April 2016. This project is creating an open tool platform, ecosystem, and self-sustainable community for assurance and certification of Cyber-Physical Systems (CPS) in the largest industrial vertical markets including automotive, railway, aerospace, space, energy.
	</li>
</ul>
<h2>
	Committer and Project Community
</h2>
<p>
	Our number of committers grew past 1,400 in 2015. Curiously, however, while all of our other numbers are increasing (the number of active projects increased by 5%, and the total number of commits increased by 13%), the number active committers dropped by about 4% (lower than 2014, but still higher than 2013).
</p>
<p>
	<img alt="" src="/images/reports/2016_committers.png" title="Committers and Contributors">
</p>
<p>
	Our focus on removing barriers for contributions continues to reap dividends as the number of non-committer contributors increased by approximately 35% over the previous year. The Eclipse Platform project and its subprojects have become great examples of diversity; their project teams are clear leaders in accepting contributions, accounting for 885 contributions from approximately 122 contributors in 2015. Several other projects boast impressive contribution numbers as well, with Eclipse SmartHome, Eclipse C/C++ Development Tools, and Eclipse Papyrus taking top spots.
</p>
<p></p>
<p>
	Many of the contributors have been invited to join project teams as committers.
</p>

<p>
	<img alt="" src="/images/reports/2016_contributors.png" title="Contributors">
</p>
<p></p>
<p>
	The EMO is committed to providing a robust and dependable server and software infrastructure, including professional support staff to assist projects and Working Groups in achieving their goals effectively and efficiently, as well as 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&rsquo;ve put into place over the past year.
</p>
<p></p>
<ul>
	<li>
		Servers and Infrastructure: Core service availability (Git, www.eclipse.org, and Bugzilla) for 2015 was 99.987%, down from 99.993% last year.
	</li>
</ul>
<p></p>
<ul>
	<li>
		Common Build Infrastructure:&nbsp;Two new major features were added this year: GPG signing for HIPP (Hudson Instance Per Project) to allow for automated deployment to Maven Central&nbsp;in 
		a secure fashion; and the ability to connect HIPPs to external Hudson/Jenkins slaves. &nbsp;Furthermore, we&rsquo;ve begun testing Jenkins as a substitute to Hudson for those projects who wish to use it. 
		A &ldquo;JIPP&rdquo; platform is expected to be available to projects later this year.
	</li>
</ul>
<p></p>
<ul>
	<li>
		Websites:&nbsp;Professional graphical and layout treatments are now the first consideration for all our websites, making the Eclipse Foundation-produced websites world-class.
	</li>
</ul>
<p></p>
<ul>
	<li>
		Bandwidth and performance: Our bandwidth cap now sits at 250 Mbps to help support the ever increasing projects and developers that come to the Eclipse Foundation. Eclipse servers now move over 55 terabytes on average each month. New software and infrastructure is being tested to help reduce our bandwidth requirements and leverage the power of our free mirrors network.
	</li>
</ul>
<p>
	<img alt="" src="/images/reports/2016_downloads.png" title="Files Downloaded">
</p>
<p></p>
<ul>
	<li>
		Developers, Developers, Developers:&nbsp;Eclipse&rsquo;s account database now sits at 290,000 accounts, with a growth rate of 2500 new accounts each month. Although a percentage of those accounts are 
		created for spam purposes, we&rsquo;re employing modern methods to curtail such practices.
	</li>
</ul>
<p></p>
<ul>
	<li>
		Project virtual servers to Google Cloud:&nbsp;We&rsquo;ve been moving project virtual servers to the Google Cloud Platform. This will liberate server resources and webmaster overhead, as well as provide the webmaster team with some experience with Cloud services. If proven successful, this service move could be the first of others, as we deem appropriate.
	</li>
</ul>
<p></p>
<ul>
	<li>
		IT work queue: The webmaster and web developer work queues are currently very high -- in excess of 1000 items. We&rsquo;ve hired an additional SysAdmin (Derek Toolan) and a new release engineer to replace Mikael Barbero (Frederic Gurr, July 2016), and are actively seeking an additional web developer.
	</li>
</ul>
<p></p>
<ul>
	<li>
		USS: The User Storage Service is a new service offered by the Eclipse Foundation, which allows Eclipse projects to store non-sensitive user-data on EMO servers by using the USS SDK. The server infrastructure behind this new service is currently modest but is designed for expansion as the need arises.
	</li>
</ul>
<p></p>
<ul>
	<li>
		SPAM:&nbsp;Keeping Eclipse content free of SPAM is an ongoing battle. In addition to Bugzilla, Marketplace and Forum content, the Eclipse Wiki fell victim to spambots in December. We&rsquo;ve since implemented a crowd-sourced moderation system to help webmasters handle the issue.
	</li>
</ul>
  </div>
</div>

</body>

</html>
