<!--

    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.
-->

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<!-- $Rev$ $Date$ -->

<html>
<head>
</head>
<body>

<h1>Apache Geronimo Documentation</h1>

<p>
There is not yet a full manual or similar official documentation.  However,
the resources below will help new users and developers get up to speed with
Geronimo.
</p>

<h2>Project Resources</h2>
<ul>
  <li>The <a href="http://wiki.apache.org/geronimo">Geronimo Wiki</a> has
  information on running Geronimo, as well as checking out and
  building from source, and many other things.</li>
  <li>Release Notes are available for milestone releases:
    <ul>
      <li><a href="http://cvs.apache.org/dist/geronimo/v1.0-M2/RELEASE-NOTES-1.0-M2.txt">Milestone 2</a></li>
      <li><a href="http://cvs.apache.org/dist/geronimo/v1.0-M3/RELEASE-NOTES-1.0-M3.txt">Milestone 3</a></li>
    </ul>
  </li>
</ul>

<h2>Books</h2>

<p>
A number of books covering Geronimo are planned or in production.  If all
goes well, they will be ready when Geronimo 1.0 is released.
</p>

<p><b>Books with Content Available Electronically</b></p>

<ul>
  <li><u>Geronimo: A Developer's Notebook</u> by David Blevins
    <ul>
      <li>First
      <a href="http://today.java.net/pub/a/today/2004/08/02/geronimo.html">two chapters</a>
      available at java.net</li>
    </ul>
  </li>
  <li><u>Apache Geronimo Development and Deployment</u> by Aaron Mulder
    <ul>
      <li><a href="http://chariotsolutions.com/geronimo/">Electronic copy</a>
      available</li>
    </ul>
  </li>
</ul>      

<h2>Articles and Interviews</h2>
<ul>
  <li>TheServerSide.com
    <a href="http://www.theserverside.com/talks/videos/DainSundstrom/dsl/interview.html">interview with Dain Sundstrom</a>
    about Geronimo (transcript and video)
  </li>
  <li>TheServerSide.com
    <a href="http://www.theserverside.com/talks/videos/JeremyBoynes/dsl/interview.html">interview with Jeremy Boynes</a>
    about Geronimo (transcript and video)
  </li>
</ul>

</body>
</html>
