<!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>2014 Annual Eclipse Community Report</title>

</head>

<body lang="EN-US">

<div id="maincontent">
	<div id="midcolumn">
	
		<h1>2014 Annual Eclipse Community Report</h1>
		<br/><strong>Published June 2014</strong><br/><br/>
		
<P>Welcome to the third 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, 2013
to March 31, 2014. 
</P>
<H2 CLASS="western">Who We Are</H2>
<P>Our Bylaws define the Eclipse Foundation in this way:</P>
<P STYLE="margin-left: 2.01cm"><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: 2.01cm"><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 2014, as set by the Board of Directors.</P>
<OL>
	<LI><P STYLE="margin-bottom: 0cm"><B>Be the developer platform of
	choice:</B> The goal of Eclipse is to define a development platform
	that is freely licensed and 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. 
	</P>
	<LI><P STYLE="margin-bottom: 0cm"><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. 
	</P>
	<LI><P STYLE="margin-bottom: 0cm"><B>Recruit and foster Eclipse
	projects in those domains: </B><SPAN STYLE="font-weight: normal">It
	is an important part of the Foundation's role to be recruiting new
	projects in areas outside of Eclipse's historical strengths in tools
	and IDEs. </SPAN>Some recent successes would include the surge in
	new projects related to the Internet of things (IoT), and
	location-aware or geospatial technologies.</P>
	<LI><P STYLE="margin-bottom: 0cm"><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. 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 web, download, code management,
	build, and other key components of project infrastructure in 2014. 
	</P>
	<LI><P STYLE="margin-bottom: 0cm"><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 2014 is to focus our attention on the
	creation of working groups and new Eclipse projects that focus on
	particular industry segments such as the Internet of things, web
	development, mobile, automotive, insurance, and finance. 
	</P>
	<LI><P><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. 
	</P>
</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><P><B>Eclipse Foundation Europe GmbH:</B> <SPAN STYLE="font-weight: normal">In
	October 2013, <A HREF="http://eclipse.org/org/press-release/20131029_efe.php">the
	Eclipse Foundation Europe was founded</A>. The new EFE has local
	staff members to support the European community. Staff will support
	members in EU-funded projects such as ITEA2, provide appropriate
	development and dissemination services as a project partner, and
	participate in European-based associations such as the German Bitkom
	to create awareness of open innovation, open source business models,
	and the Eclipse platform. Ralph Mueller has been appointed the
	Managing Director of Eclipse Foundation Europe. Mr. Mueller is a
	30-year veteran in the IT industry. He has previously worked at IBM,
	Object Technology International, and Siemens-Nixdorf; most recently
	he has been the Director of European Ecosystem at the Eclipse
	Foundation. </SPAN>
	</P>
	<LI><P><B>New logo:</B> <SPAN STYLE="font-weight: normal">After
	almost 14 years, it was time to update our logo to a more modern
	look.</SPAN></P>
</UL>
<P STYLE="margin-left: 1.25cm">
<IMG SRC="/artwork/images/v2/logo-800x188.png" NAME="New Eclipse Logo" ALIGN=LEFT WIDTH=470 HEIGHT=110 BORDER=0><BR CLEAR=LEFT>
</P>
<P STYLE="margin-left: 1.25cm"><SPAN STYLE="font-weight: normal">Along
with the new logo comes a new, more restrictive <A HREF="https://www.eclipse.org/legal/logo_guidelines.php">set
of guidelines</A> for using the Eclipse logo.</SPAN></P>
<UL>
	<LI><P><B>A simplified developer workflow: </B><SPAN STYLE="font-weight: normal">In
	2013 the Eclipse Foundation implemented <A HREF="https://www.eclipse.org/legal/CLA.php">Contributor
	License Agreements</A> (CLA) and a <A HREF="https://www.eclipse.org/legal/CoO.php">Developer
	Certificate of Origin</A> (DCO). It is now very easy for a
	contributor to create an Eclipse Foundation account and
	electronically sign a CLA directly through our website. A CLA is
	tied to an individual's Eclipse Foundation account, which makes it
	valid for all Eclipse Foundation-managed forges (e.g. eclipse.org,
	LocationTech, and PolarSys).</SPAN></P>
