For a long time, the only IDE I knew was the VB6 IDE, which is fairly outdated (ca. 1998) and not very feature-rich (unless you purchase third-party add-ons). You can set breakpoints and watches and there are other (now common-place) amenities, such as Intellisense.

So, when I saw Eclipse for the first time, I was amazed at how much the IDE could do for you (Generate Getters and Setters, the quick-fix feature, the Refactoring menu, etc.). Same thing when we moved to Visual Studio and I saw all the auto-generated Form Designer code for the first time.

These extras are great for productivity and just plain Getting Things Done, but I have to wonder, are we becoming too reliant on IDE's? How many programmers actually understand the rationale for the refactoring suggestions their IDE's give them? Do they need to understand why the IDE is suggesting they make a particular change to the code they just wrote?

I just wonder, especially as more and more productivity features get crammed into IDE's, how much thinking future programmers will actually be doing if the IDE starts shielding them from having to actually think things through before they code, instead of using the IDE as a crutch (i.e. "I can write crap code, because the IDE will refactor it for me").

Sometimes I find it very liberating to just fire up a text editor and code in that for awhile, to prove to myself that I still actually know the language I'm coding in.

What are your thoughts on this? Are super-friendly IDE's jammed-packed with productivity features ultimately harming programmers by hiding too many details of the language and shielding them from making real design decisions?


No. We're not. People can and do write crap code with and without an IDE. And I'd say that IDEs help me catch more of my crap code than they help me create it.


Back when I was a young programmer, I wore an onion on my belt because that was the style at the time and text editors??? LUUUUXXXXXURY. We were lucky to be allowed to sleep in the attic. Of course we called it an attic but really it was just an old prickly pine tree that we used to have to set fire to every night in order to stay warm. And then in morning, our dad used to beat us to death with a pile of old Emacs lisp macros and send us off to work 43 hours a day a mill for tuppence a month. Of course, you tell that to the kids these days and they wouldn't believe you.


That's rather a loaded question. I mean, "are we becoming dependent on our IDE's?" is very different to the question of "are we becoming TOO dependent on our IDE's?"

I'd say that there is some dependency on IDEs and that there has to be for productivity to meet what is expected of us. Tools are there to make our lives easier and there is little kudos or monetary value in knowing how to do things without the IDE. It might make us feel good that we know, but no one will thank us for letting them know that.

Becoming TOO dependent implies there's a point at which it is detrimental. That there is a level of dependency that is too much. I don't see how that could be unless the makers of the IDEs just stopped and withdrew them. But why would they? The only time I've experienced a side-effect of IDE dependency was moving from C# back to C++ development, but that was more because C++ IDEs haven't entirely caught up on all the features and it took mere seconds to get back into it.

The IDE is the next step in a long line of abstractions away from just writing 1s and 0s. From binary to assembly to C to C++ to python etc etc. If you're fine with using C++ or C#, then it would be somewhat hypocritical to believe that others shouldn't use the newly available abstractions whether they be new languages or new development environments.

So, I'd say, the answer is no. The only way you'd be seen as too dependent is by those who see merit in knowing how to do it without an IDE over just getting the job done.


Are carpenters too dependent on their hammers and saws? Would they be wrong to use the best hammer or saw possible?


I would say that this is true in some respects. Good programmers probably won't be harmed that much. However there are a lot of bad developers who can get by, simply by letting the IDE do all the work. With VS.Net, you could probably write an entire application without typing a line of code. Just draw out your interface, add some controls, connect some data sources, and you are done. It wouldn't be a very complex or good application, but it would probably work. I think that this is ultimately dangerous, especially when it comes to work actually being done for hire. You can get a lot of work done, without having any idea what you are doing. You don't know if there are any problems with the code, how it will perform under load, or how to fix it if something goes wrong.

Ultimately, the bad part, is that this leads to the idea from managers, and others, that code can be written by non-programmers, if you just give them a good enough tool set. I've worked in situations like this, and have to say that it never turns out good. Eventually these non-programmers run up against something that the IDE can't do for them, and they waste weeks trying to do something that a good developer could have done in a day. And the good developers end up supporting and maintaining the code written by the non-programmers.


Here's the clincher for me.

"Java may be better than VB, but the Visual Studio IDE makes me so productive that the differences don't matter."

