<?xml version="1.0" encoding="UTF-8"?>
<!--
Copyright 2004 The Apache Software Foundation
Licensed  under the  Apache License,  Version 2.0  (the "License");
you may not use  this file  except in  compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed  under the  License is distributed on an "AS IS" BASIS,
WITHOUT  WARRANTIES OR CONDITIONS  OF ANY KIND, either  express  or
implied.

See the License for the specific language governing permissions and
limitations under the License.
-->

<document>
  
  <properties>
    <title>Pluto Project News and Status</title>
    <author email="ddewolf.aT.apache.D0T.org">David H. DeWolf</author>
    <author email="cdoremus.aT.hannaford.D0T.com">Craig Doremus</author>
    <author email="zheng.aT.apache.D0T.org">ZHENG Zhong</author>
  </properties>
  
  <body>
    
    <section name="News and Status">
	<h4>12 October 2006 - Portals Pluto 1.1.0 beta2 released</h4>
	<p>
		The Apache Pluto project is proud to announce the release of Pluto 1.1.0 beta2. 
		This is the second release of the 1.1 version of Pluto, which is a major refactoring of Pluto 1.0.1 
		to allow for easier integration of Pluto's portlet container into a portal and easier 
		configuration of the Pluto portal driver, a bare-bones portal included with Pluto.
	</p>
	<p>
		This release fixes a number of bugs in Pluto 1.1 including ones that prevented standard portlet modes and
		window states from functioning properly. We've also updated the binary release to deploy Pluto into 
		Tomcat 5.5.17.
	</p>
	<p>
		Pluto is the reference implementation of the JSR-168 (Portlet 1.0) specification for a portlet container. 
		Pluto 1.1 is the basis for the reference implementation of the JSR-286 (Portlet 2.0) specification 
		now under development by the JSR-286 Expert Group.
	</p>
	      

	<h4>1 June 2006 - Portals Pluto 1.1.0 beta1 released</h4>
	<p>
		The Apache Pluto project is proud to announce the release of Pluto 1.1.0 beta1. 
		This is the first release of the 1.1 version of Pluto, which is a major refactoring of Pluto 1.0.1. 
		This refactoring allows for easier integration of Pluto's portlet container into a portal and easier 
		configuration of the Pluto portal driver, a bare-bones portal included with Pluto.
	</p>
	<p>
		Pluto is the reference implementation of the JSR-168 (Portlet 1.0) specification for a portlet container. 
		Pluto 1.1 will be the basis for the reference implementation of the JSR-286 (Portlet 2.0) specification 
		now under development by the JSR-286 Expert Group.
	</p>
	      
      <h4>18 September 2005 - Portals Pluto 1.0.1 General Availability Released</h4>
      <p>
        The Apache Pluto Community is proud to announce the General
        Availablility release of Pluto 1.0.1, the reference implementation of
        the Java Portlet Specification (JSR-168).
      </p>
      <p>
    	  Nearly all the outstanding bugs have been fixed in this release.
        In addition, the Admin Portlet Application now supports hot deployment
        of custom portlets.
      </p>
      
      <h4>24 July 2005 - Portals Pluto 1.0.1-rc4 Released</h4>
      
      <h4>11 July 2005 - Portals Pluto 1.0.1-rc3 Released</h4>
      <p>
        The Apache Pluto Community is proud to announce the release of Apache
        Pluto 1.0.1-rc-2: the third binary release of the reference
        implementation of the Java Portlet Specification.
      </p>
      <p>
        The third release candidate contains several bug fixes and will be
        followed by a general availability of Pluto 1.0.1. In addition to bug
        fixes, the release contains a new administrative portlet which can be
        used to deploy portlets.
      </p>
      
      <h4>22 December 2004 - Portals Pluto 1.0.1-rc2 Released</h4>
      <p>
        The Apache Pluto Community is proud to announce the release of Apache
        Pluto 1.0.1-rc-2: the second binary release of the reference
        implementation of the Java Portlet Specification.
      </p>
      <p>
        Community feedback will decide if a further release candidate is
        required before a final release.
      </p>
      
      <h4>8 October 2004 - Portals Pluto 1.0.1-rc1 Released</h4>
      <p>
        The Apache Pluto Community is proud to announce the release of Apache
        Pluto 1.0.1-rc-1: the first binary release of the reference
        implementation of the Java Portlet Specification.
      </p>
      <p>
        Pluto 1.0.1-rc-1 is considered a release candidate. The promotion of
        this release candidate to general availability is expected within the
        few weeks, pending feedback from the community.
      </p>
      <p>
        The Java Portlet Specification defines a Portlet API very similar to
        the Servlet API. The API provides a means for aggregating disperate
        content sources.  The specification addresses security and
        personalization considerations and defines a standard with which these
        sources, or portlets can be deployed.
      </p>
      <p>
        Pluto is an embedable portlet container which will typically be bundled
        within a fully functional Portal.  The Pluto community has developed a
        simple portal driver implementation which allows for the testing and
        development of portlets with the container. The Pluto testsuite is an
        implementation agnostic portlet application which tests several basic
        operations of the container in which it is deployed.
      </p>
      <p>
        The distribution is organized into four releases:
        <ul>
          <li>A binary distribution bundled with Tomcat. This distribution is
          the easiest to install.</li>
          <li>A source distribution.</li>
          <li>A binary distribution containing the container library.</li>
          <li>A binary tools distribution with the portal driver and testsuite.</li>
        </ul>
      </p>
      
      <h4>September 2004 - Releasing Pluto</h4>
      <p>
        The Pluto Team is currently working on the first public release which
        is expected by the end of September.
      </p>
      
      <h4>July/August 2004 - Pluto moved out of the Incubator</h4>
      <p>
        The Pluto Project is now a sub project under the portals PMC and has
        moved out of the incubator. This move comes with some changes regarding
        mailing addresses etc. In addition Pluto now uses Subversion instead of
        CVS.
      </p>
      
      <h4>May 2004 - Pluto moved issues to JIRA</h4>
      <p>
        As most projects in the ASF, we are superseding Bugzilla and using JIRA
        to manage project issues. New URL for
        <a href="http://issues.apache.org/jira/secure/BrowseProject.jspa?id=10560">
        Pluto issues</a>.
      </p>
      
      <h4>21 March 2004 - Pluto Declaration of Intent Finalized</h4>
      <p>
        The Pluto Community has finalized a declaration of intent which
        clarifies the direction with which Pluto development will move forward.
      </p>
      
      <h4>27 February 2004 - Pluto SubProject Documentation Available</h4>
      <p>
        The maven subproject documentation is now being generated and included
        in the Pluto documentation builds.
      </p>
      
      <h4>10 November 2003 - Pluto Gets a Face Lift</h4>
      <p>
        Pluto is now managed by maven and it's website has subsequently recieved
        a face lift. http://jakarta.apache.org/pluto now contains additional
        information that should be helpfull in establishing this community.
      </p>
      
      <h4>9 November 2003 - Pluto added to Bugzilla</h4>
      <p>
        Pluto has been added to Bugzilla
        (<a href="http://issues.apache.org/bugzilla">http://issues.apache.org/bugzilla</a>).
        Issues, bugs, and enhancements will now be managed through this bug
        database.
      </p>
    
    </section>
    
  </body>
  
</document>

