I find myself using my text editor of choice (vim, nano, gedit, pick your poison) much more often than any IDE as of late.

After noticing my ide shortcuts getting dusty I started to think about this and wonder: what justifies use of an IDE for you opposed to a text editor?

For that matter what rationale would you have for not using an IDE and merely relying on an editor?

  • possible duplicate of programmers.stackexchange.com/questions/1003/…? Nov 23, 2010 at 19:51
  • what do you actually do in your editors?
    – user1249
    Nov 23, 2010 at 20:03
  • Write code, develop applications,... pretty much everything as of lately.
    – Chris
    Nov 23, 2010 at 21:51
  • 15
    Personally, I find IDE's a lot more useful when reading other people's code (especially large projects) than when writing my own code. IDE's let you navigate through the source more easily, making it easier to quickly understand other people's source code. Nov 23, 2010 at 22:46
  • 3
    I would like to turn the question around. What justifies NOT using an IDE.
    – Nailer
    Nov 24, 2010 at 15:10

16 Answers 16


The I: integration. A good text editor may be nice for writing code, but most of your programming isn't spent writing; it's spent testing and debugging, and for that you want your text editor to integrate with your compiler and your debugger. That's the greatest strength of an IDE.

  • If only I could find one that didn't get in my way :)
    – user131
    Nov 24, 2010 at 6:16
  • 5
    I've just come to accept sub-par editing as the price I pay for the convenience of integration.
    – TMN
    Nov 24, 2010 at 15:55
  • Isn't testing programming if you do it right? If you spend most of your time debugging and monkey testing, then I think I see where your problem is. Mar 2, 2011 at 11:07
  • 8
    @Tom, Testing is programming when you can automate tests you do all the time. Otherwise, verify by whatever method yields the greatest quality. Mar 2, 2011 at 11:31

These are my favorite features of my favorite IDE, IntelliJ, which I like using for Java, PHP, Javascript, HTML, even ActionScript.

  • Error checking - Like live spell check for code. Absolutely essential.
  • Code navigation - Ctrl+click on a function, variable, type to go to the definition. (IntelliJ is very good at this in all of the above languages)
  • Code completion - I use Ctrl+space constantly to help fill in the class or method name that I need. This speeds up coding a ton, and even helps catch bugs before they happen when something you needed is not accessible from the context you are in. IntelliJ will even help you expand acronyms - type NPE, hit Ctrl+space, and it will show "NullPointerException", "NoPageError", etc. Hitting Alt+enter to automatically add the import is really nice too.
  • Code generation - Generate getters and setters, implement methods from an interface with a couple clicks.
  • Very good code coloring - IntelliJ not only does the standard keyword, string, variable name coloring, but also colors member variables, local variables, parameters. In ActionScript a variable that is actually a setter/getter will be colored like a function.
  • Refactoring - Mistake-free renaming is the biggest. IntelliJ is very good at renaming even setters and getters or string usages. Of course there is regex-based search and replace when you need it, and a "preserve case" option to enable you to replace "myNumber", "MyNumber" and "MYNUMBER" with "myString", "MyString" and "MYSTRING" in one operation
  • Version control integration - We use SVN, and my favorite IDE VC features are being able to create, delete, move classes without thinking about SVN, easily browsing history, a very good diff tool, good merging capability, and annotating files (showing line-by-line history) in the editor.
  • Dependency importing - When relying on a third party library that you have the source for, you can navigate to the code easily for reference, debugging, etc.
  • Smart typing - pasting code and having it automatically paste to the right tab position, auto completion of end-brackets, parentheses, quotes, etc.
  • A very good Test runner for JUnit, FlexUnit, PHPUnit
  • Debugging - of course. Debugs JBoss, Jetty, even Flash flawlessly. Ctrl+click stack traces to go right to the code.

Things like the code coloring you might take for granted, but good code coloring is like peripheral vision - it allows you to focus on the important stuff without taking that split-second extra to identify the full word.

IntelliJ also even uses Ctrl+space to suggest variable names. In Java, if you declare a new EventMessageItem variable and hit Ctrl+space, it will suggest "eventMessageItem", "eventMessage", "item", etc.

All of these things give me way more time to think about my code and architecture, and think less about fixing formatting, dealing with the file system, fixing copy-and-paste errors, switching between applications, chasing down documentation, etc. etc. I don't know how you can say no to that kind of productivity increase.

  • 4
    + 1 for mention IntelliJ Idea - I just love it
    – artjom
    Nov 24, 2010 at 8:01
  • 3
    +1, most of the points here apply to any decent IDE, or should :)
    – Matthieu
    Nov 24, 2010 at 20:50

