Mostly just to avoid the unnecessary recompilations, I guess. The "make" way of doing things is to rationally manage a build so things don't get recompiled unless they actually need to be, after all. So a little bit of a speed of build benefit, and probably a bit more satisfaction that things are being done "properly", if you will.
Did you realize Arduino 1.0.1 does this? Seriously, it does. I know....
I developed the code, originally in November 2010, as part of a patch on issue 393. It was resubmitted 1 year later as issue 638.http://code.google.com/p/arduino/issues/detail?id=638
Last December it was committed into Arduino's github repository, and eventually released as part of Arduino 1.0.1.
I'm sure that does nothing to sway you to prefer the IDE over vim & a makefile... but when talking about ways command-line based make is superior to the Arduino IDE, avoiding recompiling files based on timestamps and dependency analysis has been part of Teensyduino for 1.5 years and now, as of 1.0.1, is officially a feature of the Arduino IDE.
I'll agree that the update to the IDE improves the Arduino build process,
But the IDE even with this improvement still doesn't completely avoid doing unnecessary things or do what can be done with Makefiles.
Yes the update can prevent rebuilding of certain files for a given sketch under certain circumstances,
but since the IDE doesn't build core or Arduino library archives and store them independently of IDE sketch build area,
the IDE must rebuild library archives when say changing board types or restarting the IDE.
Because of the build methodology, the IDE also doesn't (can't) remember the compiled objects across instances of the IDE
even for the same sketch.
i.e. bring up IDE, build a sketch, exit IDE, bring up IDE for the same sketch - EVERYTHING rebuilds.
Even in the cases where the IDE is smart enough to not to re-compile core objects, it still
re-archives them into a local core library.
Overall, it is a build methodology problem. The IDE falls down in certain advanced capabilities because of
the methodology used and it is very difficult if not impossible to push the IDE to be "smarter" do things
differently without having to actually modify the IDE JAVA code.
With makefiles it is possible to do things in a more traditional way like
create 1 core library and 1 set of true libraries for each board type
and with proper dependencies never have to rebuild them again no matter what sketch uses them
or across sketch builds unless there is a change to the actual library code.
Consider an IDE like Atmel's AVR studio. It's build methodology was to use build on top of Makefiles so
that it can do things like allow you to override everything and use your own makefiles.
What annoys me the most about the IDE is that while it works quite well for certain work flows
and for novices, some of its implementation decisions - most of which would not have affected novices work flow
or impact their ease of use, get in the way of or even prevent doing certain more advanced things.
An Arduino library being able to call another Arduino library is very problematic with the current IDE build methodology.
Yeah, there is a hack to allow it to work today, but it involves adding header files to the actual user sketch - which is a
kludge since the sketch really doesn't care about such sub library dependencies.
Another, being able to source level debug using other Atmel tools.
Those types of problems can go away if a slightly different build methodology were used.
So for me, the building/re-building of modules unnecessarily isn't my biggest concern, what concerns me more is that
certain things like conditional compilation, (sketch being able to control compilation options of libraries), libraries being
able to call other libraries, library code being able to detect and conditionally change based on board type
(not processor type, or having to poke around for "magic" defines), being able to source level debug are the killers.
Heck even the ARDUINO define for the core code revision is not available in a header file as the build methodology
assumed things were only going to be built with the IDE.
It would be nice if the IDE developers would at least consider the ability to build makefiles around their core libraries
for the more advanced uses that want to use Makefiles so that they can do things like source level debugging
as some of the way they are doing things make it more difficult for building Arduino sketches with Makefiles.