Open Source Java Community and OpenJDK Resources. Latest News, podcasts, Updates, downloads.

Apache Ant is a Java-based build tool. In theory, it is kind of like Make, but without Make's wrinkles.

Why another build tool when there is already make, gnumake, nmake, jam, and others? Because all 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, then execute commands not unlike what you would issue in 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 have yet another format to use and remember.

Ant is different. Instead of a model where it is extended with shell-based commands, Ant 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 that 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 task that allows different commands to be executed based on the OS that it is executing on.

Project Home Page:
http://ant.apache.org/

Documentation
http://ant.apache.org/manual/index.html

Downloads
Binaries: http://ant.apache.org/bindownload.cgi
Source: http://ant.apache.org/srcdownload.cgi

License:
http://ant.apache.org/license.html

Maven is a software project management and comprehension tool. Based on the concept of a project object model (POM), Maven can manage a project's build, reporting and documentation from a central piece of information.

If you think that Maven could help your project, you can find out more information about in the "About Maven" section of the navigation. This includes an in-depth description of what Maven is, a list of some of its main features, and a set of frequently asked questions about what Maven is.

Maven was originally started as an attempt to simplify the build processes in the Jakarta Turbine project. There were several projects each with their own Ant build files that were all slightly different and JARs were checked into CVS. We wanted a standard way to build the projects, a clear definition of what the project consisted of, an easy way to publish project information and a way to share JARs across several projects.

The result is a tool that can now be used for building and managing any Java-based project. We hope that we have created something that will make the day-to-day work of Java developers easier and generally help with the comprehension of any Java-based project.

Maven's Objectives

Maven's primary goal is to allow a developer to comprehend the complete state of a development effort in the shortest period of time. In order to attain this goal there are several areas of concern that Maven attempts to deal with:

* Making the build process easy
* Providing a uniform build system
* Providing quality project information
* Providing guidelines for best practices development
* Allowing transparent migration to new features

Learning about Maven

This site is separated into the following sections, depending on how you'd like to use Maven:

* Run Maven Information for those needing to build a project that uses Maven
* Use Maven Information for those wanting to use Maven to build their project, including a "10 minute test" that gives a practical overview of Maven's main features in just 10 minutes
* Write Maven Plugins Information for those who may or may not be using Maven, but want to provide a plugin for shared functionality or to accompany their own product or toolset
* Improve the Maven Repository Information for those who may or may not use, but are interested in getting project metadata into the repository
* Develop Maven Information for those who are currently developers, or interested in becoming developers of the Maven project itself

Each guide is divided into a number of trails to get you started on a particular topic, and includes a reference area and a "cookbook" of common examples.

You can access the guides at any time from the left navigation.

Documentation:
http://maven.apache.org/guides/index.html

Downloads
http://maven.apache.org/download.html

Rant stands for Remote Ant. It is a distributed build system that allows an Ant build file to launch builds on other systems and receive exceptions should they occur.

Download
http://sourceforge.net/project/showfiles.php?group_id=39381

