views:

932

answers:

8

I've been using make and makefiles for many many years, and although the concept is sound, the implementation has something to be desired.

Has anyone found any good alternatives to make that don't overcomplicate the problem?

A: 

Ruby's make system is called rake: http://rake.rubyforge.org/

Looks quite promising.

There's always Ant: http://ant.apache.org, which I personally find horrendous. It's the de-facto standard for Java development, however.

davetron5000
+6  A: 

check out SCons. For example Doom 3 and Blender make uses of it.

WaldWolf
+3  A: 

I recommend using Rake. It's the easiest tool I've found.

Other good tools I've used, though, if Ruby's not your thing, are:

  • AAP (Python)
  • SCons (Python)
  • Ant (Java, config in XML, pretty complex)
Clinton R. Nixon
+1  A: 

It sort of depends on what you're trying to do. If all you want is make-style target dependencies and command invocation, then Make is actually one of the better tools for the task. :-) Rake is very nice, but can be clumsy for some simple cases. Ant is of course verbosity city, but it has better support for building Java-like languages (Scala and Groovy included). Also, Ant is available everywhere. That's the main reason I use it. Because it works consistently on Windows, it's actually even more cross-platform than Make.

If you want dependency management for Java-like libraries, Maven is the canonical choice, but I personally like Buildr a lot better. It's faster and much easier to customize (it's based on Rake). Unfortunately, it isn't quite as ubiquitous as Maven just yet.

Daniel Spiewak
+5  A: 

I have a lot of friends who swear by CMake for cross-platform development:

http://www.cmake.org/

It's the build system used for VTK (among other things), which is a C++ library with cross-platform Python, Tcl, and Java bindings. I think it's probably the least complicated thing you'll find with that many capabilities.

You could always try the standard autotools. Automake files are pretty easy to put together if you're only running on Unix and if you stick to C/C++. Integration is more complicated, and autotools is far from the simplest system ever.

tgamblin
+4  A: 

Some of the GNOME projects have been migrating to waf.

It's Python-based, like Scons, but also standalone -- so rather than require other developers to have your favorite build tool installed, you just copy the standalone build script into your project.

Eric Talevich
+1  A: 

I'm not sure if you are asking the correct question here.

Are you after a simplified make? In which case, you need to get someone who is very familiar with make to create a series of (M|m)akefiles that will simplify your problem.

Or are you wanting to look at the underlying technology? Are we wanting to enforce a design-by-contract type architecture which is built in to, and enforced in, the code design? Or possibly, the language itself, e.g. Ada and its concept of specs (interfaces) and bodies (implementations)?

Which direction you are after will definitely affect the potential results of such a question?

Basically, new ways of building systems from only those components that have really changed versus adoption of new technologies that have such mechanisms built in by design.

Sorry it's not a direct answer. Just wanted to try and get you to evaluate which path you wanted to head down.

cheers,

Rob

Rob Wells
+1  A: 

I still prefer make after having considered a bunch of the alternatives. When you auto-generated dependencies either via the compiler or something like fastdep there is not much left to do. In particular I do not want my build script to be tied to the implementation language, and I do like writing stuff in XML when more readable alternatives are available. A tool that expose a general purpose language has merit though, but yet another interpreted language does not (afaik). What is Wrong with Make? might appeal to your point of view about moving away from make.

/Allan

Allan Wind