User: runs Ant with a complete build specification and/or writes Ant build specifications.
Task Developer: writes/modifies Ant tasks.
Extensions Developer: develops extensions like a GUI, IDE plugin, (scripting extension?)
Core Developer: works on the Ant core
It should be easy to write a build file for small Java programs. It should be possible to write a build file set for large Java systems. Maintenance of such a set should be easy (e.g. no duplication of information).
Every build process contains dependencies (e.g. item A needs B to be available before its own build can start). It should be possible to specify these dependencies in a declarative way.
Suppose a working build specification for system A is available. It should be possible for system B to declare dependencies to (modules of?) system A without touching the build specification of A. Ant should be able to handle dependencies between modules which form a DAG.
It should be possible to modify details of the actual build (e.g. classpath, used compiler) without the need to change the build specification. This feature is needed when starting Ant (e.g. configuration with command line parameters) and for a subproject build driven by the build of a dependent project.
Often similar items have to be built. Therefore it should be possible to provide general (template?) build specifications, and to declare for a concrete item that it should be built according to such a general specification.
One result of the build process should be a log which shows what has been done.
A task should not need to know the structure of a build specification. It would have to provide an interface (not necessarily in the Java language sense) for the Ant core to input the necessary configuration attributes and to execute the task). There should be a standard functionality to allow a task doing log output.
An interface (again not necessarily in the Java language sense) should be provided which allows a task to get (and set?) information about it's context in the build process.
The Ant core should be independent from a specific representation of the build specification. It should be possible to create a specification programmatically (thereby allowing the introduction of new representations). The core should do no in- or output itself. Build errors should always lead to throwing an Exception.
Access to the current state of a build should be available, and its modification possible.