What justifies the use of an IDE versus a standard editor?

Question

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?

Answer 1

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.

Answer 2

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.

Answer 3

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,

Answer 4

[To the IDE] You had me at intellisense/autocomplete

Answer 5

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.

Answer 6

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.

Answer 7

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.

Answer 8

• One-click compilation
• Debugging
• Code templates
• Code completion
• Integration with version control and refactoring tools
• Simpler unit testing

to name a few

Answer 9

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.

Answer 10

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.

Answer 11

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.

Answer 12

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.

Answer 13

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)

Answer 14

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.

Answer 15

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.

Answer 16

Short learning curve. Thats it.