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.

Popular posts from this blog

Encrypting and Decrypting with Spring

I was recently working with protecting some sensitive data in a typical Java application with a database underneath. We convert the data on its way out of the application using Spring Security Crypto Utilities. It "was decided" that we'd be doing AES with a key-length of 256, and this just happens to be the kind of encryption Spring crypto does out of the box. Sweet!

The big aber is that whatever JRE is running the application has to be patched with Oracle's JCE in order to do 256 bits. It's a fascinating story, the short version being that U.S. companies are restricted from exporting various encryption algorithms to certain countries, and some countries are restricted from importing them.

Once I had patched my JRE with the JCE, I found it fascinating how straight forward it was to encrypt and decrypt using the Spring Encryptors. So just for fun at the weekend, I threw together a little desktop app that will encrypt and decrypt stuff for the given password and sa…

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:

    -> ~/.atom/*

    -> ~/.mrconfig
    -> ~/.config/mr/*

    -> ~/.tmuxinator/*

    -> ~/.vimrc
    -> ~/.vim/*

    -> ~/bin/*

    -> ~/.gitconfig

    -> ~/.tmux.conf    

    -> ~/.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 operating on many repositories at the same time.

I discovere…

Always use git-svn with --prefix

TLDR: I've recently been forced back into using git-svn, and while I was at it, I noticed that git-svn generally behaves a lot better when it is initialized using the --prefix option.

Frankly, I can't see any reason why you would ever want to use git-svn without --prefix. It even added some major simplifications to my old git-svn mirror setup.

Update: Some of the advantages of this solution will disappear in newer versions of Git.

For example, make a standard-layout svn clone:

$ git svn clone -s

You'll get this .git/config:

[svn-remote "svn"]
        url =
        fetch = project-foo/trunk:refs/remotes/trunk
        branches = project-foo/branches/*:refs/remotes/*
        tags = project-foo/tags/*:refs/remotes/tags/*

And the remote branches looks like this (git branch -a):

(Compared to regular remote branches, they look very odd because there is no remote name i…

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 without the…

Automating Computer Setup with Boxen

I just finished setting up a new laptop at work, and in doing so I revamped my personal computer automation quite a bit. I set up Boxen for installing software, and I improved my handling of dot-files using vcsh, which I'll cover in the next blog-post after this one.

Since it's a Mac, it doesn't come with any reasonable package manager built in. A lot of people get along with a combination of homebrew or MacPorts plus manual installs, but this time I took it a step further and decided to install all the "desktop" tools like VLC and Spotify using GitHub's Boxen:

  include vlc
  include cyberduck
  include pgadmin3
  include spotify
  include jumpcut
  include googledrive
  include virtualbox

If the above excerpt looks like Puppet to you, it's because it is. The nice thing about this is that I can apply the same puppet scripts on my Ubuntu machines as well. Boxen is Mac-specific, Puppet is not.

It was a little weird to get started with Boxen, as you're offered…