Products comparison - last updated 2005-04-21
We are frequently asked how Ivy can be compared to other dependency management tools. Here is a short matrix summing up a comparison of the products handling dependency management that we have heard about.Obviously, this comparison can not be objective and may be inacurrate for some products, but we have tried to do it with as little subjective judgement as possible.
| Product | Maven ibiblio compatibility | Ant integration | Continuous integration | Transitive dependencies | Flexibility | Maturity | License |
|---|---|---|---|---|---|---|---|
| Ivy | ++ | ++ | ++ | ++ | ++ | + | BSD |
| Maven | +++ | -- | + | -- | + | +++ | Apache Software License |
| Maven2 | ++ * | - | ++ | + | + | --- | Apache Software License |
| HttpUnit Dependencies | ++ | ++ | + | -- | + | - | MIT License |
| Savant | -- | ++ | -- | + | ++ | ++ | Other |
Some Explanations
Maven ibiblio compatiblity
The use of the maven ibiblio repository is interesting because it is already filled with many projects. Benefiting from this repository is thus a plus.On this feature, the best is obviously maven itself, since this repository has been built at the initiative of the project. Maven2 is a bit special, because it changes the layout of the repository compared to maven1, and thus a new repository is available. But everything in the first repository seems to be synced in the second, and how could we say that maven is not 100% compatible with maven repository ;-).
The dependencies task of http-unit is also very good, one of the main aim of the project being to bring this repository to ant users. Savant does not provide such a compatibility.
Ivy, since its version 0.6, can be considered almost as good as the dependencies task. It provides a built-in ibiblio repository compatibility, and the limitation of not being able to say that you depend on a particular jar of a module has been deleted by the 0.6+ feature of artifacts restriction. For sure, the use of ivy files for dependencies is still heavily recommended, the advantage of this technique being that once an ivy file has been written, you can reuse the module easier, and it's the aim of Ivy.
Ant integration
Ant is the most used build tool in the java community. Being well integrated with it is a real plus.On this feature, maven, which is also a build tool by its own and not only a dependency management tool, is the only one to distinguish itself (even if you can call ant tasks from maven, the opposite is not easily the case). Maven2 will propose ant tasks for its dependency management feature, so a good step is taken in this direction. But for the moment it's not publicly available. For the others, integration is at the same level. The dependencies task and Savant could be claimed to be more integrated, since the dependencies are declared in the build file itself and they produce paths or filesets of the dependencies.
Ivy, for its part, has taken the party to be less intrusive in the build file:
- The dependencies are described in a separate file. The advantage of being separated is that this dependency file can be reused for dependency of dependency management, and that it can have its own life in your source control management, in particular.
- It lets you build your filesets and paths by your own. The advantage is that if you already have a build file, you can simply ask Ivy to put your dependencies at the place they used to be, and that's all, you have migrated to Ivy. Moreover, you can still benefit of all the power of ant filesets and paths declaration.
- Since 0.8, it is able to build a path for you with the cachepath task.
Continuous integration
A dependency management tool is the most util when your dependencies change often, and this is especially the case in a continuous integration environment, where your dependencies can change of version very often.On this point, as far as I know, Savant do not allow to automatically change the version you use when a new is released.
Maven provides a SNAPSHOT feature, which enables continuous integration only if the component you depend on publishes SNAPSHOT versions. And you can by no way know which was really that version, in order to get that particular version on a later time.
I have for the moment very few information on Maven2 on this subject, but it will at least do what maven did.
The dependencies task say you can tell that you depend on the latest version, and that it is then the responsibility of the Repository to get it... but I haven't found more information on their web site. Maybe it uses the same principle as Maven...
Ivy uses pluggable latest strategies to find the latest version, so that the component you depend on has nothing special to do. Moreover, it produces a report in which it tells which version has been retrieved, so that you can easily know the environment of the component you are building. Finally, it can even produce an ivy file with all latest revisions resolved to a fixed one, so that you can use it to reproduce the same environment even later, when new versions of the dependencies will have been built.
Transitive dependencies
Transitive dependencies management, also known as dependencies of dependencies management, let you reuse more easily complex components which have themselves dependencies, and help you manage conflicts between dependencies.Maven and the dependencies task does not provide this feature at all.
Maven2 will provide this feature, but few doc is avaialble for the moment. It seems that it will be handled by declaring a dependency on the pom of another project. I have no information on how filter will be applied to the transitive dependencies.
Savant actually manage transitive dependencies, but you automatically get all dependencies of your dependencies, not being able to filter them easily.
Ivy provides this feature, and, with its concept of configurations, let you choose the set of artifacts of your dependencies you really need. You can even use fine graine filters (include/exclude) to adjust what you want. Finally, its unique configurable conflict manager let you manage conflicts the way you want, even if the default strategy works in most cases so that no special configuration is required.
Flexibility
Is the dependency management tool able to adapt to your environment, or have you to follow its rules ? It's a matter of flexibility, and it's hard to evaluate.As far as I know, Maven dependency management is based on a rigid structure of repository you have to follow, unless you specify for each jar where it can be found, which does not really let you have a repository structure of your choice. Maven2 will certainly follow the same philosophy. The dependencies task has the same limitation, unless you create your own implementation of Repository. Savant seems to provide a lot of flexibility, but it also seems quite hard to configure.
Ivy is extremely flexible:
- comes out of the box with two main ways to find dependencies (filesystem based and url based)
- let you configure your repository layout with very simple to define patterns
- let you use multiple repositories, chaining them or defining which repository to use for which modules or group of modules
- let you choose where you artifacts are copied in your file system, with or without version in the name, and structured the way you want, all with the same simple pattern principle
- let you define reusable configurations of your component, since a same component does not have the dependencies at build time or runtime, or when deployed in a server or as a standalone application, etc.
Maturity
On this point, two products are now quite old and can be considered mature: Maven and Savant. On the other hand, the dependencies task has published its first version (0.1) on september 2004, and, at the time of this writing, no version has been published since their 0.4 in december 2004.Maven2 is still in alpha, with no public download and very few documentation.
Finally, Ivy as published its first public version (0.5) on january 2005 after several months of use in our company. After several months of user driven development and testing, and after several weeks of release candidates cycles, it is finally close to its first stable release: 1.0. It's still far from being "mature", but backward compatibilty will be assured with future versions, and the user communitity grows from day to day. And if you want to have a look of what others think of Ivy, check the links section.
Feel free to comment the comparison on this page if you think that we have forgotten some points or missed features of the other products.
The comments are owned by the poster. We aren't responsible for their content.
| Poster | Thread |
|---|
