Alexandria is a CVS/Javadoc/Source code/Documentation management system
meant for use within Open Source projects. It's goal is to create a
global documentation and source organization system to help people
understand source code and to share code across projects.
Alexandria is a Java centric project. The backend is implemented in all
XML which is driven by Ant, Xerces, and Xalan.
Definition of source code is done within XML and then transformed (XSLT)
into various HTML files and a master build.xml file which is used to
drive Ant. Ant attempts to download various CVS repositories and then
builds Javadoc.
Planche 3 : Ant
Ant is a Java based build tool. In theory it is kind of like make
without make's wrinkles.
Why another build tool when there is already make, gnumake, nmake, jam,
and others? Because all of those tools have limitations that Ant's
original author couldn't live with when developing software across
multiple platforms. Make-like tools are inherently shell based. They
evaluate a set of dependencies and then execute commands not unlike what
you would issue on a shell. This means that you can easily extend these
tools by using or writing any program for the OS that you are working
on. However, this also means that you limit yourself to the OS, or at
least the OS type such as Unix, that you are working on.
Makefiles are inherently evil as well. Anybody who has worked on them
for any time has run into the dreaded tab problem. "Is my command not
executing because I have a space in front of my tab!!!" said the
original author of Ant way too many times. Tools like Jam took care of
this to a great degree, but still use yet another format to use and
remember.
Ant is different. Instead of a model where it is extended with shell
based commands, it is extended using Java classes. Instead of writing
shell commands, the configuration files are XML based calling out a
target tree where various tasks get executed. Each task is run by an
object which implements a particular Task interface.
Granted, this removes some of the expressive power that is inherent by
being able to construct a shell command such as `find . -name foo -exec
rm {}` but it gives you the ability to be cross platform. To work
anywhere and everywhere. And hey, if you really need to execute a shell
command, Ant has an exec rule that allows different commands to be
executed based on the OS that it is executing on.
Planche 4 : Avelon
The Avalon project is an effort to create, design, develop and maintain
a common framework and set of components for applications written using
the Java language. This framework is not a standalone product, but
allows existing and yet to be created applications to fit into a common
platform and to share code, design and human resources.
Planche 5 : Cactus
Cactus is a simple test framework for unit testing server-side java
code (Servlets, EJBs, Tag Libs, Filters, ...).
The intent of Cactus is to lower the cost of writing tests for
server-side code. It uses JUnit and extends it.
Cactus has been developed with the idea of automatic testing in mind and
it provides a packaged and simple mechanism based on Ant to automate
server-side testing.
Cactus implements an in-container strategy (click on the diagram below
to undestand how it works). An alternative but complementary approach
not covered by Cactus is to use Mock Objects (see the Mock vs Container
page to understand the differences and why Cactus believes in the
usefulness of an in-container approach).
Planche 6 : Commons
The Commons is a new Jakarta subproject focused on all aspects of
reusable Java components.
The Jakarta Commons project is composed of two parts:
* The Commons Proper - A repository of reusable Java components.
* The Sandbox - A workspace for Java component development.
The components page lists the components currently available in both the
Sandbox and Commons Proper.
Planche 7 : ECS
The Element Construction Set is a Java API for generating elements for
various markup languages it directly supports HTML 4.0 and XML, but can
easily be extended to create tags for any markup language. It is
designed and implemented by Stephan Nagy and Jon S. Stevens.
Planche 8 : James
The Java Apache Mail Enterprise Server (a.k.a. Apache James) is a 100%
pure Java server, designed to be a complete and portable enterprise mail
engine solution based on currently available open protocols (SMTP, POP3,
IMAP, HTTP). It requires Java 2 (minimum requirement is the JRE 1.2).
Planche 9 : JetSpeed
Jetspeed is an Open Source implementation of an Enterprise Information
Portal, using Java and XML. A portal makes network resources
(applications, databases and so forth) available to end-users. The user
can access the portal via a web browser, WAP-phone, pager or any other
device. Jetspeed acts as the central hub where information from multiple
sources are made available in an easy to use manner.
The data presented via Jetspeed is independent of content type, This
means that content from for example XML,RSS or SMTP can be integrated
with Jetspeed. The actual presentation of the data is handled via ates
XSL and delivered to the user for example via the combination of Java
Server Pages (JSPs) and HTML. Jetspeed provides support for templating
and content publication frameworks such as Cocoon, WebMacro and
Velocity. Note that outside of regualar browser Jetspeed also supports
WAP devices.
Jetspeed helps you build portal applications quickly. The goal is to
make Jetspeed a tool for both portal developers as well as user
interface designers. Currently the focus is on providing developers with
a set of tools that facilitates building the base for the portal. With
Jetspeed you can quickly build an XML portal and also syndicate your own
content.
Planche 10 : JMeter
Apache JMeter is a 100% pure Java desktop application designed to load
test functional behavior and measure performance. It was originally
designed for testing Web Applications but has since expanded to other
test functions.
Planche 11 : Log4J
Inserting log statements into your code is a low-tech method for
debugging it. It may also be the only way because debuggers are not
always available or applicable. This is often the case for distributed
applications.
Planche 12 : Lucene
Jakarta Lucene is a high-performance, full-featured text search engine
written entirely in Java. It is a technology suitable for nearly any
application that requires full-text search, especially cross-platform.
Planche 13 : ORO
The Jakarta-ORO Java classes are a set of text-processing Java classes
that provide Perl5 compatible regular expressions, AWK-like regular
expressions, glob expressions, and utility classes for performing
substitutions, splits, filtering filenames, etc. This library is the
successor to the OROMatcher, AwkTools, PerlTools, and TextTools
libraries from ORO, Inc. (www.oroinc.com). They have been donated to the
Jakarta Project by Daniel Savarese (www.savarese.org), the copyright
holder of the ORO libraries. Daniel will continue to participate in
their development under the Jakarta Project.
Planche 14 : Regexp
Regexp is a 100% Pure Java Regular Expression package that was
graciously donated to the Apache Software Foundation by Jonathan Locke.
He originally wrote this software back in 1996 and it has stood up quite
well to the test of time. It includes complete Javadoc documentation as
well as a simple Applet for visual debugging and testing suite for
compatibility.
Planche 15 : Slide
Welcome to the Jakarta Slide project ! Slide is a project composed of
multiple modules tied together using WebDAV (see below for more details
about WebDAV).
It includes :
* A content management system with a Java API
* A servlet implementing the WebDAV protocol on top of the content management system
* A Java WebDAV and HTTP client library
* A WebDAV command line client
* WebDAV enabled Swing components
Planche 16 : Struts
Welcome to the Struts Framework! The goal of this project is to provide
an open source framework useful in building web applications with Java
Servlet and JavaServer Pages (JSP) technology. Struts encourages
application architectures based on the Model-View-Controller (MVC)
design paradigm, colloquially known as Model 2 in discussions on various
servlet and JSP related mailing lists.
Planche 17 : Taglibs
Welcome to Jakarta Taglibs! The goal of this project is to provide an
open-source repository for JSP custom taglibs and Web Publishing tool
extensions which support JSP custom taglibs.
Planche 18 : Tomcat
Tomcat is the servlet container that is used in the official Reference
Implementation for the Java Servlet and JavaServer Pages technologies.
The Java Servlet and JavaServer Pages specifications are developed by
Sun under the Java Community Process.
Tomcat is developed in an open and participatory environment and
released under the Apache Software License. Tomcat is intended to be a
collaboration of the best-of-breed developers from around the world. We
invite you to participate in this open development project. To learn
more about getting involved, click here.
Planche 19 : Turbine
Turbine is a servlet based framework that allows experienced Java
developers to quickly build secure web applications. Parts of Turbine
can also be used independently of the web portion of Turbine as well. In
other words, we strive to make portions of Turbine easily available for
use in other applications.
Turbine is developed in an open and participatory environment and
released under the Apache Software License. Turbine is intended to be a
collaboration of the best-of-breed developers from around the world. We
invite you to participate in this open development project. To learn
more about getting involved, click here.
Planche 20 : Velocity
Velocity is a Java-based template engine. It permits anyone to use the
simple yet powerful template language to reference objects defined in
Java code.
When Velocity is used for web development, Web designers can work in
parallel with Java programmers to develop web sites according to the
Model-View-Controller (MVC) model, meaning that web page designers can
focus solely on creating a site that looks good, and programmers can
focus solely on writing top-notch code. Velocity separates Java code
from the web pages, making the web site more maintainable over the long
run and providing a viable alternative to Java Server Pages (JSPs) or
PHP.
Planche 21 : Watchdog
Watchdog, the validation tests for the Servlet and JavaServer Pages
specifications, is currently available. To download the Watchdog
binaries, click here. To learn more about getting involved in the
development of Watchdog click here.