I want a new tool. Something that solves all of my problems. This is a simple want, but seems to be hard to solve.
Over the years, I've taken responsibility for being the defacto build-meister at most jobs. Back in the C++ days (remember those? Remember CORBA? Right) it was gnu-make and whatever POS we had to use because we used VC++ (I wasn't far enough along to know about Vi or Emacs). I learned Make and the intricacies of just how screwed up VC++'s settings could be. It sucked. We also had to install a bunch of crap on everyone's machine because the idea of having a portable install was years, nigh, decades away.
Then I began to write in Java and things were simple. Simple because there weren't Java libraries to import and our code base was one huge monolith. We were the monkies, throwing bones into the air and hoping they didn't hit us in the head. We tried using Make for Java and that was downright painful, given the fact that we built on Windows and our tools didn't get setup well in Make.
I tried Ant. Glorious day! It did 80% of what I needed out of the box! We were still checking libraries (the few we had) into our SCM. Well, at least the build process worked across Windows and our new *nix environment (that barely ran Java).
Then the Ant scripts grew, and the Ant developers decreed that Ant was not to be a programming language (like Make, but not like Make). And Ant's utility was diminished, but only slightly since I had already spent alot of time learning Ant and could make it dance nicely. However, still checking libraries into the SCM was pretty lame.
Various companies and startups later, Ant hasn't progressed much. It's still the standard, but it's showing it's age. And we're still checking libraries into a centralized place.
Enter Maven. Maven did everything Ant did and more. It managed dependencies and helped you with build standards and and and and... like the over-excited puppy, it tried to be everything to everyone and pleased a good half of the people we ran across. Except no one could remember exactly which prototype to use and, dammit, why couldn't we just go back to Ant since it did everything right without the developers having to remember the various incantations?
Sure. Back to Ant. And lo, Ant gains import and macrodef! (Write Ant tasks you say! You've obviously never developed Ant tasks, I say) Hey, look, you can do some crazy things with this! The Ant task itself will execute a build script when not embedded in a task. Hmm, I can use that to bootstrap all these modules I've created over the years. Kick ass! Now I can easily and modularly upgrade/add/standardize all of our build scripts. Wonderful.
Except that now I have various issues, one being the bootstrap itself (written in Ant, and thus a wee bit limited in it's ability to accomplish useful tasks in a small bundle, and a bitch to upgrade), the other being the job of importing new libraries and functionality. The second is fairly easy, except you have to make your scripts depend on the conventions of your imported library (damn, this is almost as bad as Maven...)
I started out writing Formicidae. This is/was/could be a set of ant scripts + libraries that are easily imported into your scripts. The "bundles" are downloaded from the interwebs (or your cached and possibly modified copies) and expose the various steps you're most likely interested in, either as macrodefs or tasks (with well-known entry points, via pre-defined properties). Bojangles was an Ant task to do just that; manage the dependencies between modules, etc.
Sheesh! There's a mouthful. But it solved a serious problem. Namely never using Maven (more on this later). Seriously though, it did give me a way to manage my build scripts, keep them small and tidy, but it makes for a maintenance pain, since I've sort of broken the integration with many IDEs and Ant as well (Apparently many IDEs don't take kindly to you "doing stuff" to the task model inside of Ant, despite it being a legitimate extension of Ant).
I'm still checking libraries into my SCM. Crap. Enter Ivy. Yay! Something to manage library dependencies and it seems to not groan too much under the weight for the 10-level deep, 100+ node dependency graph we use. Excellent. Except there are issues with the documentation (Hello non-native English documenters! I'm sorry, but the docs suck(ed)) and the betas and alphas and generally it's overcomplicated and seems to do strange things.
Alrighty. So, lets tackle Maven for a moment. Why avoid it? Well, some of it is elegance (which Maven lacks, unless you agree with Maven) and the rest of it is having to bend my projects around Maven. There is a huge upside, which is being able to not have to worry about all of this. However, people tend to integrate with Ant and Ant alone. And I have a hard time convincing people to do something I tend to dislike, which is doing a bunch of work just to get it to work with one specific tool. Ant at least worked around my project and stayed out of my way. Maven... tends to be a bit pushy. I don't always have the same build targets, or cycles, and I don't have time to fix every project to make sure it fits. I don't have to do this with Ant, why do I have to do it with Maven?
Now I'm thinking about how to replace Ivy and it seems to be surprisingly easy. JGraphT includes pretty much everything you need to build and analyze the dependency graph. The remainder seems to be revolve around resolution and other issues.
However, ultimately, I'd love to have a tool (or series of tools) that accomplish several goals. I want a layered approach to my build system : * Simple, easily extensible, and modular build tool. Handles building without "state" (versions, etc). * Project management (namely dependency management) and release management with limited state (versions) * Build server that is project aware and can drive the remainder of the process
Instead of buying the farm with every project, I like being able to ease into the level of management I want with each tool. I sort of get this with Ant + Ivy + Hudson today, but it's clumsy.
So, now I'm going to go figure out how to walk the vertices in JGraphT since I've got a prototype resolver built.
Someday, I may have rebuilt all of this, but for now I'll settle for something that can ready Ivy and Maven dep-graphs and pull down the proper libraries.