[Whether Java is actually better doesn't matter. The point was that they agreed that Java was better but refused to consider making changes, based entirely on the IDE.]

Their claim was that the IDE can make up for shortcomings with the language and environment.

From my POV, code lives a long time, but IDE's are fashion accessory and change every season. Apparently, the accessory defines the value, not the language, run-time, libraries or framework.

I don't agree with this POV. But it tells me that some people can be so wed to the IDE that long-term value of the code, environment, framework, etc., don't matter. And that's got to be a bad thing.


I wouldn't say so. I know a few developers who couldn't write "Hello, World!" without their favorite IDE, but I think the vast majority use it as a productivity tool, not as a crutch.


Judging from just StackOverflow, I'll say this: Hell yes.

For example, in the questions about C#'s 'var' usage, the dissenters bring up the fact that something along the lines of:

var something = DoStuff();

"That's not very readable, how do you know what 'something' is? Sure, the compiler knows, but how do YOU know?"

Then the pro-IDE people reply, "just hover over it in the IDE." That's just stupid.


Hell no. IDEs are jampacked full of features like Intellisense which means that I don't need to remember precisely what a function name is called, and can focus on the logic of my code instead. Jump to definition, find all references, and such like are all invaluable for me.

A good programmer can write good code in a text editor or in an IDE. It's just easier in the IDE. A bad programmer can write bad code in a text editor or in an IDE. They'll just write bad code faster in the IDE.


Having an IDE doesn't significantly affect whether the code produced is "Crap" or not. Personally, I don't use an IDE, but programmers I work with do. It's sheerly a matter of preference and a matter of which tools we're used to.

If you can write good code with an IDE, you can do the same without, it just might take you time to become accustomed to using a set of CLI tools. And vice-versa.

On the other hand, you can write crappy, functional code without an IDE, the kind that if you're never reviewed, it will not fail until the worst possible time. And having an IDE will not magically make that problem go away.

It's not the tools themselves, but knowing how to put your tools to proper use that makes all the difference.


If an IDE can cut down on human errors and help productivity then that is great.


Do you feel the same way about high-level languages targeted at managed, garbage-collecting runtimes? As opposed to, say, assembly?


Charles Petzold (well known Windows programming author) gave a very interesting speech on this topic a few years back called Does Visual Studio Rot The Mind? Personally I favor IDEs for many of the reasons mentioned in this thread, but his talk is good food for thought.


Let's put it this way: in many languages there is a very high amount of what could be called accidental complexity—areas where the language is getting in the way of expressing the "business logic"/solving the problem at hand—and this is one areas where IDEs should be considered useful.

If an IDE is automatically generating code for you, then consider it an abstraction layer and welcome it. Of course, a la Joel, all abstractions are leaky, and one would be well off to know where their tools fail.

As far as a teaching tool, I was an intern this summer learning .NET/C# and 30-day trial of ReSharper taught me a whole bunch. Of course, as Dare Obansajo pointed out, we shouldn't blindly rely on ReSharper's suggestions, but as far as teaching me some constructs and keywords which lasted after my trial was over, ReSharper did very well.


It is your choice wether you know what is going under the hood of IDE or you don't care.

Ignorant people are dependent, IDE is their master.

People who have know-how use IDE as tool.


IDE's make things easier, some things IDE's do for you, could take 10 times longer for you to do by your self. In my opinion, IDE's really don't stop you from learning what you need to learn it just makes it easier for you to learn. The features they provide will prove useful during the learning experience and after the learning experience. IDEs for the win!


I don't see why an IDE would be different from LaTeX: It lets you focus on the content of what you're writing while automating some details for you, but you can still write horrible crap.


I believe that it is important to at least have a general understanding of whats going on at the lower level. However I agree with others in that modern IDEs are simply the the next step in the evolution of software development. A bad programmer will be a bad programmer with or without and IDE.


Every time you see your IDE doing something for you, automatically - blame the language. If there's a robot (eclipse) who can perform manual tasks to save you the burden of typing - the language is at fault, as this job should be done by compiler.

(yes, it's relevant only for a part of eclipse automations, but still a big part).


I wouldnt call a builder who uses his hammer all day long over dependent on the hammer... more like he is using his tool to leverage his efforts.


No not at all. IDE's are allowing us to write faster code than efficient one. The IDE's are just for telling that there are other things related to it, exactly same as facebook is telling you where are your friends and what are they doing. Market values for algorithm and creative ideas rather than static information tool.


A lot can be learned by trying to program without one, but I think it is best to take those lessons back to the IDE with you. For example, when learning to type, once you have all the keys down, you can use a keyboard with all the letters rubbed off which forces yourself not to look and can lead to much greater speeds, getting you past a plateau. But I no longer use a keyboard with the letters rubbed off and I'm still pretty fast. In this same way, You can ultimately treat an IDE just like a text editor if you don't use any of the features, so it really can't be any worse as long as you make sure there is nothing you are relying on (equivalent to looking at your hands) that is making you less effective.


For me the features in IDEs that hamper your understanding of a language or framework are those dealing with code generation (project templates, automatic dependency checking, etc). Beyond that I find that a good IDE is worth its weight in memory and load time just because it is much more efficient than a text editor and a straight command line debugger.

The wealth of code editing productivity tools (like function name completion, integrated documentation, etc), refactoring support, and excellent debugging tools in most modern debuggers make them a valuable tool that I sorely miss whenever I am forced to use a text editor and gdb at the command line.


What I would say is that if you can't imagine not having your IDE to write code, then you have become an addict. There is a great article in the Salon archive that I recommend for every one.The Dumbing Down of Programming

Check it out and then come back to the thread.


I'll just say that having a good set of tools cuts down on a lot of frustration.


Here's one example of IDE dependence: Eclipse will automatically resolve imports using Ctrl-O. NetBeans doesn't have this feature, and even though I know what package contains System.out.println, I can never adopt NetBeans without Resolve Imports.

Refactoring, though, still requires higher-level knowledge. The mechanics are simply made easier by the IDE (which I find to be a good thing). Knowing how and when to apply refactoring still requires a smart programmer.


After some 13 years of using variolus IDEs I have come to the conclusion they actually hurt my productivity. Now I am not using them at all on any platform.


Bad developers produce bad code regardless of how easy it is to do so. Good developers just get to do their job quicker and more effectively with good tools.


IDE completely influence the modern style of programming. Without auto generating getter setters, accessors for instance variables would be a theoretical ideal, which all practical programmers ignored, preferring raw public access to the variables. Without autocompletion we'd still write all our variables and method names in SMS style txt (like C's strcpy).

IDE's are really compilers which transform the terse language of our keystrokes into the more verbose and more readable programs that we have to maintain.


Programmers are expected to produce more and the new IDEs allow us do that. Eventually, programmers will be removed from the equation. Instead, systems will be generated from requirements documents and we'll all be out of a job.

I love intellisense...