VS provides the ability to do all of those things. You can both extend the IDE and create DSLs. And .NET runs on a VM, so it's write-once, run-everywhere (unless you're trying to port to Mono/Linux, but that's not what .NET is designed for). It also has the absolute best debugging toolkit of any IDE, ever.
Make files are for the people deep down in the guts of systems, writing bare-metal code. This isn't 1990, we don't to force ourselves to use these antiquated tools for all sides of development.
The idea that you need to "understand your build system" is particularly ridiculous. I understand that my code compiles, has no warnings from VS, passes all my test cases, and works fine in beta testing. Why do I need to write a make file to do what VS is smart enough to do automatically?
As for this not being 1990 (or 1980, BTW), I agree. One should not use antiquated tools to do a job, but I find your willingness not to understand what you are doing quite amusing. If I cared, I would find it distressing, but, since I don't, I will leave it as it is.
Being condescending and rude isn't moving your point along any. In fact, I still don't know what you point is. You appear to think makefiles are inherently superior to VS solution/project files, but for no obvious reasons. The only reason you give seems to be that VS users don't understand their build system, whatever that means.
With that said, I know people who the old VC project system inside and out. And I know tons of people who know MSBuild as well as the most build engineers I know in the Unix world know make.
Makefiles are an artifact of a particular build system. It is not foundational to all build systems. Understanding Makefiles is useful for the world in which you use make, but I fail to see why it would be useful in a world where they don't use make.
It holds, within its structure, information enough for VS to build its targets. Who cares if it's not called "Makefile" and you don't invoke it with "make"?
The reference to makefiles is that, if most VS users did understand what goes on after they invoke "Build", they would be able to write a makefile. Since so few of them do, few of them could, conceivably, write one.
Or tell, exactly, what happens when they hit... What was it? F9?
And I think most developers do understand what happens in their build files. Especially since most of them are now msbuild files. We actually handcraft our own, because of the way we have our integration server set up. It's not rocket science, but its not a makefile either. But yes, it does capture dependency information.
Either you just know really poor devs, or you know a lot less than you think you do about what people know in this space.
I agree with this. But what has that got to do with Visual Studio and makefiles?
Is your point that Visual Studio is hard to use, somehow? I've created quite complex build systems using Visual Studio and scripting. I'll admit I've had rough patches where it's been hard to figure out where a setting might be, or where I forget to set things consistently (e.g. library inclusion across build targets), but it's pretty full-featured and reasonably easy to grasp. It strikes me as consistent, once you learn the basics.
Perhaps your point is that makefiles are easier to review "at a glance"? I don't really agree with that, since it depends entirely on one's competency with makefiles versus Visual Studio project/solution configuration.
I could be missing something entirely, though, so I welcome any additional take on it.
The point is that what appears to be an easy approach to project build management is, in fact, a loaded shotgun aimed at your feet.
Oh wait, no it wouldn't.
And the C# build process is very simple. It should be easy to understand.
Okay, your premise seems to be:
1) Understanding your build process means you can write a makefile for it.
This is only true if you know how to write a makefile. i.e. makefile syntax and the specifics of your toolchain.
2) Conversely, if you can't write a makefile, you don't understand your build process.
This is false, because I can't write a makefile since I don't know makefile syntax. I most assuredly do understand my build process, though.
Correct me if I've misunderstood you.
It does not follow that if you don't know how to write a makefile for your toolchain the necessarily you don't understand your build process. But, if you can't write it after you understand its syntax, then you are pretty much doomed.
Of you don't understand your build system, you really don't know what you are shippin.