IDE's understand your code much better than an editor. This allows for instance for identifier completion and refactoring, which for verbose languages like Java is a God-send,

  • 1
    Note that all this understanding requires memory to store. Hence IDE's tend to be pretty resource hungry as compared to a "fit-on-a-floppy" editor.
    – user1249
    Nov 23, 2010 at 21:47
  • 19
    Yeah, but my 8Gb i7 dev machine needs to do something while I'm typing away. :D Nov 24, 2010 at 0:34
  • IDEs don't have to be resource hungry. But Smalltalk's probably an edge case: reflection's easy, very simple syntax, and so on. Nov 24, 2010 at 12:09
  • @Frank, depends on what you want them to do and how easy that is.
    – user1249
    May 13, 2011 at 9:44
[To the IDE] You had me at intellisense/autocomplete
  • 1
    +1 Even though it's always disconcerting to realize I never type a full class, method, or property name anymore, and know exactly how many keystrokes it take to single-out the correct autocomplete option... tic-tic-tic-TAB-dot-tic-tic-tic-TAB-dot-tic-tic-tic
    – grossvogel
    Nov 24, 2010 at 1:10
  • 6
    @gross, but it is right! Manually typing frequently implies typing errors.
    – user1249
    Nov 24, 2010 at 8:16
  • @TThorbjørnRavnAndersen Unless you have two similarly named things, and accidentally don't type enough characters to get the right one. I accidentally inserted a "NumberOfPoints" property in a few areas that needed "NumberOfSegments" due to not paying close enough attention to my autocompletion :p. That being said, I'd rather have autocomplete than not.
    – KChaloux
    Aug 31, 2012 at 18:59

Productivity. Is there any other justification that makes sense? For me, a well-designed IDE that centralizes a lot of the functions that I perform while programming -- creating and editing code, using source control, debugging, interacting with project management tools, communicating with other programmers, creating documentation, running automated tests -- dramatically reduces the process friction that reduces my productivity.

Additionally, even though I feel as though I need to know how to use each tool individually, I don't want to have to. For me at least, a right-mouse-click is infinitely preferable to opening a CLI and typing.

I have used many, but the IDEs that I return to over-and-over are Visual Studio, Wing IDE and NetBeans. All add significant value to the time that I spend programming.


Historically, IDEs provided unmatched convenience on a single-tasking computer. My first C compiler required the following steps in the edit-compile-run cycle:

  • Start editor
  • Edit program
  • Save program, quit editor
  • Compile program
  • Assemble compiled program
  • Link compiled and assembled program
  • Run program

on my CP/M system. (I could have automated much of that as a batch program had my disk drives been larger.)

When I got Turbo Pascal, I was delighted to be able to keep the editor available while compiling and debugging.

That, I believe, is what made IDEs popular in the first place.

  • But all of those things can be done from a lot of editors; Emacs, for example.
    – JasonFruit
    Jan 25, 2011 at 22:16
  • @JasonFruit: Certainly. I'm explaining what first attracted me to them. In those days, I was running CP/M on a TRS-80 Mod 4, and I believe Emacs was still TECO-based then. Jan 25, 2011 at 22:38
  • Okay, point. :-) (Emoticon to fill out the requisite number of characters.)
    – JasonFruit
    Jan 26, 2011 at 1:21
  • 2
    @JasonFruit, CP/M-80 machines had a maximum of 64 Kb RAM. Consider how much Emacs you can fit into that.
    – user1249
    May 13, 2011 at 9:43

If you code in Lisp, Emacs has Intellisense-like capabilities like looking up method parameters and autocompletion, so you could say it's the original IDE. It's also nice to be able to use one program for multiple tasks (editing in general, shell/command prompt, reading news).

