• Post Reply Bookmark Topic Watch Topic
  • New Topic
programming forums Java Mobile Certification Databases Caching Books Engineering Micro Controllers OS Languages Paradigms IDEs Build Tools Frameworks Application Servers Open Source This Site Careers Other Pie Elite all forums
this forum made possible by our volunteer staff, including ...
Marshals:
  • Campbell Ritchie
  • Ron McLeod
  • Paul Clapham
  • Jeanne Boyarsky
  • Liutauras Vilda
Sheriffs:
  • Rob Spoor
  • Bear Bibeault
  • Tim Cooke
Saloon Keepers:
  • Tim Moores
  • Stephan van Hulst
  • Tim Holloway
  • Carey Brown
  • Piet Souris
Bartenders:
  • Frits Walraven
  • Himai Minh

ANT vs Make

 
Ranch Hand
Posts: 336
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
Is there any article which does a direct comparison between ANT vs Make. I've read the article from "The Saint". I've also read an article in the Java developer Journal and I am ready to dive in.
As a Make user, I already understand the concepts of targets and dependencies. I think I just need to adjust to ANT's syntax. What do you think?
Thanks,
Leslie
 
Author
Posts: 71
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
Hi Leslie,
I don't know of any direct comparison between ANT and make. Pick a problem that you need to solve and dig in. If you're used to make and understand XML, you should do just fine.
Kirk
 
drifter
Posts: 1364
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
I found one comparison:
Comparing ant and make as java build tools
Maybe it's old, it lists one of the cons for ant is that you compile all classes every time. That doesn't have to be true.
[ March 10, 2003: Message edited by: Carol Enderlin ]
 
Ranch Hand
Posts: 171
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
Hi Carol
I think that exactly the opposite is the case. Ant is v smart when it comes to identifying which classes need to be compiled and which ones in a jar file need to be repackaged etc.
This results in a significant improvement in the performance of the build as opposed to relatively dumb MAKE files.
IMHO, Ant totally simplifies the development process even though it can take a bit of time and thought to break down the operations into the appropriate tasks and identify the dependencies between these tasks. One of the key features of Ant is it's open API which allows you to create your own custom Tasks.
Our current implementation includes an Ant script that is automatically run every night which performs the following operations:
1. Check out the latest source code from our version control package.
2. Compile the source code
3. Build the deployment packages.
4. Start our test server
5. Deploy the packages to the server.
6. Run a whole suite of test scripts and send emails to appropriate people detailing any failures.
7. If the whole application builds and tests successfully then deploy the application to our integration server.
Don't fancy writing a MAKE file to do that
 
Leslie Chaim
Ranch Hand
Posts: 336
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator

Originally posted by Andy Bowes:

...
Don't fancy writing a MAKE file to do that


Well, some have done that .
 
Leslie Chaim
Ranch Hand
Posts: 336
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
Well, here is something which I have done using Make. It's very complex and a bit contrived but I was wondering how would this be done in ANT.
First, a brief overview of my problem:
I wanted to build prog (which is written in C) based on all of its dependencies. However, some commands (or tasks) should always run and Make should decide whether to rebuild prog. I made use of The double colon of Make.
The task involved of building two dynamic header files based on information in an Oracle database! This allowed "prog" to be built based on meta-data. One rule always ran which refreshed (or replaced) the header file if it was necessary. If there was a change in the header file then Make would run the second rule.
I really had to do some arm twisting (as you will see) to get this done. I am just wondering how much easier this would have been with ANT.
Here's the snippet from the Makefile:

<code>update_header</code> is a Shell script:

As you can see update_header regards to the first param as a script. Both <code>create_define_file.sh</code> and <code>create_map_file.sh</code> do the same thing: they query the database and return a complete header file.
I will just show the more complicated of the two: create_map_file.sh

A lot of arm twisting I think so! How would this be achieved with ANT?
Thanks,
Leslie
[ March 12, 2003: Message edited by: Leslie Chaim ]
 
You showed up just in time for the waffles! And this tiny ad:
Building a Better World in your Backyard by Paul Wheaton and Shawn Klassen-Koop
https://coderanch.com/wiki/718759/books/Building-World-Backyard-Paul-Wheaton
reply
    Bookmark Topic Watch Topic
  • New Topic