A GUI Makefile manager

Pretty much every IDE does the moral equivalent. Many will even specifically generate makefiles from their project files.

Pretty much every IDE does the moral equivalent. Many will even specifically generate makefiles from their project files.

What I was thinking of was a standalone application - perhaps someone uses a strange text editor that does just that: edits text. If someone needed to build a large application with their favorite text editor, they would be at a loss.

How I imagine it is that someone could use this tool regardless of what else they were using, so that the efficiency of an IDE compiler is not attached to a separate utility.

In general I have found implementing a GUI to do more complex tasks gets extremely complicated. Both in terms of implementing it in the first place and having people use it because the usage will definitely not be very intuitive.

Before you sink a lot of time into such an idea, you might want to investigate tools like CMake. Not only do they generate all your makefiles (allowing vast and difficult changes with a bit of planning), they also generate project files for other IDEs (for example MSVC solutions/projects).

Such a functionality is helpful, but seeing that people who would use such a program would probably already use an IDE which include the same functionality (though with their own incompatible project file format) there is only a fraction of people who would use it.

Then there is the problem of parsing externally modified makefiles, if they are slightly different then those produced by your click-together-GUI. That would make everyone need to download/install your program if they want to work with someone else who uses it.

I think thats why there are many incompatible types of meta makefiles/project files which are sometimes not much easier to edit, which can sometimes get converted to standard makefiles. Switching all together to an easier makefile format would maybe help, for example if everyone was suddenly using rake, but any new make program does not get enough people for the network effect to kick in and completely replace old make.

http://en.wikipedia.org/wiki/List_of_build_automation_software

That would make everyone need to download/install your program if they want to work with someone else who uses it.

The program would use the first makefile (supposedly the master makefile) as its base. It would also follow the specifications for a makefile, so anyone who used the GUI could still edit it from a text editor.

you might want to investigate tools like CMake

That is near what I'm thinking of, except that you need cmake to use it's files.

Pretty much every IDE does the moral equivalent. Many will even specifically generate makefiles from their project files.

What I was thinking of was a standalone application - perhaps someone uses a strange text editor that does just that: edits text. If someone needed to build a large application with their favorite text editor, they would be at a loss.

How I imagine it is that someone could use this tool regardless of what else they were using, so that the efficiency of an IDE compiler is not attached to a separate utility.

It's called cmake :p

Managing project files is a bitch. You really want to use a meta-utility to handle the generation of project files for .

The program would use the first makefile (supposedly the master makefile) as its base. It would also follow the specifications for a makefile, so anyone who used the GUI could still edit it from a text editor.

So basically, make then? That's effectively what the ndk-build/android.mk wrappers around make do with the android NDK (which are implemented entirely in make)

you might want to investigate tools like CMake

That is near what I'm thinking of, except that you need cmake to use it's files.

So your application would work without the application? I think I might be seeing a small flaw in your plan ;)

So your application would work without the application?

As in that, I meant you could run 'make' and build your application without needing to use my application.

I think you're underestimating the complexity of what can be in a makefile. If you allow a user to hand-edit the generated makefile (or to have created the original input), then all bets are off. Depending on which version of make you're supporting, the language is turing complete. and lets you do pretty much anything. Creating a GUI that can parse/understand/edit/maintain that is not a trivial task. It's not even a difficult task - it's insane.

I think you're underestimating the complexity of what can be in a makefile. If you allow a user to hand-edit the generated makefile (or to have created the original input), then all bets are off. Depending on which version of make you're supporting, the language is turing complete. and lets you do pretty much anything. Creating a GUI that can parse/understand/edit/maintain that is not a trivial task. It's not even a difficult task - it's insane.

It would be insane to actually maintain the whole file. General parts of it though, like rules or commands could be taken as 'Name:Value' or input fields in the GUI. Adding files or dependencies would be mostly GUI, allowing you to select files or directories.

I think a GUI makefile is very hard to read through.