<?php
/**
 * Copyright (c) 2015, 2018 Eclipse Foundation and others.
 *
 * This program and the accompanying materials are made
 * available under the terms of the Eclipse Public License 2.0
 * which is available at https://www.eclipse.org/legal/epl-2.0/
 *
 * Contributors:
 * Mike Milinkovich (Eclipse Foundation) - Initial implementation
 * Eric Poirier (Eclipse Foundation)
 * Christopher Guindon (Eclipse Foundation)
 *
 * SPDX-License-Identifier: EPL-2.0
 */
?>
<div id="midcolumn">
  <h1><?php print $pageTitle; ?></h1>
  <p>May 24, 2018</p>
  <p>The Eclipse Foundation, Inc. ("Eclipse Foundation", "Us" or "We") is a member-supported not-for-profit
    foundation which acts as the steward of our open source projects, community, and ecosystem. We are
    committed to our community members’ rights to privacy. We promise to share transparently all aspects
    of how Eclipse Foundation projects and websites work in regards to privacy, terms, and personal data,
    and We are in full support of efforts to ensure your protection online. We only collect your personal
    data with your consent, and collect only as much as We need to provide you the service you request. For
    example, We need your personal data to register you to one of our conferences. Each time We collect
    additional personal data from you We will explain what We collect, why We need it, how We use it, how
    long We keep it, and how We protect it.
  </p>
  <p>You can withdraw consent anytime. We will respect your wishes.</p>
  <h2>Personal Information on Eclipse Foundation Websites</h2>
  <p>As a platform for open source innovation and collaboration, personal information on all Eclipse
    Foundation websites is either meant to be shared, for example records of your contributions to our
    open source projects, or protected, such as your name and email address when you subscribe to
    our newsletter.
  </p>
  <p>Any personal data you share with Us, We protect according to this Privacy policy.</p>
  <h2>Individual Access to Personal Information</h2>
  <p>We will respond within 30 days to your requests to have access to your personal information collected
  by Us. We will promptly correct inaccuracies, as the case may be, and We will delete it and/or anonymize
  it upon your request. Please contact <a href="mailto:privacy@eclipse.org">privacy@eclipse.org</a> to make
  such a request.
  </p>
  <h2>Information Security and Quality</h2>
  <p>We protect the integrity of your personal information with appropriate technical and organizational
    measures, such as using encryption for transmission of certain forms of information, to help keep it
    secure, accurate, current, and complete.
  </p>
  <p>Your personal information may be stored in Canada, the European Union and the United States,
    always with our same high security standards.
  </p>
  <p>One of the primary purposes of the Eclipse Foundation and its websites is to enable collaborative
    open source software development. Doing so necessarily requires Us to maintain records of
    authorship related to all contributions. Any personally identifiable information collected by virtue of
    your contributions will be publicly available on the Internet in unencrypted form and without access
    restriction.
  </p>
  <p>We also offer services to our community which provide the ability for users of Eclipse software to
    store data on Eclipse Foundation servers through services including, but not limited to, the User
    Storage Service and the Automated Error Reporting Initiative. Any data stored through these
    services will be publicly available on the Internet in unencrypted form and without access restriction.
    Therefore, you should not use these services to store passwords, any personally identifiable
    information, any confidential business information, or anything else that you do not want to be
    generally and publicly available.
  </p>
  <h2>Clickstream Data and Cookies</h2>
  <p>We sometimes collect anonymous information from visits and contributions to Eclipse Foundation
    websites to help provide better service. For example, We keep track of the domains from which
    people visit and We also measure visitor activity on Eclipse Foundation websites, but in ways that
    keep the information anonymous. This anonymous information is sometimes known as &quot;clickstream
    data.&quot; We may use and aggregate this data to analyze trends and statistics and to help Us tailor our
    websites to better serve Eclipse participants.
  </p>
  <p>Some Eclipse Foundation website pages use cookies to better serve you when you return to the site.
    You can set your browser to notify you before you receive a cookie, giving you the chance to decide
    whether to accept it. You can also set your browser to turn off cookies. If you do so, however, some
    areas of our sites may not function properly.
  </p>
  <p>Our sites may also set a session cookie to enable them to function properly. In such cases, the
    session cookie will only last for the length of your session, and the only information recorded will be
    that which is necessary to enable the website to function properly, and no personally identifiable
    information will be recorded in the session cookie.
  </p>
  <h2>Business Relationships</h2>
  <p>This website contains links to other website. We are not responsible for the privacy practices or
    the content of such website.
  </p>
  <h2>Notification of Changes</h2>
  <p>This privacy statement was last updated on May 24, 2018. A notice will be posted on this website
    home page for thirty (30) days whenever this privacy statement is changed.
  </p>
  <h2>Questions Regarding This Policy</h2>
  <p>Questions regarding this Privacy policy should be directed to: <a href="mailto:privacy@eclipse.org">privacy@eclipse.org</a>.</p>
</div>
<div id="rightcolumn" class="margin-top-20">
  <div class="sideitem">
    <h6>Related Links</h6>
    <ul>
      <li><a href="index.php">Legal resources</a></li>
      <li><a href="guidetolegaldoc.php">Guide to legal documents</a></li>
    </ul>
  </div>
</div>