</UL>
<P STYLE="margin-left: 1.25cm; font-weight: normal">The Foundation
also created Gerrit plugins and Git hooks that automatically check
contributions from non-committers to ensure that the author of the
contribution has a valid CLA on file, and that the contribution has
been &quot;signed off&quot; by the author indicating that they
understand the terms of the Certificate of Origin.</P>
<P STYLE="margin-left: 1.25cm; font-weight: normal">We've also begun
supporting GitHub as the main development tool used by projects for
their day-to-day development, while maintaining internal mirrors of
the GitHub repos. A GitHub hook is used to help guide committers
through the CLA and signed-off-by requirements when handling pull
requests from the community.</P>
<H2 CLASS="western">Membership</H2>
<P>The Foundation finished 2013 with a total of 190 members. By the
end of March 2014, that number had increased to 204. A total of 30
companies joined as new members of the Foundation in 2013 and Q1
2014. These companies include 2lemetry, Alma Mater Studiorum
Universita di Bolognal, AMIQ EDA, Analog Devices, Artal Groupe,
Azavea, Bitreactive AS, Bonitasoft, Cigital, Le Centre national de la
recherche scientifique (CNRS), Codetrails, Combitech, Dell,
DevelopIntelligence LLC, Docfacto, Euroforum Deutschland SE, Glob3
Mobile, Heinz Nixdorf Institute, IBH Systems, Klocwork, Lablicate,
M2M Alliance E.V., MapGears, Marintek, Open Geospatial Consortium,
Open Source Automation Development Lab (OSADL), Robotron
Datenbank-Software GmbHSeranata Commerce, Tesis Dynaware, Univeristat
Polit&egrave;cnica de Val&egrave;ncia, UT-Battelle, and Vivid
Solutions</P>
<H3 CLASS="western">Working Groups</H3>
<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>
<UL>
	<LI><P><B>Automotive: </B><SPAN STYLE="font-weight: normal">With
	Eclipse Kepler, the Eclipse Automotive working group has shipped a
	package designed to serve as a <A HREF="http://www.eclipse.org/downloads/packages/eclipse-ide-automotive-software-developers-includes-incubating-components/keplersr2">platform
	for automotive tools development</A>. In addition, the group has
	created the <A HREF="http://www.eclipse.org/eatop/">EATOP project</A>,
	providing tooling for describing automotive architectures in
	accordance to the EAST/ADL standard. In the work package #5 (Eclipse
	Qualification Roadmap according to DO-330) a positive result has
	been delivered (process description and roadmap) and is available
	for use. Robert Bosch GmbH and Continental AG have teamed up to
	design and deliver build frameworks that go beyond the current
	make-based approaches and better serve more complex models. For more
	information on all these topics, please refer to the <A HREF="http://wiki.eclipse.org/Auto_IWG">Automotive
	Working Group</A>.</SPAN></P>
</UL>
<P STYLE="margin-left: 1.15cm"><SPAN STYLE="font-weight: normal">The
Eclipse Foundation has (together with other partners) applied as
partner for the ITEA project AMALTHEA For Public (<A HREF="http://wiki.eclipse.org/images/5/5c/2013-06-04_AMALTHEA_Project.pdf">pdf</A>).
The project has been accepted and is waiting to be provisioned by the
national authorities. </SPAN>
</P>
<P STYLE="margin-left: 1.15cm"><SPAN STYLE="font-weight: normal">Meanwhile,
we continue to work with the <A HREF="http://openmdm.org/">openMDM
group</A> (Open Measurement Data Management) in order to transfer the
current openmdm.org into a new working group at the Eclipse
Foundation.</SPAN></P>
<UL>
	<LI><P><B>Internet of Things (IoT):</B> The Eclipse IoT demonstrated
	significant momentum in 2013 towards its goal of creating an open
	source community for the Internet of Things. Of significance was the
	rename of the working group from M2M to IoT, so that it was more
	inclusive of the wider IoT industry. In 2013, a total of 10 new open
	source projects were created at Eclipse that focused on IoT,
	including</P>
