<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<!--
   Licensed to the Apache Software Foundation (ASF) under one or more
   contributor license agreements.  See the NOTICE file distributed with
   this work for additional information regarding copyright ownership.
   The ASF licenses this file to You 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.
-->
<html>
<head>
  <title>Proposal for IO Package</title>
</head>
 <body bgcolor="white">
  
<div align="center"> 
<h1>Proposal for <em>IO</em> Package</h1>
 </div>
  
<h3>(0) Rationale</h3>
  
<p>Many software projects have a need to perform I/O in various ways, and
the JDK class libraries provide a lot of functionality, but sometimes you
need just a little bit more.  The io package seeks to  encapsulate some of
the most popular i/o base classes into one easy to  use package.</p>
   
<h3>(1) Scope of the Package</h3>
  
<p>This proposal is to create a package of Java utility classes for  various
types of i/o related activity.</p>
   
<h3>(1.5) Interaction With Other Packages</h3>
  
<p><em>IO</em> relies only on standard JDK 1.2 (or later) APIs for production
deployment.  It utilizes the JUnit unit testing framework for developing
and executing unit tests, but this is of interest only to developers of the
component.  IO will be a dependency for several existing components in the
open source world.</p>
  
<p>No external configuration files are utilized.</p>
   
<h3>(2) Initial Source of the Package</h3>
  
<p>The original Java classes are splashed around various Apache  subprojects.
 We intend to seek them out and integrate them.</p>
  
<p>The proposed package name for the new component is <code>org.apache.commons.io</code>.</p>
   
<h3>(3)  Required Jakarta-Commons Resources</h3>
  
<ul>
 <li>CVS Repository - New directory <code>io</code> in the     <code>jakarta-commons</code>
CVS repository.</li>
 <li>Mailing List - Discussions will take place on the general     <em>dev@commons.apache.org</em>
mailing list.  To help     list subscribers identify messages of interest,
it is suggested that     the message subject of messages about this component
be prefixed with     [IO].</li>
 <li>Bugzilla - New component "IO" under the "Commons" product     category,
with appropriate version identifiers as needed.</li>
 <li>Jyve FAQ - New category "commons-io" (when available).</li>
 
</ul>
   
<h3>(4) Initial Committers</h3>
  
<p>The initial committers on the IO component shall be Scott Sanders and
Nicola Ken Barozzi and Henri Yandell</p>
    <br>
</body>
</html>
