• Jakarta-Commons Collections: Complete migration of the primitives package to the new purely primitive interfaces with Collection adapters. Move toward a 3.0 release.
• Jakarta-Commons Functor: Repackage the various org.apache.commons.functor.core.* subpackages to org.apache.commons.functor.*. I had initially expected a tighter dependency between core. and core, in practice there are no dependencies.
• Jakarta-Commons Functor: Normalize the names of the methods used to obtain the static instances of the stateless functors. Probably something as uninspired as getInstance.
• Axion: Update Axion to use the new primitive collections interfaces instead of the old.
• Axion: Add Axion to Gump, now that Axion builds with JDK 1.4.
• Jakarta-Commons Pool: Introduce functor-based interfaces and implementations for specialization through composition.
• Jakarta-Commons DBCP/DB-Commons: Extract JDBC-proxy types from DBCP, use it and the functored pool implementations to clean up DBCP. In particular, use composition to support the folks who want features like "abandoned" object detection and the like.
• Jakarta-Commons DBCP: Use Axion to implement more complete/robust unit tests for DBCP.
• Jakarta-Commons JUX: The trivially simple JUX (JUnit eXtensions) package may be helpful for some of the above, as might the "tunneled exception" stuff I previously mentioned.

I've got some other tasks in mind of course, but these are the ones that have been floating around for a while. We'll see if this helps act as a motivator, it should at least be useful for my own reference.

Morgan posted a similiar list a while back (a blog entry that was lost it seems). I'm not sure he found it helpful, but I like the idea of having some modern equivalent of .plan files.

1. Import and use a type from org.gnu.foo:

   import org.gnu.foo.Bar;
   class ClientCode {
     public static void main(String[] args) {
       Bar bar = new Bar();
       bar.someMethod(args[0]);
     }
     /* ... */
   }

   or

   import org.gnu.foo.Bar;
   class MoreClientCode {
     void clientMethod(Bar bar) {
       bar.someMethod("xyzzy");
     }
     /* ... */
   }

2. Extend from a type in org.gnu.foo:

   import org.gnu.foo.Bar;
   class ClientCode extends Bar {
     /* ... */
   }

3. Specialize a type from org.gnu.foo, but via composition rather than inheritance:

   import org.gnu.foo.Bar;
   class ProxyBar {
     ProxyBar(Bar bar) {
       this.bar = bar;
     }
    
     void someMethod(String str) {
       return bar.someMethod(str.toUpperCase());
     }
    
     /* ... */
    
     private Bar bar;
   }

4. Invoke a method from org.gnu.foo using "hard-coded" reflection:

   class ClientCode {
     public static void main(String[] args) throws Exception {
       Class klass = Class.forName("org.gnu.foo.Bar");
       Method method = klass.getMethod("someMethod", new Class[] { String.class });
       Object obj = klass.newInstance();
       method.invoke(obj,new String[] { args[0] });
     }
   }

5. Invoke a method from org.gnu.foo using runtime-determined reflection:

   class ClientCode {
     public static void main(String[] args) throws Exception {
       Class klass = Class.forName(args[0]);
       Method method = klass.getMethod(args[1], new Class[] { String.class });
       Object obj = klass.newInstance();
       method.invoke(obj,new String[] { args[2] });
     }
   }

   invoked via

   java ClientCode org.gnu.foo.Bar someMethod xyzzy

6. Invoke a method from org.gnu.foo as an external process:

   class ClientCode {
     public static void main(String[] args) throws Exception {
       Process p = Runtime.getRuntime().exec("java org.gnu.foo.Bar xzyyz");
       /* ... */
     }
   }

How do these answers change if org.gnu.foo is licensed under the "regular" GPL?