I've noticed an interesting phenomenon.

Many programmers in the C++ and .Net realm absolutely love Visual Studio, and extoll its virtues as an IDE to everyone they meet. Then there are others who are not so impressed.

Now, I personally like Visual Studio a hell of a lot, but not perhaps for the same reason as most bright-eyed newcomers to the programming world. You see, I like Visual Studio because I still remember the really early C compiler days (think Microsoft C) when you had to write your code in something hideous like Edlin or DOS-Edit, then exit, run a batch file that called the compiler, and hope the output didn't cover more than a screen or two so you could spot any serious errors at the top of the list.

(For you spoiled young folks, this was the era where a small mistake would cause the compiler to barf pages and pages of errors for the rest of the code file. If the "missing semicolon" error scrolled off the top of the screen, you're in trouble; you may be left chasing pages of spurious nonsensical non-problems until you finally locate that pesky missing character. Yes, we used to actually write software that way. I cranked out a couple of games like that before giving up and moving to Windows.)

So as far as I'm concerned, compared to the way Things Once Were, Visual Studio is a huge blessing. I've written an addin that collects some handy little tools that I use on a regular basis, and between that and memorizing a few dozen keyboard shortcuts, I can blaze along in Visual Studio being nice and productive. It sure beats the hell out of single-tasking and compiling with batch files. (For some reason - I think it was youthful ignorance - I always preferred batch to makefiles.)


This brings us back to those programmers who don't see Visual Studio in such a positive light. I've heard quite a few remarks about how crappy it is, how poorly featured it is, and so on and so forth.

Now, this naturally makes me very curious. I'm not the sort of guy to use a crappy tool when a better one exists right next door, especially if the better one happens to be free. I may be stuck with VS for work, but at least I can use this mythical Better IDE for my own personal projects, right?

So I inquire as to what this grand tool is that makes Visual Studio seem so horrible in comparison.


Here's the interesting bit: without exception, every single programmer I've ever heard bitch about Visual Studio's quality (in the last 3 years or so that is) is a Java programmer. Some of them are recent newcomers to .Net, especially C#. Some have decided they need to "get more advanced" and try out C++. Either way, a strong Java background is universal among these complainers.

And the better IDE? (Drumroll, please...) It's always a Java IDE. IDEA comes up quite a bit.

This, of course, raises an interesting question: what specific features of this IDE do these Java guys miss in Visual Studio?


I've only ever heard one answer: refactoring tools.



I'm not going to argue. Visual Studio has only mediocre refactoring tools. Resharper is pretty slick, but it's an add-in, not core VS functionality. If you're working with C++, you can pretty much kiss automated refactoring goodbye, because parsing C++ is comparable to stabbing yourself in the brain with a ball-point pen, in terms of enjoyment and sanity.

What's odd is that I have also noticed that extensive reliance on refactoring tools correlates very strongly with shitty programmers.


This is not to say that refactoring is bad, or that if you need to rearrange your code you're a bad programmer. As a matter of fact, a reluctance to clean up code that needs refactoring is also a strong a sign of a bad programmer. However, when you're so caught up in "automated refactoring" that you need to do it all day every day - to the extent that you actually choose your IDE based on its refactoring tools - you're doing something wrong.

It has been my observation that overreliance on refactoring is a crutch. These are the trial-and-error, cargo-cult people who just blindly gibber around in their code until it seems to work. I don't know why, but the Java camp seems to produce an awful lot of these kinds of programmers.


When you can easily rearrange your code in all manner of odd ways, it encourages you to write code without thinking about the actual design. By contrast, when refactoring your codebase is a pain in the ass, you have a huge incentive to design it properly the first time. Moreover, when you're not obsessed with moving little blurbs of code around a half-dozen files, one tends to invest more brain-effort into actually getting working code produced.


Of course I'm sure at this point the agile crowd has already stopped reading and is in the comments section spewing all manner of rage, because easy refactoring is of course essential to agile development, and we all know that agile is the One True Methodology.

Well, two things to that. First, as I'm sure I've revealed from my description of coding in the early 90's, I've been around this field a while. I've seen a lot of One True Metholodogies come and go, and hey guess what, none of them were actually worth all that much. I'm far from convinced that agile is really anything special. Sure, there's some good concepts there, but it's stuff that good programmers have been doing instinctively for decades anyways - and most of that transcends methodology to a large extent. But I'm not here to argue against the agile fad, especially not since it's (thankfully) finally dying down.

Secondly, let me reiterate that I have no issue with refactoring itself. I need to do a fair bit of it on a regular basis, and despite best efforts, things tend to grow beyond the initial design. That's OK. I'm not arguing that we should eliminate automated refactoring because refactoring is itself a problem.

My opinion here is that forcing refactoring to be done by hand encourages us to be much more careful with how we do it. I've seen frivolous and unnecessary refactors cause just as much trouble as poorly factored code; heck, I've made some of those changes before. I think we only stand to benefit from adjusting our habits to think more carefully on the initial design, and to think extra carefully before making huge, sweeping changes.



So there you have it. I have now concluded that anyone who complains about Visual Studio (at least on the grounds that it has worse refactoring features than their Java tool of choice) can be safely flagged as a less-than-optimal-quality programmer.