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

</head>

<body lang="EN-US">

<div id="maincontent">
  <div id="midcolumn">
  
    <h1>2017 Annual Eclipse Community Report</h1>
    <br/><strong>Published June 2017</strong><br/><br/>

<p>Welcome to the sixth 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,
    2016 to March 31, 2017.</p>
  <h2>Who We Are</h2>
  <p>The Eclipse Foundation&rsquo;s mission:</p>
  <blockquote><i>The purpose of Eclipse Foundation is to advance the creation,
    evolution, promotion, and support of its hosted technology projects,
    and to cultivate diverse open source communities, and vibrant
    business ecosystems 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
    and community, but 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>
  <blockquote><i>To be the leading community for individuals and organizations
    to collaborate on commercially-friendly open source technology.</i></blockquote>
  <h2>Strategy</h2>
  <p>The following are the strategic goals of the Eclipse Foundation
    for 2017, as set by the Board of Directors.</p>
  <ol>
    <li><strong>Be a leading open source community for emerging
      technologies.</strong> 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,
      especially in areas outside of Eclipse's historical strengths in
      tools and IDEs. Some recent successes 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><strong>Cultivate the growth of our projects, communities, and
      ecosystems.</strong> 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 2017 is to focus our attention on the success of our
      working groups and on new Eclipse projects that focus on
      particular industry segments such as IoT, web development, mobile,
      automotive, science, and finance.</li>
    <li><strong>Create value for all its membership classes.</strong> 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 />
      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 2017.</li>

    <li><strong>Be the leading community for developer tools.</strong> The goal of
      Eclipse is to define development platforms that are freely
      licensed and open source, and that provide 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. The Eclipse
      community is best known for its desktop IDEs such as the Eclipse
      Java development tools (JDT) and the C/C++ development tools
      (CDT). However, under the leadership of the Eclipse Cloud
      Development top-level project, the Eclipse Che, Eclipse Dirigible,
      and Eclipse Orion projects are working on new tooling platforms
      for cloud-based and web development.</li>
    <li><strong>Continue to grow a diversified revenue model.</strong> 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="http://www.eclipse.org/org/foundation/minutes.php#board">minutes
      of the Board</a>, found on our website.
  </p>
  <ul>
    <li><em>Intellectual Property Management:</em> In June 2015, the Eclipse
      Foundation Board of Directors approved a <a
      href="https://mmilinkov.wordpress.com/2016/06/29/overhauling-ip-management-at-the-eclipse-foundation/">major
        overhaul</a> of the Eclipse Foundation&rsquo;s intellectual property
      policy. The new approach allows Eclipse projects to decide what
      level of IP due diligence they want performed for each of their
      releases. &rsquo;Type A&rsquo; projects will have their dependencies checked
      for license compatibility, while &rsquo;Type B&rsquo; will add the full list
      of historical Eclipse Foundation practices include code scanning
      and deep analyses. These changes bring the Eclipse Foundation&rsquo;s
      practices in alignment with industry practices.
    </li>
    <li><em>Contributor Agreements:</em> In August 2016, the Eclipse
      Foundation rolled out its new Eclipse Contributor Agreement (ECA)
      that included the following changes:
      <ul>
        <li>Simply renaming the document helped clear up confusion
          about its intent. The name &rsquo;Contributor License Agreement&rsquo;
          (CLA) is often assumed to mean that the relevant foundation or
          corporation acquires intellectual property rights in the
          contribution -- something that the Eclipse Foundation has
          never done.</li>
        <li>Moving to and including the text of the Linux
          Foundation&rsquo;s Developer Certificate of Originality meant that
          the ECA is now based on terms which are widely known
          throughout the software industry.</li>
      </ul>
    </li>
    <li><em>Devoxx US:</em> Working with the worldwide Devoxx community, the
      Eclipse Foundation produced the first Devoxx US, co-located with a
      one day Eclipse Converge event. We were delighted with the
      positive feedback we received from the Devoxx community on
      bringing the Devoxx brand to North America.</li>
  </ul>
  <h2>Membership</h2>
  <p>The Eclipse Foundation has eleven (11) strategic members,
    including CA Technologies, CEA List, Codenvy, Ericsson, IBM, itemis
    AG, Obeo, Oracle, Red Hat, Robert Bosch GmBH, and SAP. </p>
  <p>Of note, the Eclipse Foundation also counts close to 1400
    committers as members. Committers are an important membership class
    for the Foundation, as represented by the Board seats granted to
    them. </p>
  <p>The Foundation finished 2016 with 260 member companies. By the
    end of April 2017, that number increased to 262 member companies. A
    total of 36 new companies joined as new members of the Foundation
    from May 1, 2016 through April 30, 2017, including</p>
  <p>Associacao de Usuarios da Tecnologia Java SouJava, Booz Allen
    Hamilton, Bridging IT GmbH,CMind Inc, Create-Net, DePaul University,
    Deutches Zentrum, Docker Inc, Faculty of Mathematics and Information
    Science, Warsaw University of Technology, fortiss GmbH, InterSystems
    Corp, Iotracks Inc., IRISA, ITK Engineering AG, L'Embarque, London
    Java Community, M&atilde;elardalen, Northern Alberta Institute of
    Technology (NAIT), OFFIS e.V, openHAB Foundation, Payara,
    Professional Science Masters GIS Temple University, PTA GmbH,
    RepreZen, SalesForce.com, Inc., Samsung Semiconductor Inc, Sherpa,
    SMT.Kumudben Darbar College of Commerce, Science and Management
    Studies, Splendit IT-Consulting GmbH, SSI Schaefer IT Solutions
    GmbH, Synchrotron Soleil, Telecom Saint-Etienne, Terranodo, LLC,
    Universitat Oberta Catalunya, University of Gothenburg, Webtide.</p>

  <h3>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>
  <p><strong>Internet of Things (IoT)</strong> The Eclipse IoT Working Group is a community of organizations
    and individuals building open source technology that is used to
    build IoT solutions. Eclipse IoT has 29 different open source
    projects and 32 members of the working group. The technology
    portfolio include technology for embedded constrained devices, IoT
    gateways, and IoT cloud platforms.</p>
  <p>A number of new projects joined the Eclipse IoT community in
    the past year, including</p>
  <ul>
    <li>Eclipse Kapua, a modular IoT cloud platform to manage and
      integrate device data</li>
    <li>Eclipse ioFog, a microservice framework for ioT edge
      computing</li>
    <li>Eclipse Unide, a project to standardize a protocol, called
      PPMP, for industrial machine performance monitoring</li>
    <li>Eclipse Agail, an EU resarch project focused on improving
      the out-of-box experience in IoT gateways</li>
    <li>Eclipse Ditto, a framework for creating IoT digital twins</li>
  </ul>
  <p>The Eclipse IoT Working Group also undertakes a number of
    community outreach and development programs, including the
    following:</p>
  <ul>
    <li>Eclipse IoT Days were hosted in London UK, Ludwigsburg
      Germany, Grenoble France and San Jose USA.</li>
    <li>The Open IoT Challenge attracted 80 proposals to build IoT
      solutions based on open source and open standards.</li>
    <li>In April 2016, the WB published the results of the second <a
      href="https://www.slideshare.net/IanSkerrett/iot-developer-survey-2016">IoT
        Developer Survey</a>. The results of this survey have been viewed
      over 20,000 times and downloaded over 700 times from Slideshare.
    </li>
    <li>The Eclipse IoT Working Group published a new white paper
      titled <a
      href="https://iot.eclipse.org/white-paper-iot-architectures">The
        Three Software Stacks Required for IoT Architectures</a>. The white
      paper has become a powerful resource for explaining the software
      requirements for building IoT solutions, and how Eclipse IoT open
      source technology meets these requirements.
    </li>
  </ul>
  <p><strong>LocationTech, </strong>hosted by the Eclipse Foundation, is a working group developing
    technologies with spatial awareness. Now in its fourth year,
    LocationTech continued to grow and mature, and now includes 19
    members and 16 projects. During the past 12 months, a number of
    major milestones were achieved, including significant releases by a
    number of projects. </p>
  <p>Strategic members of the LocationTech working group include
    Boundless, IBM, Oracle, and Red Hat. Participant solutions members
    include: Azavea, Booz Allen, Boundless, CartoDB, CCRi, OGC, Planet,
    RadiantBlue, SensorUp, Terranado, and VividSolutions.</p>
  <p>New members in the past year include Booz Allen, Terranado,
    DePaul University, and Temple University. </p>
  <p>Of note, GeoTrellis, GeoGig, SFCurve and Spatial4j, all key
    projects that were contributed to LocationTech in previous years,
    completed their incubation and released their initial version under
    the Eclipse process. The GeoMesa project had its second major
    release in 2016.</p>
  <p>The fourth annual LocationTech Tour was a big success. There
    were 15 events globally, with over 1,500 people participating.</p>
  <p>The Eclipse Foundation organized FOSS4G North America 2016 on
    behalf of LocationTech and OSGeo. The conference was a huge success,
    drawing more than 550 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 2016, hosted in Washington
    D.C. This was the second year in a row for this event, and featured
    an excellent program with tracks dedicated both to government and
    industry speakers. The event was hosted by the American Red Cross,
    and was well attended.</p>
  <p>The <strong>Science Working Group</strong> (SWG), hosted by the Eclipse Foundation,
    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
    third year of operation. It has grown to 15 members and 10 projects.
    This report covers the period from March 2016 to March 2017.</p>
  <p>The group has the following members:</p>
  <ul>
    <li>Steering Committee members: Kichwa Coders, Itema, Oak Ridge
      National Laboratory, Diamond Light Source and IBM</li>
    <li>Participating members: Lablicate, Clemson University, The
      Facility for Rare Isotope Beams, Uppsala University,
      Tech&rsquo;Advantage, IFP Energies Nouvelles, iSencia Belgium, Airbus
      and Open Analytics</li>
  </ul>
  <p>New members this year include Soleil Synchrotron.</p>

  <p>MARINTEK was merged into a new organization in January 2017 and
    is no longer a member.</p>

  <p>The Science Working Group hosts the following projects:</p>

  <ul>
    <li>Eclipse 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>Eclipse ICE. This project provides capabilities for
      modeling and simulation including setting up the model, launching
      the job, analysing the results, and managing the input and output
      data.</li>
    <li>Eclipse ChemClipse. This is an Eclipse RCP chemistry
      application designed to handle analytical data from
      chromatographic/spectrometric systems like GC/MS or GC/FID. These
      systems are used to identify environmental pollutants, in
      forensics, to ensure the harmlessness of groceries, or in the area
      of industrial quality control processes, and similar applications.
    </li>
    <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 may include constructing 3D geometries or
      volume meshes of physical space. The post-processing side may
      include visualizing those geometries and meshes, plotting results,
      analyzing images, and visualizing real data.</li>
    <li>Eclipse Rich Beans. This project allows user interfaces to
      be created from beans or graphs of beans. The user interface
      available has standard widgets that have few dependencies to
      reuse. For example, there are widgets for editing numbers with
      bounds validation and 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>Eclipse Triquetrum. The project 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's actions in a
      scientific workbench UI. It will define and execute models -- from
      personal pipelines with a few steps, to massive models with
      thousands of elements.</li>
    <li>Eclipse January is a set of libraries for handling
      numerical data in Java. It is inspired in part by NumPy and aims
      to provide similar functionality.</li>
  </ul>

  <p>In its third year the following projects joined the working
    group:</p>

  <ul>
    <li>The Eclipse TeXlipse project provides an Eclipse extension
      to support LaTex projects, so that document preparation can be
      incorporated into the normal Eclipse development activities. This
      project is not yet active as the IP process has not been
      completed.</li>
    <li>Eclipse StatET offers a set of mature tools for R coding
      and package building. This includes a fully integrated R console,
      R script editors, a R graphics view, an object viewer, a visual
      debugger, interaction with remote R installations and more.</li>
    <li>Eclipse Scanning allows experiments to be conducted by
      coordinating the operation of scientific instruments, such as
      motors or detectors. It sequences the movements of these
      instruments (or devices) in order to scan different parts of the
      experimental space. For instance you might scan a temperature
      controller to conduct an experiment at different temperatures or
      move a goniometer through a range of optical angles or combine the
      two in a two dimensional scan. Scanning is useful as an open
      source project because the algorithms that complete scans during
      experiments are the same in many areas of research. Hardware is
      experiment specific, so scanning algorithms can be used in many
      settings where electronically controlled hardware does automated
      experiments.</li>
  </ul>
  <p>The group hosted an Unconference at EclipseCon France in June
    2016. There were four talks for the Science track at the conference.</p>
  <p>In order to facilitate and encourage cooperation between the
    various science related projects, a new top level project; Science,
    was created in October 2016. This hosts most of the Science Working
    Group&rsquo;s projects.</p>
  <p>Also in October 2016, the group coordinated a common release
    for some of its projects. The aim was to make the working group more
    visible and ensure that some of the projects depending on each other
    were synchronized. A joint press statement was released by the
    Eclipse Foundation and Oak Ridge National Labs on the topic of the
    release.</p>
  <p>
    In October 2016, the group ran a full day workshop as part of the <a
      href="https://indico.esss.lu.se/event/357/page/11">NOBUGS 2016</a>
    conference held in Denmark. The workshop featured talks and
    tutorials on a number of Eclipse projects (EASE, January, RichBeans,
    Scanning, DAWNSci) and was well attended by users from many
    synchrotron and other scientific facilities.
  </p>
  <p>There were two talks in the Science and LocationTech track at
    EclipseCon Europe in October 2016, plus a very popular science
    related keynote &#8211; &rsquo;Observation of Gravitational Waves from Binary
    Black Hole Mergers - Dawn of a New Astronomy.&rsquo; The group also
    participated in the Unconference prior to the conference.</p>
  <p>In November 2016 the group was the focus of the Eclipse
    Newsletter, which featured five stories about the group&rsquo;s projects.</p>
  <p>There were two science related presentations by group members
    at Eclipse Converge in San Jose in March 2017.</p>
  <p>The steering committee continued to elect a chair and a
    secretary to help with running the group. Tracy Miranda was elected
    chair and Torkild Ulv&oslash;y Resheim was re-elected secretary. Both will
    serve for a period of one year, until the next election. We would
    like to thank Jay Jay Billings of Oak Ridge National Labs for his
    excellent service as the previous chair.</p>
  <p>We would also like to thank Andrea Ross for her service helping
    the working group since its inauguration. Mike Milinkovich is now
    the Eclipse Foundation liaison for the group.</p>
  <p>
    The <strong>Eclipse Long-Term-Support Working Group</strong> continues to see slow but
    steady growth. In the last 12 months, Robert Bosch Gmbh has joined
    the working group as a steering committee member. The related
    Eclipse infrastructure appears to be sufficient at this point in
    time. Due to the departure of IBM&rsquo;s Pat Huff, the chair position was
    transferred to Lisa Lasher (IBM).Website: <a
      href="https://lts.eclipse.org/">https://lts.eclipse.org</a>
  </p>
  <p>The Eclipse <strong>openMDM</strong> (measured data management) working group wants to
    foster and support an open and innovative ecosystem providing tools
    and systems, qualification kits, and adapters for standardized and
    vendor independent management of measurement data in accordance with
    the ASAM ODS standard.</p>
  <p>
    In the past 12 months, the <a href="https://www.openmdm.org/">openMDM
      group</a> has focused on building its first demonstrators and revising
    the existing code base. The projects are now in a state where the
    code base can be downloaded from the <a
      href="https://projects.eclipse.org/projects/technology.mdmbl">Eclipse
      mdmbl project</a> and installed in a restricted way due to some
    infrastructure prerequisites.
  </p>
  <p>Mr. Sven Wittig from Audi has succeeded the former chair of the
    working group, Gerwin Matthwig. He has helped to initiate the hiring
    of a product manager (Toolkit Manager) for the group as well as a
    standing development team funded by the working group. The current
    plan is to issue a 1.0 release in the fall of 2017.</p>
  <p>New member Bridging IT GmbH joined the working group in the
    spring of 2017.</p>
  <p>The <strong>PolarSys Working Group</strong> focuses on providing open source
    development solutions for Software and Systems Engineering. It has
    28 members and 14 projects hosted on the PolarSys forge. New members
    in the period include TM Forum, Universitat Oberta de Catalunya,
    Sherpa Engineering, and CMind Inc.</p>
  <p>
    In 2016, <a href="http://polarsys.org/%20">PolarSys members</a> worked
    together to refine the WG vision and mission statements and to
    improve the WG governance with emphasis on an end-user orientation.
    The central change is to extend the scope of the WG to Software
    Engineering, and to define the focus of PolarSys on product
    management of end-user solutions.
  </p>
  <p>
    During the past 12 months, PolarSys members continued to improve the
    <a href="https://www.polarsys.org/solutions">PolarSys
      established solutions</a> (Capella and Papyrus) with a focus on
    product management and usability. PolarSys sponsored exhibit booths
    at the <a href="http://www.incose.org/symp2016/home">Incose
      Symposium</a>, <a href="http://models2016.irisa.fr/">Models 2016</a>,
    and EclipseCon Europe 2016 in order to promote these solutions.
  </p>
  <p>Several new projects enriched the PolarSys ecosystem: Polarsys
    B612, the open source font designed for readability; PolarSys NG661
    to design and simulate ARINC661 Human Machine Interfaces; the
    PolarSys Rover to put together educational resources related to
    PolarSys solutions; and PolarSys Time4Sys, a tool to capture timing
    aspects in the design phase of a real-time system.</p>
  <p>
    This period was also the first year of operation of the <a
      href="https://www.polarsys.org/papyrus-ic/">Papyrus Industry
      Consortium</a>, a PolarSys hosted industry consortium (IC) of 14
    members dedicated to the advancement of the Papyrus ecosystem. The
    Papyrus IC sponsored exhibit booths at different conferences
    including <a
      href="http://www.site.uottawa.ca/~damyot/ICCSE2016/ICCSE2016-Program.pdf">the
      annual conference of Incose canadian chapter</a> and <a
      href="http://models2016.irisa.fr/">Models 2016</a> and had a
    central place at the <a
      href="https://www.polarsys.org/sites/default/files/users/user233/Ericsson-Modeling-Days-Sept-13-14-2016-Final-Program.xls_.pdf">Ericsson
      Modeling Days 2016</a>. All the committees of the Papyrus IC were
    active this year including the Steering Committee, the Architecture
    Committee, the Product Management Committee, and the Research
    Committee. This greatly helped build the collaborative ecosystem
    around Papyrus. Product Management activity resulted in the creation
    of Papyrus for Information Modeling, a customized tool streamlined
    for users interested in modeling the static structure of information
    with UML class diagrams. Product Management activity also resulted
    in a good description of the <a
      href="https://www.polarsys.org/papyrus-ic/products">Papyrus
      Industry consortium Product Line</a>. Lastly, the research consortium
    coordinated <a
      href="https://wiki.polarsys.org/Papyrus_IC/Research_Academia/Webinars">14
      webinars</a> covering both research and industry topics.
  </p>
  <p>With the success of the Papyrus Industry Consortium, PolarSys
    members are now creating the Capella Industry Consortium to foster
    the development of the Capella ecosystem. This Capella Industry
    Consortium will start operating in the next period and we expect new
    members to join in this context.</p>
  <p>At the beginning of 2017, the PolarSys Steering Committee was
    re-elected, since Ericsson withdrew from the leadership of both
    PolarSys and the Papyrus Industry Consortium. Existing user members
    quickly stepped in to take the responsibilities of PolarSys chair
    (Beno&icirc;t Langlois from Thales) and Papyrus IC chair (Xavier Plavis
    from Airbus). In addition, leading suppliers Charles Rivet from
    Zeligsoft and Etienne Juliot from Obeo lead the marketing activities
    and the technical consistency of PolarSys solutions respectively.</p>
  <p>The Eclipse <strong>openPASS Working Group</strong> was initiated in August 2017 by three
    German car manufacturers: BMW, Daimler, and Volkswagen.</p>
  <p>The rise of advanced driver assistance systems and partially
    automated driving functions leads to the need of virtual simulation
    to assess these systems and their effects. This especially refers,
    but is not limited, to safety effects in traffic. There are various
    methods and tools for prospective evaluation of safety systems with
    respect to traffic safety. Implementing the methodology by creating
    and maintaining the SIM@openPASS platform will support reliability
    and transparency of results obtained by simulation. The growing
    number, complexity, and variety of those vehicle functions make
    simulation an essential part in research, development, testing,
    public rating, and homologation and is thus, directly or indirectly,
    required by all stakeholders in vehicle safety, including
    manufacturers, suppliers, insurance companies, legislators, consumer
    advocates, academia.</p>
  <p>
    The <a href="https://wiki.eclipse.org/OpenPASS-WG">Eclipse
      openPASS working group</a> is the driving force behind related
    development of core frameworks and modules. The Eclipse openPASS WG
    endeavors to make sure that openPASS related Eclipse projects are in
    line with external important developments. The goal is a broad
    availability of different modules.
  </p>
  <p>Work on the related <a href="https://projects.eclipse.org/proposals/simopenpass">Eclipse simopenpass project</a> started immediately after the
    creation of the working group and was mostly executed by the fourth
    founding member, the Munich based company ITK Engineering GmbH.
    While there are still issues with the existing code base, the car
    manufacturers have started installing and using the code base.</p>
  <p>For the future we expect code consolidation and growth of the
    related ecosystem.</p>
  <p><strong>Automotive. </strong>The Eclipse Automotive Working Group is now officially defunct.
    OpenMDM and OpenPASS are the new Eclipse Working Groups in the
    Automotive domain with more focused activities. Other working groups
    will be added in the future.</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>EclipseCon France was held in June 2016 and had 245 attendees.
    The conference was extended by an extra day, with three full days of
    conference sessions. The Unconference, always well attended at
    EclipseCon France, was held after the main sessions for the first
    time this year. The feedback from attendees was very positive,
    including feedback regarding both keynotes &#8211; the first by Thomas
    Guenoux, founder of CommitStrip, who gave a very entertaining and
    engaging &rsquo;Explaining Code to my Mom,&rsquo; and the second by Johan
    Stokking on the initiative he is leading to build an open source
    crowd-sourced IoT network. </p>
  <p>EclipseCon Europe celebrated its eleventh anniversary in
    October 2016, with 618 people in attendance, the largest audience
    yet. This event was co-located with the OSGi Community Event, and
    included a great collection of technical sessions, BoFs, the IoT
    Playground, and a gripping talk by Stephen Carver illustrating the
    problems that led to the space shuttle disasters and the critical
    importance of communication and leadership in large scale projects.
    The conference also hosted a number of dedicated events, including
    the IoT Day, the CDT Summit, and Project Quality Day. Feedback from
    the conference from both attendees and sponsors continues to be very
    strong, with many stating this was the best EclipseCon conference
    yet. </p>
  <p>In March 2017, the Foundation hosted and organized Devoxx US.
    Devoxx is a well known vendor neutral conference series based in
    Europe, and Devoxx US was the first introduction of the Devoxx brand
    and format to North America. In conjunction with Devoxx US, the
    Foundation also held a one-day Eclipse Converge conference, which
    was run as a smaller EclipseCon event. An Eclipse IoT Day was held
    concurrently with Eclipse Converge, as was DevRelConf, a half-day
    developer relations conference. Collectively, the events had a very
    strong technical content covering a broad range of topics, including
    both more traditional EclipseCon-type material as well as a
    significant number of speakers well known in the Devoxx community.
    Collectively, 661 attendees participated in the events. Feedback
    from the attendees was generally positive overall, with many noting
    the quality of the talks and the many exhibitors. There was general
    feedback from both attendees and sponsors that the lower than
    expected number of attendees had a negative impact on the overall
    experience.</p>
  <p>As noted in last year&rsquo;s annual report and included here for
    completeness, the Eclipse Foundation and LocationTech acted as host
    and organizer for FOSS4G NA, held in Raleigh, NC in May, 2016. The
    conference attendance grew from 430 in 2015 to 558 in 2016, and
    feedback was generally very positive. The conference included a
    poster and map session, a PostgreS Day, and a two-day code sprint.
    Approximately 30% of the attendees were women, which is more than
    double the historical proportion for FOSS4G conference. FOSS4G NA
    will next be held again in 2018, and will again be organized by
    Eclipse Foundation and LocationTech. </p>
  <p>In addition to the conferences noted, the Foundation grew its
    2016 Eclipse DemoCamps series to 19 cities across 9 countries, which
    is an increase of 18% over 2015. These events are led by the
    community, and serve as a great way to introduce Eclipse
    technologies to new users.</p>
  <h2>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.<br /> <br />Membership renewals remained strong, and
    working group revenue and website advertising both continued to
    grow. The organization continues to be on a solid financial footing.

  </p>
  <p>Looking forward to 2017, the Board has approved a budget
    forecasting a $0.5M loss, and a significant growth in headcount.</p>
  <p></p>
  <table class="table" border="0" cellspacing="0" cellpadding="0">
    <thead>
    <tr>
      <th>In US $ millions</th>
      <th>2014</th>
      <th>2015</th>
      <th>2016</th>
      <th>2017 Budget</th>
      <th></th>
    </tr>
    </thead>
    <tr>
      <td>Revenue</td>
      <td>4.3</td>
      <td>4.9</td>
      <td>5.4</td>
      <td>6.3</td>
      <td></td>
    </tr>
    <tr>
      <td>Expenses</td>
      <td>4.7</td>
      <td>4.0</td>
      <td>5.6</td>
      <td>6.8</td>
      <td></td>
    </tr>
    <tr>
      <td>Net Income</td>
      <td>(0.4)</td>
      <td>0.0</td>
      <td>(0.2)</td>
      <td>(0.5)</td>
      <td></td>
    </tr>
  </table>
  <h2>Intellectual Property Management</h2>
  <p>During the time period spanning April 1, 2016 to March 31,
    2017, the Eclipse Foundation received 1,933 requests for
    intellectual property review and completed 1,894 reviews. As more
    open source projects come on board, the need for code review
    continues to grow, particularly for the Eclipse Foundation&rsquo;s working
    groups. In early 2017, the backlog of open IP review requests dipped
    briefly below the 100 mark; as of April 2017, however, the backlog
    of IP review requests is 165 (about half of what we had at the same
    time last year).</p>
  <p><img class="img-responsive" src="/images/reports/2017_open_cq.png" alt="Open CQs Over Time (May 2014 to May 2017)" /></p>
  <p>The Eclipse Intellectual Property Policy was updated in 2016 to
    include two types of IP Due Diligence for the third-party software
    used by open source projects hosted by the Eclipse Foundation. <em>Type A</em> Due
    Diligence involves a license certification only and <em>Type B</em> Due
    Diligence provides our traditional license certification, provenance
    check, and code scan for various sorts of anomalies. Prior to this
    change, project teams would have to wait until the full application
    of what we now call Due Diligence was complete before issuing a
    release. Now, a project team can opt to push out a <em>Type A</em> release
    after having all of their third-party libraries license certified.</p>
  <p>All new projects start using Type A due diligence, but a
    project team can decide what level of IP Due Diligence they require
    for each release. Hypothetically, a project team could opt to make
    several <em>Type A</em> releases followed by a <em>Type B</em> release, and then switch back.
  </p>
  <p>We&rsquo;ve solicited a few existing projects to try out the new IP
    Due Diligence type and have already approved more than 100
    third-party libraries as Type A.</p>
  <p><img class="img-responsive" src="/images/reports/2017_third_party_cq.png" alt="Third Party CQs by Type Created Between May 2014 to May 2017" /></p>
  <p>As of the end of March 2017, we have twenty five projects
    designated as <em>Type A</em> (all new projects are being designated as
    such). As we move forward, we expect that all new projects will
    employ <em>Type A</em> Due Diligence for all incubation releases and then
    decide whether or not to switch to <em>Type B</em> (license certification,
    provenance check, and code scan) for their graduation. There is, of
    course, no specific requirement to switch at graduation or ever, but
    we&rsquo;re going to encourage project teams to defer the decision of
    whether or not to switch from Type A until that point.</p>
  <p>The Eclipse IoT and Technology Top Level Project accounts for
    more half of the intellectual property reviews initiated between
    April 1, 2016 and March 31, 2017. This aligns well with the rates of
    new project creation in those Top Level Projects (approximately 60%
    of all new projects created in in that time frame were created under
    Eclipse Technology and Eclipse IoT).</p>
  <p><img class="img-responsive" src="/images/reports/2017_cq_tlp.png" alt="CQs by TLP between 2016-04-01 and 2017-03-31" /></p>
  <p>As the primary incubator for new projects, it&rsquo;s natural that
    the Eclipse Technology Top Level Project is the leading source of
    requests for intellectual property review. The Eclipse Open Standard
    Business Platform project stands out as the high consumer of
    intellectual property resources from the Eclipse Technology Project.
    The rapid growth of the IoT project space translates into high
    individual project representation in the &rsquo;top-ten&rsquo; consumers of
    intellectual property resources, including Eclipse Kapua, Eclipse
    hawkBit, Eclipse Hono, Eclipse Kura, and Eclipse SmartHome. There
    was also very high intellectual property activity for new projects
    and new activity in the Eclipse Cloud Development (primarily from
    the Eclipse Che project), and LocationTech Top Level Projects.</p>
  <p><img class="img-responsive" src="/images/reports/2017_cq_project.png" alt="CQs by Project between 2016-04-01 and 2017-03-31" /></p>
  <h2>Innovation</h2>
  <h3>Oxygen Simultaneous Release</h3>
  <p>In June 2016 the Eclipse community shipped Neon, its eleventh
    annual simultaneous release. Including previous releases of the
    Eclipse Platform, this was the thirteenth release that was shipped
    on time, to the day. Eighty-four projects participated in the Neon
    simultaneous release The release comprises 69 million lines of code
    produced by 326 committers from 46 member companies, with
    contributions from 461 non-committer contributors.</p>
  <p><img class="img-responsive" src="/images/reports/2017_simultaneous_release.png" alt="Simultaneous Release Metrics" /></p>
  <p>Eight projects joined the simultaneous release: Eclipse VIATRA,
    Eclipse PMF, Eclipse EclEmma, Eclipse USS SDK, Eclipse LSP4J,
    Eclipse LSP4E, and Eclipse Triquetrum. The Eclipse EMF Validation,
    Query, and Transaction projects all merged into a single Eclipse EMF
    Services project, and the Eclipse GMF Notation project merged into
    the Eclipse GMF Runtime project. The project teams from Eclipse
    Riena, Eclipse Thym, Eclipse Andmore, Eclipse Gyrex Project, and
    Eclipse GMF Tooling decided to drop out of the simultaneous release.</p>
  <p>This predictable release schedule has been a key part of the
    Eclipse Community's success over the years, and is an important part
    of the success of the Eclipse ecosystem.</p>
  <h3>Science Top Level Project</h3>
  <p>In 2016, the Eclipse Foundation created the Science Top Level
    Project with the following projects:</p>
  <ul>
    <li>Eclipse Advanced Visualization Project</li>
    <li>Eclipse ChemClipse</li>
    <li>Eclipse DAWNSci</li>
    <li>Eclipse January</li>
    <li>Eclipse Rich Beans</li>
    <li>Eclipse Scanning</li>
    <li>Eclipse StatET: Tooling for the R language</li>
    <li>Eclipse TeXlipse</li>
    <li>Eclipse Triquetrum</li>
    <li>The Eclipse Integrated Computation</li>
  </ul>

  <h3>Other</h3>
  <p>In addition to the projects noted above, the following projects
    were proposed at the Eclipse Foundation in 2016:</p>
  <ul>
    <li>The <strong>Eclipse Agail</strong> is a language-agnostic, modular software
      gateway framework for the Internet of Things with support for
      protocol interoperability, device and data management, IoT apps
      execution, and external Cloud communication.</li>
    <li>The <strong>Eclipse Apogy</strong> open source project provides a set of
      frameworks, EMF models, and Graphical User Interface components
      that simplify the creation of the software required to operate a
      physical system.</li>
    <li>The <strong>PolarSys B612</strong> project provides a fully open-sourced
      font and its variants plus a leaflet. This font is designed for
      enhanced readability and comfort and safety (protection against
      reading errors).</li>
    <li><strong>Eclipse Capra</strong> is a dedicated traceability management tool
      that allows the creation, management, visualisation, and analysis
      of trace links within Eclipse. </li>
    <li><strong>Eclipse EclEmma</strong> is a Java code coverage tool that provides
      code coverage analysis directly in the Eclipse workbench.</li>
    <li>The <strong>Eclipse Edje</strong> project provides a standard hardware
      abstraction Java API required for delivering IoT services that
      meet performance and memory constraints of microcontroller-based
      devices. </li>
    <li><strong>LocationTech GeoPeril</strong> merges complementary external and
      in-house cloud-based services into one platform for automated
      background GPU computation, for web-mapping of hazard specific
      geospatial data, and for serving relevant functionality to handle,
      share, and communicate threat specific information in a
      collaborative and distributed environment.</li>
    <li><strong>Eclipse Hono</strong> provides a uniform (remote) service interface
      that supports both the Telemetry as well as Command &amp; Control
      message exchange pattern requirements.</li>
    <li>The <strong>Eclipse ioFog</strong> set of technologies is a fog computing
      layer that can be installed on any hardware running Linux.</li>
    <li><strong>Eclipse January</strong> is a set of libraries for handling
      numerical data in Java. It is inspired in part by NumPy and aims
      to provide similar functionality.</li>
    <li>The <strong>Eclipse JDT Language Server</strong> project provides a language
      server protocol implementation for the Java language.</li>
    <li><strong>Eclipse JNoSQL</strong> provides several tools to make easy an
      integration between the Java Application with the NoSQL.</li>
    <li><strong>Eclipse Kapua</strong> is a modular integration platform for IoT
      devices and smart sensors that aims at bridging Operation
      Technology with Information Technology. </li>
    <li><strong>Eclipse Keti</strong> is a service that was designed to protect
      RESTfuls API using Attribute Based Access Control (ABAC).</li>
    <li><strong>Eclipse LSP4E</strong> includes the necessary code to integrate any
      language server in the Eclipse IDE, interacting with the language
      server</li>
    <li><strong>Eclipse LSP4J</strong> is a Java implementation of VSCode's language
      server protocol intended to be consumed by tools and language
      servers implemented in Java.</li>
    <li>The <strong>Eclipse MicroProfile</strong> project is aimed at optimizing
      Enterprise Java for the microservices architecture.</li>
    <li><strong>Eclipse Milo</strong> provides all the tools necessary to implement
      OPC Unified Architecture (UA) client and/or server functionality
      in any JVM-based project.</li>
    <li><strong>Eclipse N4JS</strong> adds a static type system similar to that of
      Java to ECMAScript 2015. This type system support nominal and
      structural typing, in both cases supporting generics similar to
      that of Java 8.</li>
    <li>The <strong>PolarSys NG661</strong> Designer project provides an open source
      tool that allows to specify and simulate HMI using the ARINC661
      Part 2 Language.</li>
    <li>The <strong>Eclipse OMR</strong> project consists of a highly integrated set
      of open source C and C++ components that can be used to build
      robust language runtimes that will support many different hardware
      and operating system platforms.</li>
    <li>The <strong>Eclipse Open Standard Business Platform</strong> (OSBP)
      comprises a model-based software factory composed of extensible
      frameworks, tools and runtime environments for building, deploying
      and managing business applications across their lifecycles.</li>
    <li><strong>Eclipse Papyrus-xtUML</strong> is a tool that supplies the
      capability to edit, execute and translate xtUML models.</li>
    <li>The <strong>PolarSys Rover</strong> provides educational material including
      models, code and documentation to demonstrate the usage of
      PolarSys solutions for the architecture, design, development and
      test of a simple rover system inspired by both Mars exploration
      and crisis management missions.</li>
    <li><strong>LocationTech Proj4J</strong> is a Java port of the widely used
      Proj.4 library for coordinate reprojection. </li>
    <li><strong>LocationTech Raster Processing Engine</strong> designed to stage
      tiles of raster data into memory for use by a processing chain.</li>
    <li><strong>Eclipse Scanning</strong> allows experiments to be conducted by
      coordinating the operation of scientific instruments, for example
      motors or detectors.</li>
    <li><strong>Eclipse sim@openPASS</strong> provides a software platform that
      enables the simulation of traffic situations to predict the
      real-world effectiveness of advanced driver assistance systems or
      automated driving functions.</li>
    <li><strong>Eclipse StatET</strong> is an Eclipse Platform-based IDE for R.</li>
    <li><strong>Eclipse SW360</strong> is a software catalogue system to ease the
      management of software components in organizations.</li>
    <li>The <strong>Eclipse TeXlipse</strong> project provides an Eclipse extension
      to support LaTeX projects, so that document preparation can be
      incorporated into the normal Eclipse development activities.</li>
    <li><strong>PolarSys Time4Sys</strong> provides a framework that fills the gap
      between the capture of timing aspects in the design phase of a
      real-time system and the ability of specific/dedicated tools to
      verify the consistency and performances of a given scheduling.</li>
    <li><strong>Eclipse TM4E</strong> includes the necessary code to easily set up
      syntax highlighting for a wide diversity of languages in the
      Eclipse IDE, but reusing TextMate grammars.</li>
    <li><strong>Eclipse Unide</strong> provides a lightweight Production Performance
      Management Protocol (PPMP) server-client implementations (using
      JSON, REST and other).</li>
    <li>The <strong>Eclipse USS SDK</strong> provides a Java implementation of the
      USS REST API to allow for easy use of the Eclipse User Storage
      Service (USS) by Eclipse Foundation projects.</li>
    <li><strong>Eclipse Whiskers</strong> is an OGC SensorThings API framework
      consisting of a JavaScript client and a light-weight server for
      IoT gateways.</li>
    <li><strong>Eclipse Yasson</strong> provides a standard binding layer between
      Java classes and JSON documents.</li>
  </ul>
  <h2>Research</h2>
  <p>Foundation increased its collaboration with academics,
    researchers, and industries by participating in several European
    projects. The Foundation&rsquo;s main objective in these projects is to
    help the consortium build an Open Source platform and community
    around the EU project.</p>

  <p>The positive side effects are</p>
  <ul>
    <li>EF recognition as an expert in building OS communities</li>
    <li>The opportunity to bring new academic and industrial
      members to the Foundation</li>
    <li>The occasion to promote and disseminate existing Eclipse
      projects into such international consortia</li>
  </ul>

  <p>Today the Eclipse Foundation Europe is a partner in seven large
    European research projects:</p>
  <ul>
    <li><a href="http://www.amalthea-project.org/">Amalthea4Public</a>:
      Started in fall 2013 and finishing this fall. This project is
      implementing an Open Platform for Embedded Multicore Systems.</li>
    <li><a href="http://agile-iot.eu/">AGILE-IoT</a>: Started in
      January 2016. This implementation 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>
    <li><a href="http://www.basys40.de/">BaSys 4.0</a>: Started in
      fall 2016. The goal of BaSys 4.0 is the creation of an Industry
      4.0 base system for factories to ensure efficient transformations
      in the production processes.</li>
    <li><a href="https://www.crossminer.org/">Crossminer</a>:
      Started in January 2017. CROSSMINER enables the monitoring,
      in-depth analysis, and evidence-based selection of open source
      components, and facilitates knowledge extraction from large
      open-source software repositories.</li>
    <li><a href="http://robmosys.eu/">RobMoSys</a>:
        RobMoSys envisions an integrated approach built on top of the
        current code-centric robotic platforms, by applying model-driven
        methods and tools. </li>
    <li><a href="https://itea3.org/project/appstacle.html">Appstacle</a>:
      Started in April 2017. APPSTACLE stands for open standard
      APplication Platform for carS and TrAnsportation vehiCLEs.
      Appstacle aims to establish a standard car-to-cloud connection,
      open for external applications and the use of open source software
      wherever possible without compromising safety and security.</li>
  </ul>

  <p>
    Eclipse also created a research consortium named <a
      href="https://projects.eclipse.org/projects/modeling.gemoc">GEMOC</a>.
    This open and international initiative aims to coordinate and
    disseminate the research results regarding the support of the
    coordinated use of various modeling languages that will lead to the
    concept of the globalization of modeling languages.
  </p>
  <h2>Committer and Project Community</h2>
  <p>Our number of committers grew past 1,400 in early 2017.</p>

  
  <p><img class="img-responsive" src="/images/reports/2017_committers.png" alt="Committers" /></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've put into place over the past year.</p>

  <ul>
    <li>Servers and Infrastructure: Core service availability (Git,
      www.eclipse.org, and Bugzilla) for 2016 was 99.958%, down from
      99.987% last year.</li>

    <li>Common Build Infrastructure: New major features were added
      this year: Jenkins (known as JIPP) as the CI tool. Stability
      improvements, newer, faster servers and slaves in the Google Cloud
      were also part of the 2016 plan.</li>

    <li>Bandwidth and performance: Our bandwidth cap was increased
      drastically, from 250 Mbps to 350 Mbps, to help cope with the
      increased loads. A new transparent mirroring system will be put in
      place in 2017 to allow retrieving files from local mirrors even
      when a request is made to the Eclipse download servers directly.</li>

    <li>Authentication and Community: In 2016 we became an OpenID
      Connect provider, to allow the various Eclipse websites, as well
      as third party sites and tools, to allow user authentication using
      the Eclipse Foundation&rsquo;s user accounts.</li>

    <li>Developers, Developers, Developers: Eclipse&rsquo;s account
      database now sits at 315,000 accounts, with a growth rate of 3000
      new accounts each month.</li>

    <li>IT work queue: The webmaster and web developer work queues
      have become more manageable since the addition of SysAdmin Derek
      Toolan and release engineer Frederic Gurr.</li>

    <li>USS: The Eclipse User Storage Service was made available
      for the Neon launch, allowing users to store Eclipse preferences
      and settings on Eclipse servers.</li>
  </ul>
</div></div>
</body>

</html>