</UL>
<UL>
	<UL>
		<LI><P STYLE="margin-bottom: 0.1cm">E<SPAN STYLE="font-weight: normal">clipse
		SmartHome - provides an integration framework for home automation</SPAN></P>
		<LI><P STYLE="margin-bottom: 0.1cm; font-weight: normal">Eclipse
		SCADA - provides a framework for building SCADA solution 
		</P>
		<LI><P STYLE="margin-bottom: 0.1cm; font-weight: normal">Calfornium
		- an implementation of the CoAP standard</P>
		<LI><P STYLE="margin-bottom: 0.1cm; font-weight: normal">OM2M - an
		implementation of the OneM2M standard</P>
		<LI><P STYLE="margin-bottom: 0.1cm; font-weight: normal">Wakamma -
		an implementation of the OMA Lightweight M2M standard</P>
		<LI><P STYLE="margin-bottom: 0.1cm; font-weight: normal">Ponte -
		provides a bridge between IoT protocols and REST 
		</P>
		<LI><P STYLE="margin-bottom: 0.1cm; font-weight: normal">Kura -
		provides a set of OSGi services for IoT gateway solutions</P>
		<LI><P STYLE="margin-bottom: 0.1cm; font-weight: normal">Concierge
		- provides an OSGi R5 complaint runtime for small devices 
		</P>
		<LI><P STYLE="margin-bottom: 0.1cm; font-weight: normal">Mosquitto
		- an MQTT broker 
		</P>
		<LI><P STYLE="margin-bottom: 0.1cm; font-weight: normal">Krikkit -
		provides an architecture for to set rules/policies for IoT routers
		and gateways 
		</P>
	</UL>
</UL>
<P STYLE="margin-left: 1.25cm; font-weight: normal">At the time of
writing, the active members of the IoT working group are 2lementry,
BitReactive, Eurotech, ibh Consulting, IBM, and Sierra Wireless.</P>
<UL>
	<LI><P><B>LocationTech: </B><SPAN STYLE="font-weight: normal">LocationTech
	is a working group for developing advanced location aware
	technologies. In its first year, the LocationTech working group
	launched and grew to include 10 projects and 13 members. The group
	participated in 30 events on four continents, including a highly
	successful six-city LocationTech Tour in which more than 650 people
	participated.</SPAN></P>
</UL>
<P STYLE="margin-left: 1.25cm; font-weight: normal">The group has
attracted a strong group of technologies, including</P>
<UL>
	<UL>
		<LI><P STYLE="margin-bottom: 0.1cm; font-weight: normal">GeoMesa -
		a scalable spatio-temporal database that provides query
		capabilities on very large datasets using cloud platforms</P>
		<LI><P STYLE="margin-bottom: 0.1cm; font-weight: normal">GeoTrellis
		- a high performance geoprocessing engine that enables real time
		interaction with geospatial data</P>
		<LI><P STYLE="margin-bottom: 0.1cm; font-weight: normal">GeoJinni
		(formerly SpatialHadoop) - a Hadoop based distributed geoprocessing
		engine providing OGC data types, functions, and both local and
		cluster-wide indexing</P>
		<LI><P STYLE="margin-bottom: 0.1cm; font-weight: normal">The JTS
		Topology Suite - a highly respected library that underpins much of
		the open source geospatial ecosystem</P>
		<LI><P STYLE="margin-bottom: 0.1cm; font-weight: normal">Spatial4J
		- provides Geodetic features complementary to JTS</P>
		<LI><P STYLE="margin-bottom: 0.1cm; font-weight: normal">GeoGit -
		enablles decentralized management of versioned geospatial data and
		innovative workflows for collaboration</P>
		<LI><P STYLE="margin-bottom: 0.1cm; font-weight: normal">Mobile Map
		Tools - a framework and library for writing high performance mobile
		maps applications on Android, iOS, and the Web</P>
		<LI><P STYLE="margin-bottom: 0.1cm; font-weight: normal">Geo Fast
		Forward (GEOFF) - makes it easy to add maps to Eclipse RCP
		applications</P>
		<LI><P STYLE="margin-bottom: 0.1cm; font-weight: normal">uDig
		desktop GIS Suite - provides visualization and processing of data
		in a wide choice of formats and web services</P>
		<LI><P STYLE="margin-bottom: 0.1cm; font-weight: normal">GeoScript
		- adds spatial capabilities to dynamic scripting languages
		including Python, JavaScript, Groovy, and Scala</P>
	</UL>
