I use NetBeans for remote C++ development (IDE on Windows, apps run on remote Linux). Overall, I'm a huge fan; NetBeans is easily the best C++ development environment I've ever seen.

However, I have had issues with automatic copying mode, and have ended up developing a quirky development pattern around the problems. I'm wondering if an alternative approach to automatic copying would end up with a faster and more useful system. Right now, I have two problems. The biggest problem is performance: builds are significantly slower when run under NetBeans than if I run them directly on the remote machine. In particular, the link step for my application (involving 50-100 object files) takes 5-10 minutes under NetBeans, vs. 5-10 seconds when run directly on the build/test machine. This is such a big penalty that I have to hack around it: I start the build under NetBeans, then once it reaches the link step I go to a separate ssh window on the build machine and run a script that kills the link step and reruns the make from that window. Even with this hack, builds still take longer than if I ran them purely native (there's a 10-20 second delay at the start of each build). 10-20 seconds may not seem like much, but when you do hundreds of builds a day, those little bits add up.

The second problem I have is that automatic copying doesn't always happen perfectly, and I occasionally end up in situations where some of the files needed on the target machine are not present (actually, they are present, but their contents are all zeroes). Unfortunately, I don't yet have a reproducible test case that makes this happen. Once this happens, it's hard to get the files properly sync-ed again; after trying several approaches, I've decided that the easiest thing is just to manually rsync the entire project tree from the IDE machine to the build/test machine (I've tried the "Upload to ..." menu entries from the IDE, but haven't found that these always do what I need).

My understanding is that the current approach hooks all of the build tools running on the build machine to catch file accesses, and then does the copies on-demand. This is elegant, but I'm wondering if a much simpler (and way less elegant) approach might actually work out better overall. Suppose that the hooking and on-demand copying were eliminated, and instead you just did the following:

* Before running any command on the remote machine for anything, copy over any files that have been changed in the IDE. Really copy the files: no placeholders with zero content, so it wouldn't be necessary to hook the build tools.

* Offer a "sync all" option in the IDE to force a copy of the entire workspace (I've seen something like this in the current IDE, but it doesn't appear to be totally predictable in what it does). People would use this, for example, if they modify files outside the IDE. Perhaps NetBeans could check for modifications to any files in the project workspace and copy those as well, which would make "sync all" almost never needed.

I think this approach would make builds way faster: it would eliminate the slow links, and I suspect it would also reduce the lags at the start of builds. In most cases, very few files are modified, so copying entire files should be fast.

In addition, this would simplify the mechanism in NetBeans, which would probably make it much easier to maintain.

I realize this is a non-trivial suggestion, but I thought I would throw it out there anyway; I'd love to see NetBeans become even more awesome than it already is!