T
tom fredriksen
Thomas said:I was waiting for that comment about make.
On one side we have make, which at a certain point insists on using a
tab instead of single spaces. On the other side we have ant with XML.
Which insists on proper nesting, proper closing of elements, a boatload
of '<' and '>', a boatload of different elements with a boatload of
different attributes in some deep nesting.
Now, I rather know which side I prefer. I have no problems with putting
up with an innocent tab.
I dont think there are any build tools for java out there that are close
to perfect. I think a build tool that contains elements from both make
and maven would be the best solution. I dont know about Ant, but I cant
see it introducing anything of value than what Make/Maven already has.
Here is a list of features a merged Make/Maven should have, IMHO...
- Maven has a predefined directory structure so it can find the
info/code where it expects it to be.
- Mavens has an intelligent compile system, by only specifying the
directories where source code is contained.
- Maven has predefined maven modules which can perform a vast array of
tasks, due to the directory structure. You dont have to script or
program anything for most uses.
- Maven automagically knows how to run tests, create jars, wars, perform
deployment etc as long as the info it needs it located where it expects it.
- Maven has one property file for the entire host
property file for entire project.
- Maven/Ant uses XML; NO USE OF XML should be allowed(XML is intended
for machines, not for humans)
- Make is too oriented around mundane details, This slows down the
project because you have to reinvent the wheel for many of the same
tasks for each new project. It also has some quirky syntax which should
be removed.
- Make is fast (native program), maven is slow (java program). Just
performing a dead-end compilation in maven takes 2 seconds on a single
file, in make its done in 0.1 second.
- maven has a slow compilation cycle. For creating a jar it needs to
perform seven or eight steps. When doing active developement, waiting
for all those steps to complete can typically take 30-60 seconds. With
make this can be done in 5-10 seconds (For this specific project). This
is because, see next item...
- Make allows one to control an action in detail, maven does not. I
usually want an target called "compile" which performs all tasks of the
jar target without running tests, this is for developement and a fast
build turn-around. In maven this is not very possible. With make it is.
- Maven requires a lot of network interaction to handle dependencies and
to handle internal dependencies and deployment. This is handled
efficiently and without any network interaction in make.
So in essence maven works almost automagically, but with almost no
ability to adapt to the project or users specific needs. While make
gives you the adaptability, but at the cost of thousands of hours of
make scripting for each new project.
At the moment I dont know what I will be doing in the end, but I am
seriously considering joining the maven project to do something about it.
regards
tom