</UL>
<P STYLE="margin-left: 1.25cm; font-weight: normal">The founding
members of LocationTech include Actuate, Boundless, IBM, Oracle,
OSGeo, and Carleton University&rsquo;s Geomatics and Cartographic
Research Centre.</P>
<P STYLE="margin-left: 1.25cm; font-weight: normal">New members since
the February 2013 launch include Azavea, Glob3 Mobile, Google,
MapGears, Mousebird Consulting, Open Geospatial Consortium, and Vivid
Solutions.</P>
<P STYLE="margin-left: 1.25cm; font-weight: normal">LocationTech
continues to grow and demonstrate increasing momentum.</P>
<UL>
	<LI><P><B>Long Term Support: </B><SPAN STYLE="font-weight: normal">After
	having made good progress on the technology side of the LTS
	initiative, we were looking into extending the ecosystem for LTS.
	This resulted in outreach activities at our own conferences as well
	as external events. We have created a <A HREF="http://marketplace.eclipse.org/category/markets/long-term-support">Long
	Term Support Marketplace</A> within the Eclipse Marketplace that now
	had eight organizations listed as long term support providers for
	different projects and platforms. In addition, the LTS steering
	committee continues to update the <A HREF="http://lts.eclipse.org/">LTS
	home page</A> and is engaging with press to bring the initiative
	into more conversations. The EMO is actively speaking to potential
	consumers of long term support (large scale RT applications based on
	Eclipse RCP, applications and tools in systems engineering, tools,
	and applications in finance and insurance industry) to create
	understanding of the value proposition that the LTS ecosystem
	offers.</SPAN></P>
	<LI><P><B>PolarSys: </B><SPAN STYLE="font-weight: normal">The goal
	of the PolarSys working group is to build and maintain an open
	source tool 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>
</UL>
<P STYLE="margin-left: 1.25cm; font-weight: normal">In its second
year of activity, PolarSys has grown in terms of membership and
projects. Astrium, Artal, Ecole Polytechnique de Montr&eacute;al, and
University of Sk&ouml;vde joined the working group. The new projects
extended the Polarsys tool chain to new activities in systems
engineering and development.</P>
<UL>
	<UL>
		<LI><P STYLE="margin-bottom: 0.1cm; font-weight: normal">POP - a
		full environment for Signal, a programing language for
		critical/real-time embedded applications</P>
		<LI><P STYLE="margin-bottom: 0.1cm; font-weight: normal">CHESS - a
		Papyrus customization for component based development of high
		integrity systems</P>
		<LI><P STYLE="margin-bottom: 0.1cm; font-weight: normal">Gendoc -
		migrated from the Topcased community to provide capabilities to
		generate documentation from models 
		</P>
		<LI><P STYLE="margin-bottom: 0.1cm; font-weight: normal">ReqCycle -
		addresses both requirement management and requirement traceability
		in the tool chain 
		</P>
		<LI><P STYLE="margin-bottom: 0.1cm; font-weight: normal">Kitalpha -
		a modeling component that implements the ISO/IEC 42010 standard for
		system description in system and software engineering</P>
	</UL>
