The Avalon framework consists of interfaces that define relationships
between commonly used application components, best-of-practice pattern
enforcements, and several lightweight convenience implementations of the
generic components.
What that means is that we define the central interface Component. We
also define the relationship (contract) a component has with peers,
ancestors and children.

LogKit is a logging toolkit designed for secure performance oriented
logging in applications. To get started using LogKit, it is recomended
that you read the whitepaper and browse the API docs.

Apache Axis is an implementation of the SOAP ("Simple Object Access
Protocol") submission to W3C.

The Byte Code Engineering Library is intended to give users a
convenient way to analyze, create, and manipulate (binary) Java class
files (those ending with .class). Classes are represented by objects
that contain all the symbolic information of the given class: methods,
fields, and byte code instructions, in particular.

Such objects can be read from an existing file, transformed by a
program (such as a class loader at runtime), and dumped to a file
again. An even more interesting application is the creation of classes
from scratch at runtime. The Byte Code Engineering Library (BCEL) may
also be useful if you want to learn about the Java Virtual Machine
(JVM) and the format of Java .class files.

BCEL is already being used successfully in several projects, such as
compilers, optimizers, obfuscators, code generators, and analysis
tools.

It contains a byte code verifier named JustIce, which usually gives you
much better information about what is wrong with your code than the
standard JVM message.

Bean Scripting Framework (BSF) is a set of Java classes that provides
scripting language support within Java applications and access to Java
objects and methods from scripting languages. BSF allows writing JSPs
in languages other than Java while providing access to the Java class
library. In addition, BSF permits any Java application to be
implemented in part (or dynamically extended) by a language that is
embedded within it. This is achieved by providing an API that permits
calling scripting language engines from within Java as well as an
object registry that exposes Java objects to these scripting language
engines.

This BSF package currently supports several scripting languages: *
Javascript (using Rhino ECMAScript, from the Mozilla project)
* XSLT Stylesheets (as a component of Apache XML project's Xalan and
Xerces)

In addition, the following languages are supported with their own
BSF engines: * Java (using BeanShell, from the BeanShell project)
* JRuby
* JudoScript

BeanShell is an embeddable Java source interpreter with object
scripting language features, written in Java. BeanShell executes
standard Java statements and expressions, in addition to obvious
scripting commands and syntax. BeanShell supports scripted objects as
simple method closures like those in Perl and JavaScript. BeanShell
can be used interactively for Java experimentation and debugging or
as a scripting engine for applications.

BYACC/J is an extension of the Berkeley v 1.8 YACC-compatible parser
generator. Standard YACC takes a YACC source file, and generates one or
more C files from it, which if compiled properly, will produce a
LALR-grammar parser. This is useful for expression parsing, interactive
command parsing, and file reading. Many megabytes of YACC code have
been written over the years. This is the standard YACC tool that is in
use every day to produce C/C++ parsers. I have added a "-J" flag which
will cause BYACC to generate Java source code, instead. So there
finally is a YACC for Java now!

Compiler Assisted Localization, abbreviated as CAL10N (pronounced as "calion")
is a java library for writing localized (internationalized) messages.
Features:
* java compiler verifies message keys used in source code
* tooling to detect errors in message keys
* native2ascii tool made superfluous, as you can directly encode bundles
in the most convenient charset, per locale.
* good performance (300 nanoseconds per key look-up)
* automatic reloading of resource bundles upon change

cglib is a powerful, high performance and quality Code Generation
Library, It is used to extend JAVA classes and implements interfaces at
runtime.

dom4j is an Open Source XML framework for Java. dom4j allows you to read,
write, navigate, create and modify XML documents. dom4j integrates with
DOM and SAX and is seamlessly integrated with full XPath support.

ECJ is the Java bytecode compiler of the Eclipse Platform. It is also known as
the JDT Core batch compiler.

Fastjar is an implementation of Sun's jar utility that comes with the
JDK, written entirely in C, and runs in a fraction of the time while
being 100% feature compatible.

Geronimo is Apache's ASF-licenced J2EE server project. These are the
J2EE-Specifications Note: You should use the subpackages for the
Specifications that you actually need. The ones installed by the main
package are deprecated and will disapear in future releases.

Provides a library of matcher objects (also known as constraints or
predicates) allowing 'match' rules to be defined declaratively, to be
used in other frameworks. Typical scenarios include testing frameworks,
mocking libraries and UI validation rules.

HSQLdb is a relational database engine written in JavaTM , with a JDBC
driver, supporting a subset of ANSI-92 SQL. It offers a small (about
100k), fast database engine which offers both in memory and disk based
tables. Embedded and server modes are available. Additionally, it
includes tools such as a minimal web server, in-memory query and
management tools (can be run as applets or servlets, too) and a number
of demonstration examples.

Downloaded code should be regarded as being of production quality. The
product is currently being used as a database and persistence engine in
many Open Source Software projects and even in commercial projects and
products! In it's current version it is extremely stable and reliable.
It is best known for its small size, ability to execute completely in
memory and its speed. Yet it is a completely functional relational
database management system that is completely free under the Modified
BSD License. Yes, that's right, completely free of cost or
restrictions!

The ISO RELAX project is started to host the public interfaces useful
for applications to support RELAX Core. But nowadays some of the stuff
we have is schema language neutral.

The Discovery component is about discovering, or finding,
implementations for pluggable interfaces. Pluggable interfaces are
specified with the intent that multiple implementations are, or will
be, available to provide the service described by the interface.
Discovery provides facilities for finding and instantiating classes and
for lifecycle management of singleton (factory) classes.

Commons-launcher eliminates the need for a batch or shell script to
launch a Java class. Some situations where elimination of a batch or
shell script may be desirable are:

* You want to avoid having to determining where certain application
paths are, for example, your application's home directory.
Determining this dynamically in a Windows batch script is very
tricky on some versions of Windows or when softlinks are used on
Unix platforms.

* You want to avoid having to handle native file and path separators
or native path quoting issues.

* You need to enforce certain system properties, such as
java.endorsed.dirs when running with JDK 1.4.

* You want to allow users to pass custom JVM arguments or system
properties without having to parse and reorder arguments in your
script. This can be tricky or messy in batch and shell scripts.

* You want to bootstrap system properties from a configuration file
instead of hard-coding them in your batch and shell scripts.

* You want to provide localized error messages, which is very tricky to
do in batch and shell scripts.

This package contains releases for the 1.1.x versions of the Standard
Tag Library, Jakarta Taglibs's open source implementation of the JSP
Standard Tag Library (JSTL), version 1.1. JSTL is a standard under the
Java Community Process.

Linux beats them ALL! While all other OS's are TALKING about direct
support of Java Binaries in the OS, Linux is doing it!

You can execute Java applications and Java Applets just like any other
program after you have installed this package.

java-cup is a LALR Parser Generator in Java. With v0.11, you can: *
use CUP in an Ant-Target

* start CUP by a simple command like java -jar java-cup-11a.jar
myGrammar.cup

* use generic parametrized classes (since Java 1.5) as datatypes for
non terminals and terminals

* have Your own symbol classes

This package provides macros and scripts to support Java packaging.

Javassist (Java Programming Assistant) makes Java bytecode manipulation
simple. It is a class library for editing bytecodes in Java; it enables
Java programs to define a new class at runtime and to modify a class
file when the JVM loads it. Unlike other similar bytecode editors,
Javassist provides two levels of API: source level and bytecode level.
If the users use the source-level API, they can edit a class file
without knowledge of the specifications of the Java bytecode. The whole
API is designed with only the vocabulary of the Java language. You can
even specify inserted bytecode in the form of source text; Javassist
compiles it on the fly. On the other hand, the bytecode-level API
allows the users to directly edit a class file as other editors.

Class, field, and method level annotations for describing thread-safety
policies.

Collection of classes used by Object Refinery Projects, for example
jfreechart