Craig wrote:jfrazierjr wrote:
There has been talk of using either Maven or Ivy. They both have pluses and minuses. Note that the "official" approach right now is to target the use of Maven. Personally, I would rather use Ivy since it's easier to deal with in absence of someone who already knows Maven and is willing to put in the work to set it up. ie, all things being equal, why pick the harder to learn and configure tool set...
But all things are not equal,
Well, in the context I am talking about, they are equal or at least I don't know that they are not. My context is from the point of view that none of the current developers are fairly proficient in either Maven or Ivy. If this is NOT the case and someone(you for example) who will be committed to making the build files or documenting the process already has fairly extensive knowledge of Maven, yea, it makes sense to at least evaluate the differences before choosing a tool, especially when both my limited personal experience as well as tons of people have reported that Ivy is simpler than Maven.
From the point of view of a developer who just wants to do a build AND the build process is already established, I would not care less which of the two(or even others not considered for that matter) is used. From the point of view of someone who might want to invest the time to learn one vs the other to contribute in absence of an existing expert on one or the other, THIS is where I say Ivy is the easier tool to learn and should be considered at least from that standpoint.
Craig wrote:there is always the possibility that Ivy only does a subset of what Maven does.
Well... I am sure there might be one or two things it might do Ivy can't, but the question is do we need that thing that we don't know what it is or if we need it....
Craig wrote:
Apart from dependency management there are other problems to solve, one of them is I want to get away from being semi dependant on Eclipse.
This part puzzled me... are you believing Ivy is dependent upon Eclipse? While I use Eclipse, I have no problem with the team(as if it really mattered to anyone anyway) wants to make it more IDE agnostic. I think this is a very good idea. Just for the record, when I was doing some testing with Ivy and the parser project a few months ago, I intentionally set up Ivy+Ant to work from the command line vs Eclipse based and ran into no problems, so there is no dependency upon Eclipse to use Ivy for builds. In fact, the integration with Eclipse seemed to be far more trouble that it was worth, but I have read many complaints from Maven people with the same experience of the respective Eclipse plug-ins
Craig wrote:
-- I am at the point that I really loathe it as an IDE, I shouldn't have to spend so much time fixing up problems with my IDE, its like the Windows Vista of IDEs. Maven projects can be imported into many IDEs with a lot more configuration information than projects only using Ant. Although I like to use Vim where can so that's not such a biggie to me, but I can imagine some people will want to use Eclipse, or NetBeans or IntelliJ or.... and then there is the other problem where people just have trouble using a simple ant build and have to complicate it as soon as you turn your back and suddenly you end up with this monstrosity of a build file.
I don't have a problem with making the code structure and build processes IDE agnostic. Some people STILL program in a plain text editor and while that's not for me, I am not going to suggest they change what they like and are used to(unless they ask for opinions) Personally, I would love to learn Vim enough, but it something you have to use consistently and I just end up giving up and doing things the fast way and then of course forget what I did when I try again 2 months later. On the flip side, my day job is working with a middle ware product, so I rarely do "real" low level coding on a frequent basis any more. The closest I have come lately was working on upgrading some functionality of a .Net web application off and on for a few months.
Craig wrote:
Then again maybe we should just go Ivy and Ant and let everyone deal with their own IDE project setup.
Fine by me... I can used the command line/shell without a problem for most fairly simple things on the three big OS's.
I guess my point here with keeping bringing this up is that it appears Maven was chosen because it was the "big guy" as opposed to choosing the best tool for the job. There are people who can make some amazing art work with a chain saw, but about all I can do with it is cut some wood in half. If you are an expert on Maven configuration, then by all means it's probably best to use the tool we have someone dedicated to the project who already knows it. But I know Azhrei has stated repeatedly he does not know more than the basics of either Ivy or Maven and he won't have time to learn. Ditto me, but at least I have test driven both and in my opinion, either Maven was far harder than Ivy or I was just to darn stupid to figure it out(and someone else may easily pick it up.)
Hence my suggestion of Ivy over Maven or AT THE LEAST let's do some due diligence of researching the tools before making a decision. As noted, I DID look at both (Maven first) and after 4+ hours trying to figure out Maven, I was no closer to getting anything even close to a "prototype". With less than an hour of Ivy, I had built one of the existing projects and within 2.5, I had tweaked the existing ant scripts with Ivy to build 3 projects, 2 independent ones(parser and rplib) and a "parent"(dicelib in this case) which depended upon both of the previous ones.
Based upon our stated goals of OSGi, added to my already existing experience of the two tools and reading other people who have used one or the other of the tools trying to move an existing application to OSGi, Maven's complexity(which I personally thinks is already high) goes WAY up. Of course, Ivy's does too, but the complexity appears to be much more linear as opposed to Maven's exponentially.
I hope I have finally conveyed the objective of why I keep bringing "issue" this up. To summarize:
- In absence of an expect at configuring one vs the other, we should not just pick one arbitrarily, but perform an evaluation to determine which once will best meet the needs without undue future burden.
- I have performed an evaluation as above and believe Ivy is a clear front runner from the ease of use and learning curve for a build dependency management tool.
- If anyone else want's to take the time to do as I have and compare the two (or even more than these two for that matter!!!), I don't have a problem with that and would encourage it!
- Alternately, If someone says "I am going to learn Maven and make all of the build files", I say great, have at it and would have no problem with using Maven. So far, no one has committed the time to do either 3 or 4 and has stuck around.
At this point, from a consistency stand point, it's Azhrei, yourself, and me as developers of MapTool. With the occasional contribution from Phergus and Rumble(thinking about those who have been trusted to join the mailing list). Based upon the past, I doubt Phergus will have time to learn Maven or Ivy and I rather doubt Rumble wants to. So that leaves you, me, or someone unknown to take the time to create a build system for all of the existing projects. Who knows, perhaps username already has the experience with Maven and will volunteer. He has contributed a number of bug fixes in the past year or so... Of course, he seems to have an opinion similar to mine in that Maven is a big PITA unless you do things exactly the way it want's them done.