</UL>
<P STYLE="margin-left: 1.25cm; font-weight: normal">PolarSys members
participated to two events focused on embedded systems, SAE Aerotech
in Montr&eacute;al and ERTS in Toulouse, They received a lot of
interest from the attendees. PolarSys members also published the
first videos of PolarSys tools, and the first milestone releases for
the PolarSys IDE.</P>
<H2 CLASS="western">Conferences and Events</H2>
<P>The Eclipse Foundation continues to produce very successful
EclipseCon conferences. In 2013, we added a third event, EclipseCon
France, to our annual calendar. The <A HREF="https://www.eclipsecon.org/france2013">first
edition of EclipseCon France</A> was held in June 2013 and had 246
attendees. The event was an excellent milestone for our growing
Eclipse community in France and the aerospace and systems engineering
community. <A HREF="https://www.eclipsecon.org/europe2013">EclipseCon
Europe</A> continues to grow as our annual European event and has a
successful partnership with the OSGi Alliance to co-locate the OSGi
Community Event. <A HREF="https://www.eclipsecon.org/2013">EclipseCon
North America 2013</A> was located in Boston, MA and provided an
excellent opportunity to reach out to the Eclipse community on the
east coast of the USA.</P>
<P>The EclipseCon conferences, <A HREF="https://wiki.eclipse.org/Eclipse_Day">Eclipse
Day</A>s, and <A HREF="https://wiki.eclipse.org/Eclipse_DemoCamps_Luna_2014">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 members to participate in these events.</P>
<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>Membership renewals remained strong, working group revenue and
website advertising both continued to grow, and an increase in
donations was a pleasant surprise. Despite originally budgeting a
$0.4M loss, the Eclipse Foundation experienced a gain of $0.1M, and
was able to contribute to its cash reserves. The organization
continues to be on a solid financial footing.</P>
<TABLE WIDTH=479 BORDER=0 CELLPADDING=4 CELLSPACING=0>
	<COL WIDTH=120>
	<COL WIDTH=81>
	<COL WIDTH=26>
	<COL WIDTH=89>
	<COL WIDTH=23>
	<COL WIDTH=92>
	<TR VALIGN=TOP>
		<TD WIDTH=120 HEIGHT=34>
			<P><FONT SIZE=3>In US $ millions </FONT>
			</P>
		</TD>
		<TD WIDTH=81 SDVAL="2011" SDNUM="4105;">
			<P ALIGN=RIGHT><FONT SIZE=3>2011</FONT></P>
		</TD>
		<TD WIDTH=26>
			<P ALIGN=RIGHT><br/>
			</P>
		</TD>
		<TD WIDTH=89 SDVAL="2012" SDNUM="4105;">
			<P ALIGN=RIGHT><FONT SIZE=3>2012</FONT></P>
		</TD>
		<TD WIDTH=23>
			<P ALIGN=RIGHT><br/>
			</P>
		</TD>
		<TD WIDTH=92 SDVAL="2013" SDNUM="4105;">
			<P ALIGN=RIGHT><FONT SIZE=3>2013</FONT></P>
		</TD>
	</TR>
	<TR VALIGN=TOP>
		<TD WIDTH=120>
			<P><FONT SIZE=3>Revenue</FONT></P>
		</TD>
		<TD WIDTH=81 SDVAL="4.1" SDNUM="4105;0;0.0">
			<P ALIGN=RIGHT><FONT SIZE=3>4.1</FONT></P>
		</TD>
		<TD WIDTH=26 SDNUM="4105;0;0.0">
			<P ALIGN=RIGHT><br/>
			</P>
		</TD>
		<TD WIDTH=89 SDVAL="4.1" SDNUM="4105;0;0.0">
			<P ALIGN=RIGHT><FONT SIZE=3>4.1</FONT></P>
		</TD>
		<TD WIDTH=23 SDNUM="4105;0;0.0">
			<P ALIGN=RIGHT><br/>
			</P>
		</TD>
		<TD WIDTH=92 SDVAL="4.5" SDNUM="4105;0;0.0">
			<P ALIGN=RIGHT><FONT SIZE=3>4.5</FONT></P>
		</TD>
	</TR>
	<TR VALIGN=TOP>
		<TD WIDTH=120>
			<P><FONT SIZE=3>Expenses</FONT></P>
		</TD>
		<TD WIDTH=81 SDVAL="4" SDNUM="4105;0;0.0">
			<P ALIGN=RIGHT><FONT SIZE=3>4.0</FONT></P>
		</TD>
		<TD WIDTH=26 SDNUM="4105;0;0.0">
			<P ALIGN=RIGHT><br/>
			</P>
		</TD>
		<TD WIDTH=89 SDVAL="4.2" SDNUM="4105;0;0.0">
			<P ALIGN=RIGHT><FONT SIZE=3>4.2</FONT></P>
		</TD>
		<TD WIDTH=23 SDNUM="4105;0;0.0">
			<P ALIGN=RIGHT><br/>
			</P>
		</TD>
		<TD WIDTH=92 SDVAL="4.4" SDNUM="4105;0;0.0">
			<P ALIGN=RIGHT><FONT SIZE=3>4.4</FONT></P>
		</TD>
	</TR>
	<TR VALIGN=TOP>
		<TD WIDTH=120>
			<P><FONT SIZE=3>Net Income</FONT></P>
		</TD>
		<TD WIDTH=81 SDVAL="0.1" SDNUM="4105;">
			<P ALIGN=RIGHT STYLE="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=26 SDNUM="4105;0;0.0">
			<P><br/>
			</P>
		</TD>
		<TD WIDTH=89 SDVAL="-0.1" SDNUM="4105;">
			<P ALIGN=RIGHT STYLE="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=23 SDNUM="4105;0;0.0">
			<P><br/>
			</P>
		</TD>
		<TD WIDTH=92 SDVAL="0.1" SDNUM="4105;">
			<P ALIGN=RIGHT STYLE="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">Intellectual Property Management 
