<?php
/**
 * Copyright (c) 2015, 2018 Eclipse Foundation.
 *
 * 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:
 * Nathan Gervais (Eclipse Foundation) - Initial implementation
 * Eric Poirier (Eclipse Foundation)
 *
 * SPDX-License-Identifier: EPL-2.0
 */
?>
<div id="ganymedeHeader">
  <div id="headerGraphic">
    <map name="ganymedeHeaderIMap">
      <area shape="rect" coords="71,61,440, 124" href="/ganymede/">
      <area shape="rect" coords="450,60,745,125"
        href="/downloads/packages/release/ganymede/sr2"
      >
    </map>
    <img src="/ganymede/images/ganymedeHeaderThin.jpg"
      usemap="#ganymedeHeaderIMap"
    >
  </div>
</div>
<div id="midcolumn">
  <img src="http://dev.eclipse.org/large_icons/devices/network-wireless.png">
  <h1 class="inline">Ganymede Buzz</h1>
  <div class="homeitem3col">
    <h3>Community Buzz</h3>
    <ul>
      <li><a href="http://www.myeclipseide.com/Article79.html" target="_blank">MyEclipse
          Delivers Advanced Ajax Tools for Ganymede </a> <span class="posted">+371&nbsp;weeks&nbsp;ago</span>
        <p>Genuitec is pleased to announce today the immediate availability of
          MyEclipse Enterprise Workbench 7.0 milestone 1. This milestone release
          delivers advanced Ajax tooling for Java EE and full Application
          Lifecycle Management (ALM) capabilities for Eclipse 3.4 Ganymede,
          among other enhancements.</p></li>
      <li><a
        href="http://www.protecode.com/site/pdf/GA%20Availability%20Press%20Rel.pdf"
        target="_blank"
      >Protecode Annouces General Availability of Governance and Intellectual
          Property Management Software </a> <span class="posted">+376&nbsp;weeks&nbsp;ago</span>
        <p>Protecode Inc., today announced the general availability of its
          software development tool for governance and Intellectual Property
          (IP) management. The latest release enables commercial software
          developers and open source creators to accelerate managed adoption of
          open source code in a simple, painless process. Additionally, the
          software is now available to the Eclipse community for anyone working
          on an active Eclipse project.</p></li>
      <li><a href="http://www.ddj.com/linux-open-source/208802482"
        target="_blank"
      >The Eclipse Ganymede Release </a> <span class="posted">+376&nbsp;weeks&nbsp;ago</span>
        <p>Dr. Dobb's talks to Mike Milinkovich, Executive Director of the
          Eclipse Foundation, about the Eclipse Ganymede release, a coordinated
          release of 23 different Eclipse project teams and represents over 18
          million lines of code.</p></li>
      <li><a href="http://www.froglogic.com/pg?id=NewsEvents&category=98"
        target="_blank"
      >Java GUI Testing Tool Squish Supports New Eclipse "Ganymede" 3.4 </a> <span
        class="posted"
      >+377&nbsp;weeks&nbsp;ago</span>
        <p>
          froglogic GmbH today announced support for automated testing of Java
          Rich Client Platform (RCP) applications based on the new Eclipse 3.4
          release code named Ganymede.<br /> Squish for Java is a leading
          functional GUI and regression testing tool enabling the creation and
          execution of automated GUI tests for Java SWT/RCP and AWT/Swing
          applications.
        </p></li>
      <li><a href="http://www.ecommercetimes.com/story/63659.html"
        target="_blank"
      >Eclipse Release Is Great but Doesn't Reach the Cloud </a> <span
        class="posted"
      >+377&nbsp;weeks&nbsp;ago</span>
        <p>The Eclipse Foundation has delivered a healthy package of updates,
          right on time, for the third year in a row. That's commendable, writes
          contributor Dana Gardner. What he'd really like to see, however, is a
          greater commitment on Eclipse's part to integrate with cloud-based
          development.</p></li>
      <li><a
        href="http://eclipse.dzone.com/articles/eclipse-ganymede-18-million-li"
        target="_blank"
      >Eclipse Ganymede - 18 Million Lines of Code Delivered on Schedule </a> <span
        class="posted"
      >+378&nbsp;weeks&nbsp;ago</span>
        <p>As many of you may know the annual Eclipse release train, called
          Ganymede, is now available. This is the third year in a row that the
          Eclipse community has shipped a coordinate release of multiple
          projects; 23 projects are included this year. An important reason for
          the release trains is to make it easier for Eclipse users and
          adopters, who tend to use multiple projects, to upgrade to a new
          release. A coordinated release schedule makes its possible for timely
          upgrades in the Eclipse community.</p></li>
      <li><a href="http://blogs.zdnet.com/Gardner/?p=2698" target="_blank">Eclipse
          Foundation delivers Ganymede train with 23 cars, but where are the
          cloud on-ramps? </a> <span class="posted">+378&nbsp;weeks&nbsp;ago</span>
        <p>For the third year in a row, the Eclipse community has delivered, on
          the same day as in previous years, numerous software updates across a
          wide range of projects.</p></li>
      <li><a href="http://www.ddj.com/linux-open-source/208800860"
        target="_blank"
      >Eclipse Delivers Annual Release </a> <span class="posted">+378&nbsp;weeks&nbsp;ago</span>
        <p>"Once again the Eclipse community has delivered our annual release
          train and continues to deliver innovative software in a predictable
          manner," said Mike Milinkovich, Executive Director of the Eclipse
          Foundation. "New features like the Equinox p2 provisioning system, new
          modeling tools and tools that support SOA developers will be popular
          features for Eclipse users."</p></li>
      <li><a href="http://www.devxnews.com/article.php/3755391" target="_blank">Eclipse
          Ganymede Makes It Easier for Devs </a> <span class="posted">+378&nbsp;weeks&nbsp;ago</span>
        <p>Some open source efforts are satisfied with releasing one or two
          projects a year. That's not the case with the open source Eclipse
          Foundation, which today released 23 projects as part of its Ganymede
          release train.</p></li>
      <li><a href="http://www.instantiations.com/press/release/080625.html"
        target="_blank"
      >Instantiations Rolls Out Product Updates in Conjunction with Eclipse 3.4
          and Ganymede </a> <span class="posted">+378&nbsp;weeks&nbsp;ago</span>
        <p>Instantiations, Inc., a leading provider of software quality and
          productivity solutions for the Eclipse platform, today announced that
          its entire Eclipse-based product line has been updated to coincide
          with the annual Eclipse open source release, Ganymede. Included with
          the roll-out are significant additions in the area of security to its
          CodePro
          AnalytiX&Atilde;&fnof;&Acirc;&cent;&Atilde;&cent;&acirc;&sbquo;&not;&Aring;&frac34;&Atilde;&sbquo;&Acirc;&cent;
          comprehensive code quality product, bringing advanced standards-based
          security auditing to developers desktops as they write code. The
          Ganymede release train includes Eclipse 3.4, the annual release of the
          Eclipse platform, which was delivered today.</p></li>
      <li><a href="http://www.emediawire.com/releases/2008/6/prweb1055254.htm"
        target="_blank"
      >Migrate Easily to Eclipse 3.4 Ganymede, Manage Configurations with Pulse
      </a> <span class="posted">+378&nbsp;weeks&nbsp;ago</span>
        <p>
          Genuitec, LLC, a founding member of the Eclipse Foundation, announced
          today the general availability of Pulse 2.2, the free and easiest way
          to obtain, manage and configure Eclipse Ganymede and plugins. <br />Genuitec
          is pleased to offer this product to Pulse users on the day of the
          Ganymede release. As of today, Pulse 2.2 will support full Ganymede
          tool stacks.
        </p></li>
      <li><a href="http://tasktop.com/blog/?p=32" target="_blank">Mylyn 3.0
          released </a> <span class="posted">+378&nbsp;weeks&nbsp;ago</span>
        <p>The Mylyn team is very pleased to announce
          today&Atilde;&fnof;&Acirc;&cent;&Atilde;&cent;&acirc;&euro;&scaron;&Acirc;&not;&Atilde;&cent;&acirc;&euro;&#382;&Acirc;&cent;s
          release of Mylyn 3.0 along with the Eclipse Ganymede release train.
          This occasion marks a big step in the evolution of the task-focused
          interface</p></li>
      <li><a href="http://www.adtmag.com/article.aspx?id=22837" target="_blank">Eclipse's
          Third 'Release Train' on Schedule </a> <span class="posted">+378&nbsp;weeks&nbsp;ago</span>
        <p>On Wednesday June 25 the Eclipse Foundation is sending its third
          annual "release train" chugging down the track. This year's
          synchronized launch of several Eclipse projects at once (code named
          "Ganymede") involved the coordinated release of 23 projects, up from
          21 in last year's "Europa" release, and 10 in 2006 with the original
          "Callisto" release. One of the goals of the release-train strategy,
          said Eclipse Foundation executive director Mike Milinkovich, is to
          provide "a level of predictability" that will promote commercial
          adoption of the Eclipse community's products.</p></li>
      <li><a
        href="http://www.computerworld.com/action/article.do?command=viewArticleBasic&articleId=9102838"
        target="_blank"
      >Eclipse set for coordinated release of 23 updates </a> <span
        class="posted"
      >+378&nbsp;weeks&nbsp;ago</span>
        <p>The Eclipse Foundation is set to make available tomorrow its annual
          coordinated release of open-source projects, which this year includes
          some 18 million lines of code and updates to 23 different projects.</p></li>
      <li><a
        href="http://eclipse.dzone.com/articles/eclipse-34-hidden-treasures"
        target="_blank"
      >Eclipse 3.4 Hidden Treasures </a> <span class="posted">+379&nbsp;weeks&nbsp;ago</span>
        <p>Eclipse 3.4 "Ganymede" will be released in the upcoming days. I've
          been working with the RC builds for some time now and I like it.
          Eclipse 3.4 is a better IDE and a more robust platform than its'
          successor. In this post, I've gathered some new features which I like
          and may be "off the beaten path".</p></li>
      <li><a href="http://www.infoq.com/news/2008/06/eclipse-ganymede-jdt"
        target="_blank"
      >Eclipse Ganymede: An in-depth look at JDT (Java Development Tools) </a> <span
        class="posted"
      >+379&nbsp;weeks&nbsp;ago</span>
        <p>As part of the upcoming Eclipse Ganymede release, scheduled for June
          25th, InfoQ will cover a series of Eclipse subprojects. Today, the
          subproject is JDT (Java Development Tools), which is releasing version
          3.4. InfoQ spoke with Philippe Mulet, lead of the Eclipse project, and
          Martin Aeschlimann, lead of the JDT UI subproject, to learn more about
          what to expect in Ganymede.</p></li>
      <li><a href="http://www.infoq.com/news/2008/06/eclipse-ganymede-pde"
        target="_blank"
      >Eclipse Ganymede: An in-depth look at PDE (Plugin Development
          Environment) </a> <span class="posted">+379&nbsp;weeks&nbsp;ago</span>
        <p>As part of the upcoming Eclipse Ganymede release which is scheduled
          for June 25th, InfoQ will cover a series of Eclipse subprojects.
          Today, the subproject is PDE (Plugin Development Environment), which
          is releasing version 3.4. InfoQ spoke with Chris Aniszczyk, PDE
          Technical Lead and Principal Consultant at Code9, to learn more about
          PDE and what it provides.</p></li>
      <li><a href="http://www.infoq.com/news/2008/06/eclipse-ganymede-mylyn"
        target="_blank"
      >Eclipse Ganymede: An in-depth look at Mylyn </a> <span class="posted">+379&nbsp;weeks&nbsp;ago</span>
        <p>As part of the upcoming Eclipse Ganymede release, scheduled for June
          25th, InfoQ is covering a series of Eclipse subprojects. Today, the
          topic is Mylyn. InfoQ spoke with Mik Kersten, lead of the Mylyn
          project and President of Tasktop Technologies, to learn more about
          what to expect in Ganymede.</p></li>
      <li><a
        href="http://www-128.ibm.com/developerworks/library/os-eclipse-ganymede/"
        target="_blank"
      >Eclipse Ganymede at a glance </a> <span class="posted">+379&nbsp;weeks&nbsp;ago</span>
        <p>The Eclipse Ganymede release of 24 projects showcases the diversity
          and innovation going on inside the Eclipse ecosystem. Get an overview
          of several Ganymede projects, along with resources to find out more
          information.</p></li>
      <li><a
        href="http://www.infoworld.com/article/08/06/19/Eclipse-readies-Ganymede-release_1.html"
        target="_blank"
      >Eclipse readies Ganymede release </a> <span class="posted">+379&nbsp;weeks&nbsp;ago</span>
        <p>The Eclipse Foundation next week is set to offer its annual
          simultaneous release of open-source project updates, this time called
          the Ganymede Release and featuring improvements in the core OSGI-based
          component model and SOA tools.</p></li>
      <li><a href="http://www.infoq.com/news/2008/06/eclipse-ganymede-rap"
        target="_blank"
      >Eclipse Ganymede: An in-depth look at RAP (Rich Ajax Platform) </a> <span
        class="posted"
      >+379&nbsp;weeks&nbsp;ago</span>
        <p>As part of the upcoming Eclipse Ganymede release which is scheduled
          for June 25th, InfoQ will cover a series of Eclipse subprojects.
          Today, the subproject is RAP (Rich Ajax Platform), which is releasing
          version 1.1. InfoQ spoke with Jochen Krause to learn more about RAP
          and what it provides.</p></li>
      <li><a
        href="http://eclipse.dzone.com/articles/understanding-eclipse-p2-provi"
        target="_blank"
      >Understanding the Eclipse p2 Provisioning System </a> <span
        class="posted"
      >+379&nbsp;weeks&nbsp;ago</span>
        <p>p2 is the new provisioning system which will be provided along with
          the Eclipse Ganymede release on June 25th. This is one feature that I
          didn't really follow closely enough,so I was really happy when I
          called Pascal Rapicault to get an explanation from the project
          lead.Ian Skerrett has recently blogged about 10 reasons p2 is going to
          rock, and after reading this, I'm sure you'll agree.</p></li>
      <li><a
        href="http://searchsoa.techtarget.com/news/article/0,289142,sid26_gci1317879,00.html"
        target="_blank"
      >Eclipse Ganymede Part 1: What's in it for SOA? </a> <span class="posted">+379&nbsp;weeks&nbsp;ago</span>
        <p>This is the first in a series of four articles previewing the Eclipse
          Foundation's annual downloadable project release, code named Ganymede,
          which is set for Wednesday, June 25.</p></li>
      <li><a href="http://www.infoq.com/news/2008/06/eclipse-ganymede-ecf"
        target="_blank"
      >Eclipse Ganymede: An in-depth look at ECF (Eclipse Communication
          Framework) </a> <span class="posted">+379&nbsp;weeks&nbsp;ago</span>
        <p>s part of the upcoming Eclipse Ganymede release, scheduled for June
          25th, InfoQ is covering a series of Eclipse subprojects. Today, the
          topic is the Eclipse Communication Framework. InfoQ spoke with Scott
          Lewis, project lead for ECF and Principal at his consulting company,
          Composent, Inc to learn more about ECF and what capabilities it
          provides.</p></li>
      <li><a href="http://www.infoq.com/news/2008/06/eclipse-ganymede-p2"
        target="_blank"
      >Eclipse Ganymede: An in-depth look at Equinox p2 (Provisioning Platform)
      </a> <span class="posted">+380&nbsp;weeks&nbsp;ago</span>
        <p>As part of the upcoming Eclipse Ganymede release, scheduled for June
          25th, InfoQ will cover a series of Eclipse subprojects. Today, the
          subproject is Equinox p2 (Provisioning Platform), which is a framework
          for provisioning Eclipse-based applications. InfoQ spoke with Jeff
          McAffer and Pascal Rapicault to learn more about p2 and what it
          provides.</p></li>
      <li><a
        href="http://www.theregister.co.uk/2008/06/16/eclipse_ganymede_overview/"
        target="_blank"
      >Eclipse projects squeeze into record Summer fun pack </a> <span
        class="posted"
      >+380&nbsp;weeks&nbsp;ago</span>
        <p>
          The Eclipse Foundation's annual code blitz - this year under the name
          Ganymede - kicks off at the end of this month with 24 Eclipse projects
          co-ordinating their new releases.<br />Now in its third year, this
          annual big push keeps getting bigger. Ganymede is Eclipse's largest
          co-ordinate release of updated projects to-date, beating last year's
          update by three.
        </p></li>
    </ul>
  </div>
</div>
<div id="rightcolumn">
  <div class='sideitem'>
    <h6>Related Links</h6>
    <ul>
      <li><a href="mapList.php">Ganymede Around the World</a></li>
      <li><a href="friends.php">Friends of Ganymede</a></li>
    </ul>
  </div>
</div>