Invicta is an open-source build management tool.
Using simple project definition files, it generates powerful build scripts (Apache ANT's), while hiding their complexity.
Furthermore, Invicta is a modular framework that allows advanced developers add their own customized types of components, which means writing once ANT code that can later be used by all the developers in their project or company simply by specifying the new type name.
Learn more about Invicta

Download Invicta:
Invicta is now available for download

Documentation:

Invicta includes a complete manual both for its basic usage and for advanced developers.

This manual is available online and can also be downloaded separately.

Make in Java (JMK) is an application which is used to ensure that a set of files is in a consistent state. If JMK detects an inconsistency, it executes commands that correct the inconsistency. JMK is based on the make utility which is part of most Unix systems, but is designed to be easily run on a variety of machines and operating systems.

JMK - Make in Java - A utility for maintaining files in a consistent state. The application is based on the make utility which is part of most Unix systems, but is designed to support the task of writing platform independent makefiles. File names and path lists are written in a canonical form, and translated by jmk into native form. As a result, a makefile can be used to maintain software on a variety of machines and operating systems.

JMK - Project Home
http://sourceforge.net/projects/jmk

Frequently Asked Questions
http://jmk.sourceforge.net/faq.html

The Savant build system is designed to help manage the complexities of building large software applications. In order to support highly modular designs companies might create numerous projects, which are all managed independently of each other and all of which might have different requirements of a build system. Additionally, these projects might depend on each other and other third party libraries as well. Savant is a framework for managing these types of build complexities.

Savant, originally part of the Verge open source project, has recently been moved out to its own project at http://java.net in order to allow Savant grow into a full build system and build framework. The new Savant projects home page is located at https://savant.dev.java.net and is looking for developers. This new build system and framework is being designed to allow maximum flexibility and robustness by supporting numerous scripting and compiled languages as well as providing robust dependency management.

The new Savant build system will also support the complex project structures required by J2EE and other types of applications. This next phase of the Savant build system is nearing completion and if you would like to participate, please apply for a position by visiting the Savant homepage at https://savant.dev.java.net

Savant Features

Dependency Management

* Inter-project dependencies and builds
* Transitive dependencies
* Robust dependency namespacing to avoid name collisions
* Configurable workflows for dependency fetching, caching, and publishing
* Well defined interfaces allowing customized dependency fetching. caching, and publishing
* Support for Maven 1 (http://www.ibilio.org) dependency fetching
* MD5 checking
* Full Apache Ant integration

Command-line tool

* Robust plugin system with versioning and inter-plugin dependencies
* Java compilation with multiple source trees
* Single or multiple JAR creation
* JUnit integration with CLI switches for different failure modes
* Project layout creation
* Dependency tree print-out (like pstree)
* Some J2EE support
* Ability to run ant scripts from Savant CLI and from other Savant plugins

Savant Documentation
http://www.inversoft.com/docs/savant

Download Savant
https://savant.dev.java.net/

CruiseControl is a framework for a continuous build process. It includes, but is not limited to, plugins for email notification, Ant, and various source control tools. A web interface is provided to view the details of the current and previous builds.

CruiseControl is distributed under a BSD-style license and is free for use. CruiseControl adheres to an open source model and therefore makes the source code freely available.

CruiseControl is maintained and developed by a group of dedicated volunteers.

Continuous Integration

An important part of any software development process is getting reliable builds of the software. Despite it's importance, we are often surprised when this isn't done. We stress a fully automated and reproducible build, including testing, that runs many times a day. This allows each developer to integrate daily thus reducing integration problems.

Cruise Control Documentation
http://cruisecontrol.sourceforge.net/overview.html

Cruise Control Download
http://cruisecontrol.sourceforge.net/download.html

Krysalis Centipede is a project build system based on Apache Ant.

You can just grab it and start building your project. Anything that is needed for a start is there, and the creation of personalized build targets is straightforward, because it's based on plain Ant. Centipede is un-intrusive, and gives you power without taking any. It also has an interactive target facility, so that the user can just run "build" and choose from a menu.

You just need to add a property to use additional pre-built targets. These packages are called antlibs, and behave like wars and seamlessly add functionality to the build.

Let's say you need to make documentation. Just add (an available documentation system based on Cocoon) to the properties file, write the docs, call the forrest in your main build file where you want documentation to be build and all the rest (comprising the download and installation) is completely automagic.

Since Centipede is used by many projects, it benefits from the enhancements done in each of them, thus and evolving on user requests-issues. This is pure Apache style cross project pollination.

It gives developers the power to add functionality where needed without creating complexity.

Developers seldom want to think much about the project build system, but have very clear ideas of what they want from it. Centipede gives them pre-built antlibs to be used like big component blocks, thus giving choice and power to where it really belongs.

Documentation
http://krysalis.org/centipede/quickstart.html

Download
http://sourceforge.net/project/showfiles.php?group_id=36516

Bee is a Java-based build tool. Bee inherited some principles of Make. Bee provides more procedure languages constructions, so generally can be used for script programming. It's highly extendable and base DTD can be easily changed, so it allows to create own dialects of Bee.

Project Home Page
http://www.gena.crocodile.org/bee/index-bee.html

LuntBuild is a powerful build automation and management tool. Continuous integration or daily build can be easily setup through a clean web interface. Generated builds are well managed through functions such as search, categorization, promotion, patching, deletion, etc. It also acts as a central build artifacts download area for your whole team.

Project Home Page

http://www.luntsys.com/luntbuild/

CPMake is a make utility written in Java to make anything (C, C++, Java, C#, XSL ...)
CPMake works similar to GNU make in that is uses rules and dependencies to build a project. CPMake uses Java scripting languages (BeanShell, Rhino, Jython and Groovy) for the build files to give increased flexability and the ability to customize the make file to your project.

CPMake Features:

* Make files work on any platform that supports Java.
* CPMake has built in dependency tracking for C/C++ and Java projects.
* Build files have access to all of the Java classes.
* Easy to debug build files.
* Multi threaded processing of build file.
* Cross platform paths. Use '\' or '/' Java doesn't care.

Project Home Page
http://www.cpmake.org/

CPMake Documentation
http://www.cpmake.org/documentation.html

Downloads
http://www.cpmake.org/downloads.html

CPMake Demo
http://www.cpmake.org/samples.html

JavaGen Ant Modules or JAM is a modular Ant toolkit for building J2EE applications. It consists of a collection of Ant scripts designed to perform common Java/J2EE build tasks such as compilation, packaging, testing, deployment and J2EE application server control. Although originally developed to support the JavaGen code generator, JAM has evolved into a full feature, stand-alone build framework.

Highlights include:

* JAM leverages the new import and target override features of Ant 1.6 to create a reusable build framework.
* JAM defines a small set of standard target names.
* JAM includes a Maven-to-Ant bridge providing access to Maven's POM and repository features directly from Ant.
* JAM supports various J2EE application servers as interchangeable modules.
* JAM supports code generation technologies such as XDoclet and UML-based JavaGen.
* JAM has extensive support for various unit test technologies including JUnit and Cactus.
* JAM modules support CVS, Axis, Castor, JMX, Hibernate and many other technologies.

To learn more read through the User's Guide starting with the simple example page.

JAM Download
http://javagen.com/jam/download.html

Project Home
http://javagen.sourceforge.net/

GenJar is a specialized Ant task that builds jar files based on class dependencies rather than simply the contents of a directory.

Work is underway on GenJar2. GenJar2 will be a functional replacement of GenJar, but build file syntax will change. Some of the features of GenJar2 include:

* Syntax consistent with Ant's jar task
* Replacement of GenJar's with Ant's
* Replacement of GenJar's with with Ant's
* BCEL for class dependency checking

The original GenJar branch will be maintained for as long as there is demand.

Documentation
http://genjar.sourceforge.net/manual.html

Download GenJar
http://sourceforge.net/project/showfiles.php?group_id=63362&release_id=144632

Project Home Page
http://sourceforge.net/projects/genjar/

Ivy is a free java based dependency manager, with powerful features such as transitive dependencies, ant integration, maven repository compatibility, continuous integration, html reports and many more.

Project Home Page
http://jayasoft.org/ivy

Antmod is a build management, release management, and repository management tool. Its implementation is an Ant-based extensible engine for retrieving, versioning, building, and deploying code to and from Subversion or CVS. It standardizes build files for Java projects and provides build plugins for various tasks. It also standardizes tagging and branching for both CVS and Subversion, and its module and repository management can also be used for non-Java projects. It greatly speeds up Java software development, promotes reuse of Java software, and standardizes the build-test- release cycle.

Homepage:
http://antmod.org/

Tar/GZ:
http://antmod.org/download.html

Zip:
http://antmod.org/download.html

Changelog:
http://antmod.org/news.html

CVS tree (cvsweb):
http://antmod.dev.java.net/source/browse/antmod/

Bug tracker:
https://antmod.dev.java.net/servlets/ProjectIssues

Mailing list archive:
http://antmod.dev.java.net/servlets/SummarizeList?listName=users

Continuum is a continous integration server that will ensure the health of your code base.

The term "continuous integration" refers to a process that builds and tests code on a frequent, regular basis. Many continuous integration systems monitor a source repository at regular intervals and trigger an "integration" every time someone commits a change. An "integration" can be anything from compiling and testing a single project to the assembly and testing of a deliverable from multiple dependent projects. Among the benefits of continuous integration are the immediate identification of defects and the ability to guarantee that a project's build will succeed at any point in the development cycle.

An in-depth description of continuous integration is beyond the scope of this FAQ. A much more detailed explanation of the concept can be found at the resources listed below:

* Martin Fowler has a article called "Continuous Integration"
* The C2 wiki has a page on ContinuousIntegration

There are many continuous integration projects and products on the market. Here is a list of other products which offer similar capabilities:

* CruiseControl
* AntHill

Features of Continuum

* Tight integration with Maven 2.x
* Tight integration with Maven SCM
o Subversion
o CVS
o Starteam
o Clearcase
o Perforce
o bazaar
* Easy to use web-based setup and interface
* Quartz-based scheduling
* An easy way to add new projects, see the adding projects section page for more information
* An XML-RPC interface for integration, automation and remoting
* Mail notification
* IM notification
o IRC
o Jabber
o MSN
* Blame Mechanism

Documentation
http://maven.apache.org/continuum/guides/index.html

Continuum Downloads
http://maven.apache.org/continuum/download.html

Project Home Page
http://maven.apache.org/continuum/index.html

Autojar helps creating jar files of minimal size from different inputs like own classes, external archives etc. It starts from one or more given classes (e.g., an applet), recursively searches the bytecode for references to other classes, extracts these classes from the input archives, and copies them to the output. The resulting archive will only contain the classes you really need. Thus you can keep size and loading time of applets low or make applications independent of installed libraries.
In a similar way, autojar can search directories and archives for other resources (like image files), extract them and copy them to the output.

Note that autojar in principle can't know which classes will be loaded dynamically (by Class.forName()). However, starting from version 1.3, one can tell autojar to search the bytecode for invocations of Class.forName() and inform you correspondingly. In some cases autojar actually can find out which classes are to be loaded, and add them automatically to the output.

Autojar uses the excellent bcel package (http://jakarta.apache.org/bcel/).

Using Autojar

Autojar comes in two flavours with equal functionality. The file autojar.jar is th self-contained version, created by autojar itself. Use it if you don't have BCEL installed. It is started by the command

java -jar autojar.jar [option...] [file...]

The second version, autojar-core.jar, is much smaller, as it contains only the autojar classes. You must have bcel-5.1.jar (or better) in your classpath to use it. Start it like this:

java -cp autojar-core.jar:bcel.jar de.uni_hamburg.eggink.autojar.Autojar [option...] [file...]

(As usual, Windows users have to use semicolon instead of colon in the classpath). Any program parameter (options and files) may be supplied directly on the command line or read from a text file. Example:

java -jar autojar.jar -o old.jar @params -c in.jar @class-list

Each line in params and class-list is considered a program parameter and inserted into the command line sequence.

Project Home Page
http://autojar.sourceforge.net/

Download Autojar
https://sourceforge.net/projects/autojar

Jar Jar Links is a utility that makes it easy to repackage Java libraries and embed them into your own distribution. This is useful for two reasons:

* You can easily ship a single jar file with no external dependencies.
* You can avoid problems where your library depends on a specific version of a library, which may conflict with the dependencies of another library.

Project Home page
http://tonicsystems.com/products/jarjar/

Hudson monitors executions of repeated jobs, such as building a software project or jobs run by cron. Among those things, current Hudson focuses on the following two jobs:

Building/testing software projects continuously, just like CruiseControl or DamageControl. In a nutshell, Hudson provides an easy-to-use so-called continuous integration system, making it easier for developers to integrate changes to the project, and making it easier for users to obtain a fresh build. The automated, continuous build increases the productivity.

Monitoring executions of externally-run jobs, such as cron jobs and procmail jobs, even those that are run on a remote machine. For example, with cron, all you receive is regular e-mails that capture the output, and it is up to you to look at them diligently and notice when it broke. Hudson keeps those outputs and makes it easy for you to notice when something is wrong.

Hudson Features

1. Easy installation: Just java -jar hudson.war, or deploy it in a servlet container. No additional install, no database.
2. Easy configuration: Hudson can be configured entirely from its friendly web GUI with extensive on-the-fly error checks and inline help. There's no need to tweak XML manually anymore, although if you'd like to do so, you can do that, too.
3. Change set support: Hudson can generate a list of changes made into the build from CVS/Subversion. This is also done in a fairly efficient fashion, to reduce the load of the repository.
4. Permanent links: Hudson gives you clean readable URLs for most of its pages, including some permalinks link "latest build"/"latest successful build", so that they can be easily linked from elsewhere.
5. RSS/E-mail/IM Integration: Monitor build results by RSS or e-mail to get real-time notifications on failures.
6. After-the-fact tagging: Builds can be tagged long after builds are completed
7. JUnit/TestNG test reporting: JUnit test reports can be tabulated, summarized, and displayed with history information, such as when it started breaking, etc. History trend is plotted into a graph.
8. Distributed builds: Hudson can distribute build/test loads to multiple computers. This lets you get the most out of those idle workstations sitting beneath developers' desks.
9. File fingerprinting: Hudson can keep track of which build produced which jars, and which build is using which version of jars, and so on. This works even for jars that are produced outside Hudson, and is ideal for projects to track dependency.
10. Plugin Support: Hudson can be extended via 3rd party plugins. You can write plugins to make Hudson support tools/processes that your team uses.

Download Hudson
https://hudson.dev.java.net/servlets/ProjectDocumentList

Using Hudson
http://hudson.gotdns.com/wiki/display/HUDSON/Use+Hudson