</H2>
<P>During the time period spanning April 1, 2013 to March 31, 2014,
the Eclipse Foundation received 941 requests for code reviews, and
completed reviews of 849 requests. This represents increases of 2% in
review requests and 15% in completed reviews over the previous year.
By far, the greatest number of requests for review originate in the
Technology top level project, followed by SOA and RT. Requests for
review from these top level projects represents 73% of the requests
for IP review for the time period. The three projects requiring the
greatest degree of IP support were Stardust, followed by Winery and
uDig; these represented 25% of the overall requests.</P>
<P><IMG SRC="/images/reports/2014_IP_by_TLP.png" NAME="IP Requests by TLP" ALIGN=LEFT WIDTH=620 HEIGHT=515 BORDER=0><BR CLEAR=LEFT><br/><br/>
</P>
<P>Requests for code review for the Luna Simultaneous Release
numbered 25, which represents a 7% decrease from the preceding year.
We are no longer experiencing the surge of requests in relation to
the Simultaneous Release and requests for review are more evenly
distributed throughout the year.</P>
<P>At the time of this writing, the backlog of requests for code
review stands at 118. With increased activity by working groups, a
higher volume of new project creations, 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 increases in turnaround time for requests for code reviews. 
</P>
<H2 CLASS="western">Innovation</H2>
<P>Growth in projects exploded over the past year. More than half of
the new projects came to us through the Internet of Things,
LocationTech, and PolarSys working groups. Naturally, many of these
projects align with the goals of the respective working groups; in
addition to these projects, we received proposals representing a
diverse set of interests.</P>
<P><IMG SRC="/images/reports/2014_Active_Projects.png" NAME="Active Projects" ALIGN=LEFT WIDTH=565 HEIGHT=330 BORDER=0><BR CLEAR=LEFT>Overall,
we received almost three times as many proposals for new projects in
2013 as we received in 2012.</P>
<P>In addition to the Automotive, IoT, LocationTech, and Polarsys
projects noted above, these projects were proposed at Eclipse over
the past year.</P>
<UL>
	<LI><P STYLE="margin-bottom: 0.1cm">Thym: The HYbrid Mobile project
	delivers IDE components and a framework for developing Hybrid Mobile
	Applications on the Eclipse platform. The delivered IDE components
	support the Apache Cordova framework, but facilitate extensibility
	to other frameworks including the ones that are not based on Apache
	Cordova.</P>
	<LI><P STYLE="margin-bottom: 0.1cm">Oomph: The Oomph project
	provides tools that automate the provisioning and management of
	project-specific IDEs and workspaces, as well as other tediously
	repetitive tasks.</P>
	<LI><P STYLE="margin-bottom: 0.1cm">RCP Testing Tool: The RCP
	Testing Tool allows developers to create and execute test cases for
	Eclipse-based applications with minimal effort. 
	</P>
	<LI><P STYLE="margin-bottom: 0.1cm">Flux: This project aims at
	designing and implementing a new architecture and infrastructure for
	integrating development tools across desktop, browser, and servers.
	The goal is to provide an extremely flexible platform and
	infrastructure that allows new cloud-based tooling components to be
	built highly decoupled from each other and that bridges the gap to
	existing desktop IDEs at the same time.</P>
	<LI><P STYLE="margin-bottom: 0.1cm">UML Generators: The objective of
	this project is to federate the many different open source
	code/model generators that are available and that consume or produce
	UML models.</P>
	<LI><P STYLE="margin-bottom: 0.1cm">Handly: The Handly project aims
	to provide a foundation for construction of language-oriented
	handle-based models, not unlike the JDT Java Model in their
	essential qualities.</P>
	<LI><P STYLE="margin-bottom: 0.1cm">CBI: The Common Build
	Infrastructure (CBI) project maintains and develops software
	production technology common to multiple Eclipse projects.</P>
	<LI><P STYLE="margin-bottom: 0.1cm">Franca: The Franca project
	provides a technology- and platform-neutral IDL, including an
	easy-to-use editor based on the Eclipse IDE. 
	</P>
	<LI><P STYLE="margin-bottom: 0.1cm">Gendoc: Gendoc generates
	documentation for EMF models using document templates in formats
	such as OpenOffice Writer (.odt) or Microsoft Word (.docx).</P>
	<LI><P STYLE="margin-bottom: 0.1cm">Mbeddr: The project addresses
	the development and evolution of mbeddr language extensions
	(standalone DSLs and C extensions), their IDE, debuggers, and the
	integration of formal verification tools.</P>
	<LI><P STYLE="margin-bottom: 0.1cm">Winery: Winery is a Web-based
	environment to graphically model TOSCA topologies and plans that
	manage these topologies. 
	</P>
	<LI><P STYLE="margin-bottom: 0.1cm">Ogee: The main goal of Ogee
	project is to provide tools for developers who want to consume and
	produce data using the OData protocol.</P>
	<LI><P>Fundamental Modeling Concepts (FMC): Fundamental Modeling
	Concepts (FMC) is a modeling language for complex and dynamic
	systems. The project will provide meta models and editors for FMC
	diagrams.</P>
