Maven: great idea, poor implementation (Part 2)
In my previous post I explained why Maven is a good concept for Java project builds. In this post I'll delve into a key area where it falls down, the overcomplexity of its configuration.
In brief, we have a proliferation of home-brewed build systems created in many different ways using Ant, all of which do much the same thing. Since the vast majority of Java projects have very similar build requirements, an off the shelf build system should be able to do the job.
More to the point, a standard build system using convention over configuration should be simple to set up and maintain. This in turn helps the development team's velocity, since less time is spent fiddling with (or worse, fighting against) the build system, so more time can be spent delivering value for customers.
Maven fulfils this if your build needs are ridiculously simple. Slap your source code into folders for application code and test code, name your tests right, and put in a very small pom.xml file. Run "mvn install" and your code is compiled, unit tested, and ready to deploy.
Things get ugly pretty quickly though, as soon as you need to make even a small tweak to the basic build.
For example, let's look at what's involved in changing the version of Java you want your project built to, for language compatibility and/or for compatibility with the runtime environment your project will be used in. Maven 3.0.x uses Java 1.5 by default, even if you have Java 1.6 installed, which is sensible enough.
So we have two parameters that need changing, language version for the source, and target version for generated classes. Here's what we have to add to our simple pom.xml to achieve this:
<project> [...] <build> [...] <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>2.3.2</version> <configuration> <source>1.4</source> <target>1.4</target> </configuration> </plugin> </plugins> [...] </build> [...] </project>
So the first thing that strikes you is, holy spaghetti, that's a lot of scaffolding for two parameters. Someone wading through a pom file trying to understand our build in order to modify or fix it will have a hard time working out the meat of this snippet, and it's not clear that it's all only there for those two parameters.
Much worse, the extra scaffolding isn't harmless. Before we had this, compilation was done by the maven-compiler-plugin, using the latest available version for the version of Maven we're using. Now this out of the box default has been surfaced in the pom file. Our project is locked into knowing about, and managing the plugin and its version. If we don't specify the version, Maven 3.x prints a scary warning suggesting that in the future it will no longer enable our careless disregard for managing the nuts and bolts of its innards, so expect our build to break horribly.
As soon as you set any configuration option on a built-in component of Maven, you are forced to take responsibility for that component that you wouldn't have otherwise, and clutter your configuration with stuff that would otherwise be assumed by Maven.
Now suppose you want to run integration tests on your code, that run heavier weight tests in a separate phase after unit testing. The testing model we're following is to have lightweight unit tests that run fast for quick feedback on basic errors, then heavier tests which probably need a container like Jetty, and perhaps a database, to test a bit more deeply. It's often referred to as integration testing, meaning you're testing the components of a single application integrated together.
(However, the naming leads to confusion since integration testing can also refer to testing integration with external applications, web services, etc.)
So Maven supports running a separate set of tests in an integration test phase that runs after the unit tests, using the failsafe plugin. How do we make use of this? Firstly, we write JUnit test case classes, and name them ITMyClass, and the "IT" beginning tells Maven to run them in this phase.
So does Maven just find and run these classes if they exist? Of course not, you have to add some configuration to your pom.xml so it knows. Fair enough, Maven shouldn't waste our precious build time searching all of our test classes for ones named with "IT" if we aren't using integration tests.
So, it should be a pretty simple configuration setting to tell Maven we're using the integration test phase. Right?
<project> [...] <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-failsafe-plugin</artifactId> <version>2.7.2</version> <executions> <execution> <id>integration-test</id> <goals> <goal>integration-test</goal> </goals> </execution> <execution> <id>verify</id> <goals> <goal>verify</goal> </goals> </execution> </executions> </plugin> </plugins> </build> [...] </project>
(From the failsafe plugin docs.)
Holy scaffolding! All we've really told Maven with all that configuration is to include the "failsafe plugin", and wire it into the build lifecycle to run at the integration-test phase. But again, we've locked the plugin details, including the version number, into our project's pom file.
In this case, we've also had to explicitly (and verbosely) specify the lifecycle phase. So this is a plugin whose whole purpose in life is to be used in the integration phase of Maven's build lifecycle, abut we have to take it by the hand and tell it exactly how and where to wire itself into the lifecycle, even though we're following its default use case.
That isn't configuration over convention! That isn't even Mexico!
Oh, wait, this doesn't run our integration tests with a servlet container. Let's plug in Jetty. It's actually pretty easy, just copy, paste and tweak the example in this documenation from Codehaus (the second XML snippet on that page).
There is even a bit more meat in the configuration, which is fair enough, since there are a few things you might like to configure when running a servlet container. But you've still got loads more configuration, much of which is calling out details of Maven's execution lifecyle that are, when it comes down to it, the default for 90% of the people using this.
So you can see how your Maven project's pom.xml file quickly becomes packed with unneeded crap, which increases the barrier to understanding and modifying the build. Once you develop a pretty good understanding of Maven's internal structures and models you become adept at working out which parts of the pom.xml are scaffolding, and which you actually care about.
But most developers on a team won't invest the time to master Maven, and shouldn't need to. They have business value to deliver. This is the wall I'm hitting supporting a high performance development team, because there is a low tolerance for spending time on things other than building the application features customers need.
So is Ant any better than this? As I said in my previous post, Ant builds typically become over-complicated. But Maven projects not only suffer from complexity, they also suffer from Maven's inflexibility. Normally you'd consider trading off some flexibility for simplicity, as long as the end result was higher productivity.
So my next Maven post
will focus on a specific area where Maven's inflexibility is hurting my
team's productivity. I don't currently have more than these three posts
in mind for this series, but then my team is still only in iteration 0.
Part 1 and Part 3 are here.
Feedback on these posts: I'm more than happy to be told I'm wrong, particularly if there are easier, simpler, and better ways to implement the examples I've described. The best way to give feedback to comment below and mention me (@kief) in a Tweet, with a link to your response.
(Note: Opinions expressed in this article and its replies are the opinions of their respective authors and not those of DZone, Inc.)