Skip to main content

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.


  1. Build tooling is one of the few areas where we are able to get reuse to work consistently. I am fairly certain creating a one-off build tool for my project doesn`t cause the world to become a better place.

  2. Actually having a repository you trust is not enough to make a Maven build deterministic. You also need to specify the version of every Maven plugin you happen to use, knowingly or not.

  3. xpmatteo, since one of the early maven 2.0.x releases, there have been default versions for the standard maven plugins in the super-pom. If you know which maven version is being used (usually standard for a company/team), you know which plugin versions were used. If you add new plugins and forget to define version, well, I share the opinion that this is a weakness in maven's design.

  4. Anonymous10/2/12 20:33

    Where to start?

    "and I just mavenized the whole thing from Ant."

    why on Earth did you do that?

    "but then you end up with all the dependencies in one libs blob,"

    exactly, far, far superior to a repos that is no longer under source control.

    "and you invent a big bunch of conventions for your project, which may or may not be more practical than Maven's conventions."

    Right, with about 99.999% of the time being MORE practical, and 0.001% of the time being LESS practical.

    "and Maven of course. I am now so addicted to proper dependency management "

    So, storing all the required jars in one directory (call it 'libs') and letting each module link to that jar (each having the version in the name), is this somehow not 'proper'? I would argue that it is:
    1. easier to understand
    2. easier to remove a jar and swap out with the source should debugging be required
    3. does not require a plug-in that destroys the meticulously optimized incremental build logic of Eclipse.

    "I have seen, these home-made conventions have been unclear, impractical and poorly documented."

    Have a look at H2. It has a nice built-in build tool. By using the Ant project logic (the recursive dependency 'topo sort') you can have a complete build tool without the baggage in about 2 days. This solution is clearer, more practical and requires less code and therefore less documentation

    "Yes, you need to have at least one Maven guru in your company to make it work for you"

    you must be joking. This statement is an admission of the complete failure of Maven.

    "As long as you have a Maven repository you trust, your build is entirely deterministic "

    Why would you trust a repository not under SCMS control?

    "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."

    automated transitive deps is a HORRIBLE feature, causing libs to be in the classpath of upstream modules that would not otherwise be explicitly included. They are not the default in NetBeans OR Eclipse (being bad design) as they introduce the possibility of coupling where before there was none (i.e., is this 'leaf' library required by an upstream module?), thereby decreasing modularity. The Eclipse Maven plugin includes all downstream jars, making projects that previously only required one or two libraries appear as if they required 10. This makes it more difficult to understand what a module does.

    Why Maven continues to have so many fanboys is a mystery.

  5. Hi Anonymous,

    I've argued for pretty much all these points in this 3-part series:

    In the end it's a subjective choice where each side has its plus'es and minuses. There are certainly contexts where maven isn't the right tool for the job, but the arguments all still stand in their own right.


Post a Comment

Popular posts from this blog

Open source CMS evaluations

I have now seen three more or less serious open source CMS reviews. First guy to hit the field was Matt Raible ( 1 2 3 4 ), ending up with Drupal , Joomla , Magnolia , OpenCms and MeshCMS being runner-ups. Then there is OpenAdvantage that tries out a handful ( Drupal , Exponent CMS , Lenya , Mambo , and Silva ), including Plone which they use for their own site (funny/annoying that the entire site has no RSS-feeds, nor is it possible to comment on the articles), following Matt's approach by exluding many CMS that seem not to fit the criteria. It is somewhat strange that OpenAdvantage cuts away Magnolia because it "Requires J2EE server; difficult to install and configure; more of a framework than CMS", and proceed to include Apache Lenya in the full evaluation. Magnolia does not require a J2EE server. It runs on Tomcat just like Lenya does (maybe it's an idea to bundle Magnolia with Jetty to make it seem more lightweight). I'm still sure that OpenAdvant

Managing dot-files with vcsh and myrepos

Say I want to get my dot-files out on a new computer. Here's what I do: # install vcsh & myrepos via apt/brew/etc vcsh clone mr mr update Done! All dot-files are ready to use and in place. No deploy command, no linking up symlinks to the files . No checking/out in my entire home directory as a Git repository. Yet, all my dot-files are neatly kept in fine-grained repositories, and any changes I make are immediately ready to be committed: config-atom.git     -> ~/.atom/* config-mr.git     -> ~/.mrconfig     -> ~/.config/mr/* config-tmuxinator.git       -> ~/.tmuxinator/* config-vim.git     -> ~/.vimrc     -> ~/.vim/* config-bin.git        -> ~/bin/* config-git.git               -> ~/.gitconfig config-tmux.git       -> ~/.tmux.conf     config-zsh.git     -> ~/.zshrc How can this be? The key here is to use vcsh to keep track of your dot-files, and its partner myrepos/mr for o

Using Voice-Chat for Gamers in Distributed Teams

This is a post going into the usefulness of live voice-chat tools in distributed teams. If you've ever seen the Leeeeeroooooyy Jeeeenkiiins video of World of Warcraft fame, you've heard this kind of tool in action. It's how the participants in the video are speaking with each other - this is not a feature built into the World of Warcraft game - it's a separate team-oriented VoIP software, and it's all about letting gamers communicate orally while gaming.  Since these tools are for gamers, they have to be fast (low latency) light (as not to steal CPU-cycles from heavy games graphics)  moderate in bandwidth usage (as not to affect the game server connection) There are several options around: TeamSpeak , Ventrilo , more recently the massively grown Discord , and finally Mumble , which is the open-source alternative of the gang. A few years ago, when I joined eyeo (a distributed company), several of the operations team were avid gamers, and had a TeamSp

Joining eyeo: A Year in Review

It's been well over a year since I  joined eyeo . And 'tis the season for yearly reviews, so... It's been pretty wild. So many times I thought "this stuff really deserves a bloggin", but then it was too inviting to grab onto the next thing and get that rolling. Instead of taking a deep dive into some topic already, I want to scan through that year in review and think for myself, what were the big things, the important things, the things I achieved, and the things I learned. And then later on, if I ever get around to it, grab one of these topics and elaborate in a dedicated blog-post. Like a bucket-list of the blog posts that I should have written. Here goes: How given no other structures, silos will grow by themselves This was my initial shock after joining the company. Only a few years after taking off as a startup, the hedges began growing, seemingly almost by themselves, and against the will of the founders. I've worked in silos, and in companies wit

The End of GitMinutes (my podcast)

I'm just about ship GitMinutes episode 46, which is going to be the final episode. I'll just paste the outro script here, as it sums up the sentimental thoughts pretty well: I’m happy to have finally finished [publishing the last episodes from Git-Merge 2017], just in time before Git-Merge 2018 takes place in March. I won’t be going there myself, so I’m counting on someone else to pick up the mic there. It’s sad to be shipping this one as it is probably the last GitMinutes episode ever. To go a bit down memory lane, 6 years ago, my daughter was born, and as I used a little of that paternity leave to set up my podcasting infrastructure and produce the first few episodes. Initially it was just going to be 10 episodes and call the experiment finished. Instead, I got to 46 episodes, the last dozen or so lazily tailing the last few Git-Merge conferences. To every one of my guests, thank you so much again for coming on to share your passion in this little niche of computer s