</UL>
<H2 CLASS="western">Kepler Simultaneous Release</H2>
<P>In June 2013 the Eclipse community shipped Kepler, its eighth
annual simultaneous release. Including previous releases of the
Eclipse Platform, this was the tenth release that was shipped on time
to the day. Seventy-one projects participated in the Kepler
simultaneous release, comprising 58 million lines of code. Over 180K
downloads were recorded for Kepler packages in the first three days.
This predictable release schedule 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/2014_Kepler_Overview.png" NAME="Kepler Overview" ALIGN=LEFT WIDTH=702 HEIGHT=357 BORDER=0><BR CLEAR=LEFT><br/><br/>
</P>
<P>These projects joined the simultaneous release in 2013:</P>
<UL>
	<LI><P STYLE="margin-bottom: 0.1cm">EMF Diff/Merge</P>
	<LI><P STYLE="margin-bottom: 0.1cm">Sphinx</P>
	<LI><P STYLE="margin-bottom: 0.1cm">Stardust</P>
	<LI><P>Maven Integration for Web Tools Platform</P>
</UL>
<P>An equal number of projects dropped off the simultaneous release
in 2013:</P>
<UL>
	<LI><P STYLE="margin-bottom: 0.1cm">Jetty (servlet engine and http
	server)</P>
	<LI><P STYLE="margin-bottom: 0.1cm">Virgo</P>
	<LI><P STYLE="margin-bottom: 0.1cm">Eclipse Runtime Packaging
	Project</P>
	<LI><P>Xtend*</P>
