This document compares the build tools Apache Ant and Apache Maven. It outlines that Ant is more procedural while Maven follows a standardized lifecycle approach. Maven enforces project conventions, manages dependencies automatically, and allows building complex products with minimal configuration. While Ant provides more flexibility, Maven scales better to larger projects through its standardization and automation.

1. ANT vs MAVEN
A Maven build follow a life cycle
- generate-resources
- compile
- test
- package
- Install
- deploy
- clean

2. Apache Ant
● Ant doesn’t have formal conventions like a common project directory
structure or default behavior. You have to tell Ant exactly where to find
the source and where to put the output. Informal conventions have
emerged over time, but they haven’t been codified into the product.
Apache Maven
● Maven has conventions. It knows where your source code is because
you followed the convention.

3. Apache ANT
● Ant is procedural
● Ant doesn’t have a lifecycle. You have to define goals and goal dependencies.
You have to attach a sequence of tasks to each goal manually.
Apache MAVEN
● Maven is declarative. All you had to do was create a pom.xml file and put your
source in the default directory. Maven took care of the rest.
● Maven has a lifecycle which was invoked when you executed mvn install. This
command told Maven to execute a series of sequential lifecycle phases until it
reached the install lifecycle phase. As a side-effect of this journey through the
lifecycle, Maven executed a number of default plugin goals which did things like
compile and create a JAR.

4. Maven's strengths:
● Enforces a standardized project layout. This saves time
getting new people working on the project.
● Provides automatic resolution of dependencies.
● Promotes the concept of a resource repository.
● Can create complex products with minimal direction.

5. Ant's strengths
● Flexibility in project organization.
● Know what happens in the build.xml
● Ant's weaknesses are that you can't get automatic
resource resolution with basic Ant (although you can use
Ivy), you have to code your own rules in detail for each
project, and the build environment is only as portable as
the person who designed the build.xml forced it to be.

6. Maven Drawback
● Surefire Tests
● Space 2/3rd extra

7. Maven is great if:
● You are working with many "creative" developers. It will be hard to
establish a defined project structure etc. without tool support.
● The developers are religious about their IDE and are using IntelliJ,
NetBeans and Eclipse at the same time.
● You are building a product-like application. You will have to manage
different versions and branches with their dependencies.
● You project consists of several teams which work on dependent
modules. These modules have to be composed to the application
regularly.
● You plan to use checkstyle, pmd, generate a project website etc. It's
easy with Maven.

8. Choose Ant for:
● "Situational Software" which has to be developed quickly (in a few weeks / months).
● Projects with external dependencies which are working with "cutting edge" libraries.
There is no need for finer grained dependency management.
● NetBeans projects :-). They come with predefined Ant scripts which even work
perfectly with Hudson. Just check everything into svn and let hudson check it out...
● Legacy projects which do not fit the Maven conventions very well. Violating Maven
conventions may become a hassle.
● Projects without explicit requirements for modularization. The deployable output will
consist of only a few archives.