I have been following this thread and I guess it is time to chime it
a bit with what I know. First my background. I used Eclipse since '03
for Java development then switched in mid '06 to C++ development with
Eclipse/CDT so I have a fair amount of experience with Eclipse, Ant
and about a year of full time CDT and CMake.
I am just going to rattle off some answers/corrections to the various
items that have been posted in this thread:
Eclipse Plugin Development: Usually you develop a plugin for Eclipse
using their PDE (Plugin Development Environment). This is almost
certainly going to be written in Java with maybe a small JNI module
if you absolutely need to jump across the Java/Native bridge to do
something in the C++ world. Eclipse will manage the build of your
plugin using what ever build mechanism Eclipse uses for Java.
CDT Projects: There are 2 kinds of CDT projects; 'Managed Makefile'
and 'Makefile'. In the 'Managed Makefile' project Eclipse basically
does the project management for you and then creates a Makefile
behind the scenes and then invokes that makefile to build your
project. In a 'Makefile' project you bring your own makefile to the
project. CDT just provides the IDE environment. The major downside to
the 'Managed Makefile' project is that there is really only 1
'Target' in your project, so anything past a basic "hello World" or
"Hello Library" is beyond the capability of CDT (at least how I
understand it), which is why I am guess that most people use the
"Makefile" project so they can have 1 project with lots of
"targets" ( Library, Executable, Testing harness).
Right Tool for the Right Job: As stated in previous messages, CMake
is a great "Generator" of 'project files' ( Makefile, Xcode, VS,
Nmake) for typically C/C++ projects. ( I have no experience with any
other language + CMake). Ant is a just as awesome build system for
Java. Use the right tool for the right job. If I am doing Java Dev,
CMake will NEVER enter the picture. If I am doing C/C++ dev then Ant
will NEVER enter the picture. If CMake generated an Ant xml file for
java projects then you may be onto something.
Cmake File Editing: There is a plugin at http://www.cthing.com/
CMakeEd.asp that adds a nice editor to Eclipse that makes editing
CMake files easier. It offers syntax highlighting, command completion
and integrated documentation. Very nicely done.
Current CMake/Eclipse Integration: http://www.cmake.org/Wiki/
CMake:Eclipse (which I wrote) goes over the current state of affairs
in using CMake with Eclipse. Generally after bootstrapping the
process things are pretty smooth as cmake will make sure your
makefiles are up to date if you change the CMakeLists.txt file. Where
things are NOT smooth is if you are making MAJOR changes to your
CMakeLists.txt files then I find that I need to use an external
"Terminal" program to clean things out and re-invoke ccmake to set my
project up again.
On the Eclipse download page http://www.eclipse.org/downloads/ there
is a specific selection to download just the base eclipse + CDT
without all the extra java IDE stuff. This works rather nicely. If
you need to have some XML editing capability (say for paraview
development) then you can easily download the proper XML editors for
that function.
<opinion>CMake would have an extremely difficult time luring java
developers from Ant or Maven to use Cmake for a build system and vice
versa, Ant would have a difficult time luring c/c++ developers from
cmake. Each party should concentrate on what they do best.</opinion>
Sorry for top posting..
--
Mike Jackson Senior Research Engineer
Innovative Management & Technology Services
On Jul 31, 2007, at 3:05 AM, Eric Noulard wrote:
2007/7/31, Brandon Van Every <[EMAIL PROTECTED]>:
On 7/30/07, Andy Dingfelder <[EMAIL PROTECTED]> wrote:
Building java apps it typically done using Maven or Ant, and I
see no
need to re-invent the wheel and use cmake to do that.
I do. If you want Eclipse developer mindshare, then ultimately you
want CMake to work as a Java build tool as well.
I'm following this interesting thread and here I must say
that I disagree.
CMake I think should never became "A Java build tool"
CMake "may" add java support which may end up
in generating ant build files.
Ant is a build tool which may be compared to make
(ant is much much much nicer and powerful than make though)
CMake (from my point of view) is a build tool GENERATOR.
You may not need any
of that at first, but you aren't going to get a snowball of support
unless CMake is handling basic Java builds. That's the strategic
risk. Strategically, if Ant figures out how to do C/C++,
Ant already does, see cc Task:
http://ant-contrib.sourceforge.net/cc.html
and CMake
doesn't figure out how to do Java, then CMake will lose in the
Eclipse world.
Not so sure, even if I'm no eclipse expert.
If CMake is able to generate Eclipse project files and/or with
eventual Ant build files then I'm pretty sure CMake will get in the
Eclipse
world very soon.
Java IDE is only a part of what Eclipse is for and I'm not sure
it will be the more prominent one in the mid-term.
Major vendors for embedded (generally cross compiled) tools
goes for eclipse "platform" http://www.linuxdevices.com/news/
NS9149933313.html
because eclipse is a "cool" development platform
(<flame type=free> as soon as you have enough RAM </flame>:))
Java devel. is certainly not the main target for them.
Now that CMake cross-compiling support is emerging I think that
CMake is on a very good path to get into Eclipse world as soon
as CMake would be able to generated eclipse CDT project files.
But some approaches are more likely to get accepted by large numbers
of people than others. Bootstrapping CMake is more cool than using
Ant to take care of what CMake is supposed to take care of. Coolness
inspires.
I'm not sure to get your point but I will elaborate a little more on
Ant vs CMake.
I think you underestimate what Ant
and the wealth of optional tasks are able to do, I suggest you go
to http://ant.apache.org/manual/ and browse tasks.
You'll see that high level ant tasks enables you to do ftp, ssh, scp,
cvs, subversion, rpm building in a easy way.
As far as I know CMake does not have those capabilities.
The differences I see between CMake and Ant is the fact
that CMake is a two-level tool (L1 = generate , L2 = build)
with very limited extensibility (MACRO or EXECUTE_PROCESS)
whereas Ant is a single-level tool with extensive extensibility
possibilities,
i.e. anything a Java program can do may be turned into an Ant task.
That said I LOVE CMake very much, because of this 2 level aspect
from my point of view CMake is missing a powerful extensibility
mechanism.
Before going to CMake (from hand-written Makefile and some Ant
build files)
I was interesting in SCons because SCons offers you python and
not a limited scripting language.
I did go to CMake because CMake was better at GENERATING
build files for several build tools including Visual Studio project
files.
My 2 cents on CMake, Ant, Eclipse and the like.
--
Erk
_______________________________________________
CMake mailing list
CMake@cmake.org
http://www.cmake.org/mailman/listinfo/cmake
_______________________________________________
CMake mailing list
CMake@cmake.org
http://www.cmake.org/mailman/listinfo/cmake