</UL>
<P STYLE="margin-left: 2.49cm"><FONT SIZE=2 STYLE="font-size: 9pt">*Note
that Xtend merged with Xtext (which does take part in the
simultaneous release).</FONT></P>
<H2 CLASS="western">Committer and Project Community</H2>
<P><IMG SRC="/images/reports/2014_Active_Developers.png" NAME="Active Developers" ALIGN=LEFT WIDTH=566 HEIGHT=332 BORDER=0><BR CLEAR=LEFT><br/><br/>
</P>
<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><P STYLE="margin-bottom: 0cm"><B>Common Build Infrastructure:
	</B>The Common Build Infrastructure (CBI) was significantly expanded
	to allow projects to have their own Hudson instance. The Hudson
	Instance Per Project (HIPP) allows committers to leverage the Hudson
	CI system for end-to-end building, testing, build promotion, and
	code repository tagging, while improving overall build system
	stability, availability, and performance. Committers are now
	empowered to administer their CI system as well as to start, stop,
	and restart the process without webmaster intervention should it
	crash or hang.</P>
</UL>
<P STYLE="margin-left: 1.25cm">Plans are to support other OS
platforms for HIPP, such as Fedora, Ubuntu, Mac, and Windows, to help
support platform-specific builds and tests.</P>
<UL>
	<LI><P><B>Project Management Infrastructure: </B><SPAN STYLE="font-weight: normal">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.</SPAN></P>
</UL>
<P STYLE="margin-left: 1.25cm; font-weight: normal">We've continued
to make improvements and enhance the functionality. We rolled it out
for PolarSys. In 2014, we plan to improve the overall look and feel
and usability, and move the remaining project-management related
functionality (the committer management functionality in particular).</P>
<UL>
	<LI><P><B>Sonar:</B> <SPAN STYLE="font-weight: normal">Sonar is an
	open-source product which is used to gather metrics about code
	quality, put them all in a single dashboard, and provide some tips
	to help improve quality. The Eclipse Foundation <A HREF="https://dev.eclipse.org/sonar/">deployed
	Sonar</A> as a supported service for its projects in 2013.</SPAN></P>
	<LI><P><B>Servers and Infrastructure: </B>Core service availability
	(Git, <A HREF="http://www.eclipse.org/">www.eclipse.org,</A> and
	Bugzilla) for 2013 was 99.975%, with an all-time high of 99.985% in
	2010. Most of our downtime was caused by bandwidth DDoS attacks
	against other clients at our co-location facility. We did not
	experience unexpected hardware or software failures in 2013 for our
	core services. For 2014, we are considering adding the Marketplace
	website to our core services. Gerrit is currently not considered a
	core service since we cannot currently provide hardware redundancy
	due to its single-server architecture. The Gerrit team has iterated
	its desire to implement such scalability and fault tolerance in the
	near future.</P>
</UL>
<P><br/><br/>
</P>

	</div>
</div>

</body>

</html>