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).
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.
* 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.
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.
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.
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.
ReplyDeleteActually 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.
ReplyDeletexpmatteo, 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.
ReplyDeleteWhere to start?
ReplyDelete"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.
Hi Anonymous,
ReplyDeleteI've argued for pretty much all these points in this 3-part series: http://blog.tfnico.com/2009/04/reason-3-dont-build-everything-all-time.html
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.