In general, the editor vs. IDE question seems to depend on the programming language. From what I've seen, Ruby and Haskell coders, for example, seem to prefer their favorite text editor.

  • Emacs really can do that in almost any language. The PHP mode is quite good, are the modes for Javascript, Haskell, Erlang and SQL. (The others may be good too, but I haven't used them).
    – Zachary K
    May 13, 2011 at 9:38
  • Once you add all those bells and whistles to emacs (or any editor for that matter) what you have is an IDE. Integrated-Development-Environment. I compare it to buying a cake from a bakery (IDE) versus making it from scratch (Tricked out editor)
    – sal
    May 24, 2011 at 19:00
  • +1, For Coq, Haskell, and Lisp Emacs is the only thing with any decent support Aug 31, 2013 at 13:13
  • One-click compilation
  • Debugging
  • Code templates
  • Code completion
  • Integration with version control and refactoring tools
  • Simpler unit testing

to name a few


I think the answer will depend a lot on which programming language you are using and how good you are at it. For languages like JAVA an IDE is must if you are doing anything serious. Wherever as when it comes to scripting languages like JS or Ruby IDES are not of much use.

I use notepad++ and a set of shell scripts (for backups, git commits) for my development and it works perfectly fine.

  • I use GVIM for Javascript and find that it is MUCH faster then using an IDE. It also uses a lot less memory. Add in about 3-4 shell scripts for things like jsLint, formatting, and controlling selenium and I find that I almost never need to take my hand off the keyboard. (And to be honest I probably could turn all those scripts into VIM plugins if I cared)
    – Zachary K
    May 13, 2011 at 9:40

Some arguments in favour of "editors":

  1. There are cases where an IDE has not yet been developed or will never be.
  2. With an editor you can make changes "faster" and more surgically.
  3. It needs far less resources (so easier to use many open at the same time)
  4. Because it is the only way to do solve some issues like those described here.
  5. (personal) Sometimes when I have to type everything, I am working more using my concious and am more engaged on what I am typing. Many times I found for example a spelling error in a method (formaqString), which would have gone unnoticed using an IDE.
  6. It makes it easier to work only with using the keyboard (speed/flow)
  7. Mentality of using macros or other time savers.

I use an IDE every day to work, it is difficult to write Java/C# otherwise.

(2) compared with (3): Basically only option to edit files remotely (over ssh / remote desktop) and do minimal changes to a distant server's configuration or files.


Depending of course on your language, some IDE's also include visual Form/Window designers.

Though it should be pointed out, the line between a programmer's text editor and an IDE is not a well defined one. Many editors can be extended to handle compiling, code completion, debugging, etc.


I use the IDE for testing / debugging / integration and KEDIT for editing because the IDE is seriously deficient in editing capabilities.
Because the .NET IDE recognizes external edits, all I need to do is save in the editor and accept the prompt to reload the source. This allows me to optimize my editing and debugging capabilities at the same time.
For other IDE's I use KEDIT as a template processor and source search program and copy / paste that source into the IDE.

  • What do you do in kedit that the IDE can't do? I'm genuinely curious, having never really used anything but an IDE for most of my serious coding... Nov 24, 2010 at 3:47
  • KEDIT, like other smart editors, has scripting capabilities which allow me to do things that the IDE can't. For instance, I use KEDIT to do multiple buffer (up to 100 per kedit session) copy and paste and column editing that the IDE can't even get close to.
    – Dave
    Nov 29, 2010 at 17:51

For IDE:
--advanced features are wired-up out of the box.
--some features are so specific for your framework that editors have no equivalent.

For editor:
--Keeping your hands on the keyboard.
--your dev environment is the same across all systems
--better scripting for your editor
--some features of an IDE are available with external tools or scripts. (intellisense, goto definition, find references)


Short learning curve. Thats it.

  • 4
    I guess you have not maxed out any kind of IDE Nov 24, 2010 at 0:47
  • 4
    With vim as my co-pilot, I need not to.
    – nate c
    Nov 24, 2010 at 0:52
  • 1
    Short learning curve for.... ? pardon but this was not obvious to me.
    – Chris
    Nov 24, 2010 at 16:08

The only one I'd really recommend is the debugger. An IDE is really an editor with a load of other gubbins added on, but if you can compile by typing make (or up arrow + enter) in a command prompt, then you don't need an IDE. If you can commit to SCM by right clicking in explorer and choosing the right menu item, you don't need an IDE.

Now I know some people need stuff like refactoring support (write your code right the first time :) ) or some integrated GUI designer (but even then, using Visual Studio I use Expression to do my GUI work, not the crappy XAML support in VS), and many people need intellisense and autocomplete (especially for verbose languages like Java and C# that have godallmightlylong names).

But for me, the GUI debugger is the only really good reason to use the IDE. I still use a 'command-line' debugger (well, windbg) but for day-to-day, its the builtin one to VS.


There are benefits to an IDE. Not all languages have a comprehensive IDE to really tip the scales or it could be prohibitively hard to create one for a said language. Reasons why would would want an IDE? Well lets start with these:

  • The language has a rich standard API that in IDE popups could help speed development.
  • There is a lot of boiler-plate code. (Forced try/catch, getters/setters, etc)
  • Autocomplete can accurately meet your coding needs
  • Your language unit testing suite is integrated into said IDE.
  • IDE is aware and supports numerous language common libraries regarding best practices.
  • Plugins available to make work mo'betta
  • It isn't so heavy it slows your system
  • Highly integrated debugger? That helps.

Problem is not all languages really gain a large productivity gain from a comprehensive IDE. I use IDEs for some work I do (Java, C#) but not for others (Python, Ruby, Coldfusion). It all really is a balancing act. Some languages just don't require such a comprehensive suite.

Are there IDEs for each? Sure. Do you always need one? Not really.

Not the answer you're looking for? Browse other questions tagged or ask your own question.