Sunday, January 03, 2010

In reply to Java Build Tools: Ant vs Maven

I noticed via @jvanzyl that Kent R. Spillner has been taking apart Maven and some of its features in a recent rant.

The twittersphere has shown support for Kent's views - and being the Maven fan I am, I figured I'd take some time to try countering his post a bit (forgive me if this post is a bit unstructured, I'm trying to squeeze it out under some time pressure).
"The best build tool is the one you write yourself..."

I think this first paragraph contains a lot of absolute statements that happen to be false in a lot of cases. My experience is that a lot of projects or modules are built the same way. It's a bunch of source code, and in the end you end up with a JAR-file. We've got a 25 module web application at work, and I just mavenized the whole thing from Ant. All of the modules exlucding the final web-app module itself were easily built with Maven. Nobody says that every module in the world is built this way, but it sure is a lot. Java code goes in, JAR-file comes out.

It's easy to write an Ant task that does the same thing, but then you end up with all the dependencies in one libs blob, and you invent a big bunch of conventions for your project, which may or may not be more practical than Maven's conventions. You have to document and maintain these conventions, and in all the handful of large Ant-built projects I have seen, these home-made conventions have been unclear, impractical and poorly documented. If you exclude Maven from your tool-suite, I sure hope your build-script developers are real professional smart people. I've met some people like this, and they have made great Ant-powered build conventions, but these same people are most of the time big Maven fans as well.
"If you don’t want to write your own build tool, then you should use Rake."
I only know the concepts of Rake, and I'm not sure it would be the best fit for every project. I would also say take a look at these:

* Gradle
* Ant+Ivy
* Buildr

.. and Maven of course. I am now so addicted to proper dependency management and artifact (Maven) repositories, that I wouldn't want to use a build-system lacking this, so I wouldn't use Ant without Ivy, for instance.
"So, you should write custom build tools for your projects"
No, you shouldn't. In fact, the next few paragraphs have this dogmatic ring to it, which displays a lack of understanding the purpose of Maven, and the whole using the best tool for the job thing.

You do run into tasks that are hard to do with Maven, and in some cases, configuring up the respective Maven plugin is harder. But this depends on the maturity of the plugin, just as it does on the maturity of the Ant task. I recently generated some web service stubs using some Maven Axis plugin, and it was some few lines of configuration just pointing at the wsdl, and worked like a charm after ten minutes of fiddling. The equivelant Ant job wasn't any smaller, and the authors had fallen into this nasty routine of checking the generated stubs into SVN, instead of doing it as part of the build, leading to more manual build steps you have to remember (if anyone has noticed a correlation between working with an Ant environment, and the number of manual steps included for doing a build, well, I share that feeling).

The rest of the post also have this opinionated feel to it. Saying Maven is the worst implementation of bad ideas, well, I think the ideas of dependency resolution and standardized build conventions are good ideas, and Maven is the only tool that really implements all the things I want from a build/dependency/release management system, and it does this fairly well.

Sure the configuration could be less verbose (Maven 3 has solutions for this), it could be optimized for more speed and so forth. But as of today, I'm happy that there is at least some standard system we can use for 80% of the Java world's normal projects.

Onwards with the whole "Maven advocates are liars. " part. Well, this looks like a collection of whining about problems that are fairly well documented and also solved in the Maven world. Yes, you need to have at least one Maven guru in your company to make it work for you, but at least he's dealing with a standard system for which a wide range of resource exists on the web. These are tricky problems you need to solve, and solving them with your own custom build will be hard. Maven can't accommodate every build in the world, nor should it. We have several modules which still are built with Ant, but in the end they end up in the same repository where they can be easily pulled in and used by Maven or Ivy projects.

The dependency management is not broken in Maven. As long as you have a Maven repository you trust, your build is entirely deterministic if you have no snapshot dependencies. You need to have a standard version of Maven everyone should use (of course people are free to experiment with newer versions, and it will probably work fine, but version 2.x is *the* version, running on CI environment and such.

The bloated war thing, well, having to exclude the transitive deps that you don't need is the price you pay for having automated transitive deps, which is a *great* feature in itself. Having to manually go to the dependency-documentation of every dependency, and then onwards recursively, well, I like that Maven gives me a good start with my classpath, and after that I can exclude what I don't need. This is work, and I have to do it, but its less work than how it would be without the automated deps. No matter which build system you use, you need to keep track of your dependencies, which scope they are, which versions they are, and what they are needed for.

The last few paragraphs in the blog post is more complaining caused by lack of understanding of Maven's features and software modularity in general. Of course you need to keep track of which versions you dependencies have. You should keep your dependencies in a repository. If you're unwilling to host a maven repository, or you don't see why having your dependencies in Subversion is a bad idea, then Maven is not for you. Either your project is simple enough to not need this kind of complexity, or you will later run smack into the problems a Maven infrastrcuture solves for you.

I would love to counter the arguments in the last few paragraphs in more detail, but I'm afraid I'm out of time. Refer to my previous "Why Maven" posts if you want more of my thoughts on this.