Hi Guillaume,

On Oct 6, 2008, at 10:54 PM, Guillaume Laforge wrote:

Unfortunately I have no time in the next days to dive into the details of the Groovy build. Instead, for now, I will share my general view on Ant.

I have always liked the flexibility of Ant and its wealth of helpful task. With Ivy it has a much better dependency management than Maven. I also think dependency based programming [1], which is the base of Ant, is very suitable for the needs of the build system. But Ant has its fundamental problems:

- It has no build-by-convention support which makes a build harder to maintain. - Together with Ivy it has some support for modularization. But not a very good one. - It is hard to avoid redundancy in your build code, specially if you have a multi-project build. Ant's approach to improve this has been to introduce general purpose elements (e.g. Mixins, Macrodefs, ...) into its external XML DSL. This is better than nothing but those elements have a steep learning curve. They make a build extremely hard to understand for the non-initiated. And of course they are still a pale imitation of what you can do with a real programming language like Groovy. - The XML approach makes it very verbose. - Ant allows only for an anemic interaction with Java/Groovy. You have to wrap any Java/Groovy code into a task. You can only pass String arguments to this task. What about return values, doing something with return values like looping. I guess I don't have to go into details about this on the Groovy list. This is a serious limitation for customizing your build. Ant somehow tries to alleviate this by introducing its own general purpose elements like its famous if statement. The limitations are obvious.

How does this compare to Gradle?

- Gradle offers you all the flexibility that is offered by Ant. Gradle also has dependency based programming as its base. In fact Gradle offers you more flexibility as it is based on an internal Groovy DSL and its language for dependency based programming is richer and provides an API. On top of this flexible base, Gradle provides plugins which constitute highly configurable, small build-by- convention frameworks. - Gradle's support for modularization (multi-project builds) is very strong. Far better than what is possible with Ant (and by the way with Maven). - Gradle uses Ivy under the hood and thus provides the same excellent dependency manager as Ant does. But Ivy is integrated in Gradle's build-by-convention approach and thus easier to use for the normal use cases. - The fact that Gradle uses and internal Groovy DSL obviously solves many of Ant's problems mentioned above.

If you just want to build a jar than all this might be not much of a problem. But if you are serious about project automation Ant makes your life very hard and unproductive. In fact, I have seen many projects not harnessing the power of project automation because Ant or Maven made this too hard to achieve. And although the Groovy build is not the most complex one in the universe it applies to it as well I think.

With Ant your build will also have a lot of redundancies and/or Ant specific general purpose elements. Both make the build hard to understand and make the build very intransparent to people who are not build master. This will be a serious problem if you go for modularization.

- Hans

[1] Dependency based programming is a term I think coined by Martin Fowler. It is about creating a graph of actions which have a depends relation to each other (a directed acyclic graph (DAG)). The build system makes sure that every action gets only executed once. Every popular build system I know is using this approach (Make, Ant, SCons, Rake, Gradle :)). Maven 2 thought it is a good idea not to be based on this. I'm not sure if this was a good idea.