Why should I use an IDE? [closed]

Question

In another question, Mark speaks highly of IDEs, saying "some people still just dont know "why" they should use one...". As someone who uses vim for programming, and works in an environment where most/all of my colleagues use either vim or emacs for all of their work, what are the advantages of IDEs? Why should I use one?

I'm sure this is a charged issue for some people, and I'm not interested in starting a flame war, so please only reply with the reasons you believe an IDE-based approach is superior. I'm not interested in hearing about why I shouldn't use an IDE; I already don't use one. I'm interested in hearing from "the other side of the fence", so to speak.

If you think that IDEs may be suitable for some types of work but not others, I'm also interested to hear why.

Palermo

Thanks for contacting me though my blog, there really should be a private messaging system in this site! – Mirepoix

emacs is a bad example. It is hard to find an IDE feature that emacs lacks. The difference is what is available out-the-box and what requires a customization. – Sabbatarian

IDEs are useless, real programmers use vim – Vanden

So have you started using an IDE because of the comments? – Yachtsman

Sometime you just have no choice but to use an IDE :( – Tomikotomkiel

People who don't use IDE's for compiled languages are usually old-timers who never want to change their ways, or, at the end of the day, slow programmers (to what they could be). There is a ceiling on how efficient you can get without an IDE. But consider refactoring a method/variable name in an IDE is 3 seconds, but I don't even want to think about it doing it manually. NetBeans for example even has a profiler built in -- it shows me the SQL queries my application is making while I run it! – Telluride

Answer 1

It really depends on what language you're using, but in C# and Java I find IDEs beneficial for:

• Quickly navigating to a type without needing to worry about namespace, project etc
• Navigating to members by treating them as hyperlinks
• Autocompletion when you can't remember the names of all members by heart
• Automatic code generation
• Refactoring (massive one)
• Organise imports (automatically adding appropriate imports in Java, using directives in C#)
• Warning-as-you-type (i.e. some errors don't even require a compile cycle)
• Hovering over something to see the docs
• Keeping a view of files, errors/warnings/console/unit tests etc and source code all on the screen at the same time in a useful way
• Ease of running unit tests from the same window
• Integrated debugging
• Integrated source control
• Navigating to where a compile-time error or run-time exception occurred directly from the error details.
• Etc!

All of these save time. They're things I could do manually, but with more pain: I'd rather be coding.

Oculus

I guess emacs is an IDE, then ;) – Subacid

With the right plugins (or whatever they're called in emacs) then it certainly is. If you can build and debug in it, it's an IDE :) – Oculus

Almost all of this can also be done in Vim for most of the popular languages. Integrated debugging needs a little work, but it's there. – Dibru

When it's acting in that way, I'd say Vim counts as an IDE then. – Oculus

In my experience the biggest thing Vim and Emacs are missing from "real" IDEs (yes, I know they can be greate Development Environment) is the warning-as-you-type part. That would basically mean embedding an advanced compiler in the editor and I don't think they get that level of integration. – Idden

saua: have you looked at Flymake, flymake.sourceforge.net? It at least provide some warnings-as-you-type functions to Emacs – Decibel

there's also a vim pendant which started as GSoC project: code.google.com/p/codecheck – Squiffy

Warning-as-you-type, I assume John Skeet needs this for warning the IDE trying to correct the following code would be an attempt in futility. – Tallyho

This is not what you meant, but I thought emacs was largly a emacs-lisp interpreter. – Keelby

@Joachim Sauer - Emacs has a warning as you type .el available (I know it works for C++ and I think some other languages as well) ;) – Cache

In Eclipse: - Viewing the class hierarchy - Finding references to a type or member throughout the workspace – Tarantella

I recently had to go back to using a non php 'IDE' (new job didn't have one :S) and it was incredibly painful. You appreciate how much time it saves you when you have to go without! I usually use Komodo IDE for php dev and it is fantastic. Just the ability to ctrl-click a function or class call and be taken to it is a real time saver! – Thar

I use pylint and gcc along with flymake to do the "warnings as I type" for Python and C when I use Emacs. – Bauske

@Joachim: There is also js2-mode for JavaScript which runs in the background and warns you of both syntax errors and common (syntactically valid) mistakes like not declaring a local variable with var, missing a semi-colon or statements with no side-effects. – Kathlenekathlin

For the vimmers out there, Syntastic is a lot like flymake. – Ainsworth

I think refactoring is the only one I miss when am working on Vim. Otherwise, IDEs are for sissies ;) – Buoyant

I agree Vim and Emacs are IDE's essentially. The problem is they take a base level of configuration: installing plugins until they run all the features mentioned above. What I need is something like Vim or Emacs (navigating with primarily the keyboard) but has all the good stuff cooked in so I don't need to muck around with plugins and what not. – Latoria

@KolobCanyon How about something like this: github.com/carlhuda/janus, or this: github.com/amix/vimrc, or this: github.com/spf13/spf13-vim? – Hannibal

@AlejandroMiralles -- if you are missing refactoring from VIM and refuse to use an IDE, then I would think long and hard about hiring someone like you. Refactoring ability is extremely important as it prevents bugs that could even show up during run-time (the worst!). – Telluride

@trilogy, I never said refactoring is not important. Far from that. What said was, that if you are using vi (or any other editor like it) you will miss automatic refactors. You will miss them, because you have to do them anyway (by hand, like real men! ;)) – Buoyant

@AlejandroMiralles I think real men write code on a loincloth. Again, doing something like that manually is not advisable. Refactoring in IDE is aware of context. Wouldn’t want to be QA working with you. – Telluride

@Telluride "I think real men write code on a loincloth. " So by your own words, you are not one of them ;). But seriously, IDEs don't guarantee good quality code. Linux, git, python, ruby, rails, lighting db (to name a few) are projects created with text editors. Draw you own conclusion... – Buoyant

@AlejandroMiralles that was a joke. And you just like writing all your code in notepad doesn’t guarantee it’s going to be bad quality code — my point is, you better have a good reason for not using it , and the only reason I could think of is, it’s 1970. – Telluride

@Telluride Not missing refactoring at all. I have automated refactoring on Vim. Extract code, renames, moving stuffs, signature fiddling, etc and yes, they're language and context aware and project aware. I have pretty much every single item in this list in my Vim. And in addition to these, I have lot more, weird configs and shortcuts that no sane IDE developers should ever include in their IDE, but makes perfect sense if you are me. IDE users just couldn't really appreciate having an editor whose configuration language is Turing complete until they used one themselves. – Exhortation

@LieRyan: At that point it's not so much that text editors don't have those features, as that you've turned your editor into an IDE. (There's a lot more support for doing that in more languages than there was back when this was answer was written.) – Oculus

@LieRyan at that point you have an IDE. However I’m sure you’re forgetting something. For example, netbeans has dependency management built in, sql profiling (I can monitor what sql queries are being made as I run the program), advanced telemetrics, object profiling (to detect memory leaks), I can run the application inside the application console, and create and deploy the full binary, all sorts of “warnings”, or “suggestions” as you code. If you can do all that, then you have an IDE. So you’re arguing for our side of the argument against people who use a random text editor. – Telluride

Answer 2

Code completion. It helps a lot with exploring code.

Ey

I would say code completion instead of Intellisense – Shed

Then again, I can press Ctrl+P, giving me a dropdown list of a whole bunch of commands that vim thinks I can use. – Metasomatism

More than just exploring code. If I type a . and nothing pops up, it means that something's wrong with my code; I usually don't even have to compile to find it. If I type a . and don't get what I expect, it means I'm using the wrong type, or forgot to make something internal or public, or some other such problem; I don't have to run to discover the problem. Intellisense is exceptionally useful for spotting errors at the earliest possible moment. – Favrot

How is this an answer? When you read it out loud it sounds like a bad Microsoft slogan... – Latoria

Ok...YouCompleteMe, Deoplete...if you want that type of code completion. I don't know about this for Emacs. Also Vim has exceptional auto-completion out of the box that I missing when using other editors. – Hannibal

Using code completion to explore code stems from the fact that documentation, in general, offers a poor UX – Weft

Answer 3

The short answer as to why I use an IDE is laziness.

I'm a lazy soul who doesn't like to do things a difficult way when there is an easy way to do it instead. IDE's make life easy and so appeal to us lazy folk.

As I type code, the IDE automatically checks the validity of the code, I can highlight a method and hit F1 to get help, right click and select "go to to definition" to jump straight to where it is defined. I hit one button and the application, with debugger automatically attached is launched for me. And so the list goes on. All the things that a developer does on a day to day basis is gathered under one roof.

There is no need to use an IDE. It is just much harder work not to.

Afar

If you are using Visual Studio .NET, F12 is mapped to "Go to definition." (I just discovered that) So you don't need to right-click to get to it. 8) – Parodist

@Knobloch, I tend to use both VS2008 and Eclipse. Priviously I used FlashDevelop a lot. The "Go to definition" shortcut is different for all three, so I tend to rely on right clicking :) – Afar

And you can get intimately familiar with right-clicking on the menu bar, and choosing Customize/Keyboard Shortcuts. – Incontinent

It's not just a matter of laziness :) - an IDE saves valuable time and therefore boosts productivity. – Irresolute

Additionally, an IDE is ready to use, one does not need to set up a lot of difficult things to make it productive. – Ecumenicity

Answer 4

I don't think it's fair to do the classic "text editor and console window vs IDE" when "text editor" is really emacs. Most features that are typical for IDE:s are also in emacs. Or perhaps they even originated there, and modern IDE:s are mainly interface improvements/simplifications.

This means that for the original question, the answer is not so clear-cut. It depends on how people at the site in question use emacs, if they mainly use it as a text editor, or if they go all out and use custom scripting, learn the commands for the relevant modes, know about code tagging and so on.

Lukin

Thanks. Apologies for the ambiguity; to clarify, as far as I know, the emacs users here use it as an editor, ie. in the same way that people would use vim. It is not used like an IDE. – Palermo

For the record, I use emacs like an IDE. – Spirituous

Yeah, that's not a safe generalization. I use Emacs for all the IDE features mentioned in these answers. – Hygienics

I think a time it takes to configure IDE-like features in a powerful text editor could be better spend coding in an IDE using out-of-the-box features. – Sabbatarian

I use vim like I use an IDE. – Kampong

@J.F. Sebastian: The problem there is that, to enhance production you'll have to learn the ins and outs of that IDE and, if you're switching languages and using a lot of different tools it can become a hassle. I've been learning vim currently and, although it's hard to get used to at first, it quickly pays off when I can find it in different systems and for many different languages. – Homestretch

@J.F.Sebastian: I think it's more productive to configure Emacs to do IDE stuff than to configure an IDE to do Emacs stuff like navigation, tramp,shell-mode,dired...etc. – Kathlenekathlin

emacs is not an IDE and anyone who thinks that they can get away with using it, is missing the point. For example re-factoring (aware of context) and code-completion (not just suggestions, but actual code completion where it takes into account the object state, context etc) are IDE features. If your point is to use 100+ plugins to make something close to an IDE, then you're not doing yourself or anyone who has the bad luck in hiring you any favours. – Telluride

Answer 5

I come at this question from the opposite direction. I was brought up in programming with very few pitstops in Makefile+Emacs land. From my very earliest compiler on DOS, Microsoft Quick C, I had an IDE to automate things. I spent many years working in Visual C++ 6.0, and as I graduated into Enterprise Java, I worked with Borland JBuilder and then settled on Eclipse, which has become very productive for me.

Throughout my initial self-teaching, college, and now professional career, I have come to learn that any major software development done solely within the IDE becomes counterproductive. I say this because most IDE's wants you to work in their peculiar I-control-how-the-world-works style. You have to slice and dice your projects along their lines. You have manage your project builds using their odd dialog boxes. Most IDE's manage complex build dependencies between projects poorly, and dependencies can be difficult to get working 100%. I have been in situations where IDE's would not produce a working build of my code unless I did a Clean/Rebuild All. Finally, there's rarely a clean way to move your software out of development and into other environments like QA or Production from an IDE. It's usually a clicky fest to get all your deployment units built, or you've got some awkward tool that the IDE vendor gives you to bundle stuff up. But again, that tool usually demands that your project and build structure absolutely conforms to their rules - and sometimes that just won't work for your projects' requirements.

I have learned that, to do large-scale development with a team, we can be the most productive if we develop our code using an IDE and do all of our builds using manually written command line scripts. (We like Apache Ant for Java development.) We've found that running our scripts out of the IDE is just a click fest or an automation nightmare for complex builds, it's much easier (and less disruptive) to alt+tab out to a shell and run the scripts there.

Manual builds requires us to miss out on some of the niceties in the modern IDE like background compilation, but what we gain is much more critical: clean and easy builds that can live in multiple environments. The "one click build" all those agile guys talk about? We have it. Our build scripts can be directly invoked by continuous integration systems as well. Having builds managed through continuous integration allows us to more formally stage and migrate your code deployments to different environments, and lets us know almost immediately when someone checks in bad code that breaks the build or unit tests.

In truth, my taking the role of build away from the IDE hasn't hurt us too badly. The intellisense and refactoring tools in Eclipse are still completely useful and valid - the background compilation simply serves to support those tools. And, Eclipse's peculiar slicing of projects has served as a very nice way to mentally break down our problem sets in a way everyone can understand (still a tad bit verbose for my tastes though). I think one of the most important things about Eclipse is the excellent SCM integrations, that's what makes team development so enjoyable. We use Subversion+Eclipse, and that has been very productive and very easy to train our people to become experts at.

Aprilette

+1, the complexities introduced to building stuff (at least typically) are one of the biggest reasons I tend to detest IDEs – Quicksand

Answer 6

Being the author of the response that you highlight in your question, and admittedly coming to this one a bit late, I'd have to say that among the many reasons that have been listed, the productivity of a professional developer is one of the most highly-regarded skills.

By productivity, I mean the ability to do your job efficiently with the best-possible results. IDEs enable this on many levels. I'm not an Emacs expert, but I doubt that it lacks any of the features of the major IDEs.

Design, documentation, tracking, developing, building, analyzing, deploying, and maintenance, key stepping stones in an enterprise application, can all be done within an IDE.

Why you wouldn't use something so powerful if you have the choice?

As an experiment, commit yourself to use an IDE for, say, 30 days, and see how you feel. I would love to read your thoughts on the experience.

Mirepoix

There are features Emacs has that Eclipse, at least, either lacks or hides extremely well. For example, the ability to select a chunk of lines and sort them in-place. Emacs' fill-paragraph is also hard to beat when editing comments; Eclipse kind of has a similar feature, but it's extremely weak in comparison. – Gettings

I think a big reason people don't go for IDEs is their bloatedness. If you just want to make a sandwich you don't need the entire supermarket. – Sudduth

In my experience, IDEs don't let you interact as thoroughly and as consistently with everything using the keyboard. Also, Emacs does have a bunch of great features that IDEs don't, ranging from the small-but-useful (rectangular regions, hippie-expand, extensive keyboard naviagtion) to the rather major (tramp, dired, transparent customization with elisp, keyboard macros). I'm sure some of the IDEs have some of these features, but I haven't seen them. – Kathlenekathlin

Answer 7

IDEs are basically:

• Editor w/code completion, refactoring and documentation
• Debugger
• Filesystem explorer
• SCMS client
• Build tool

all in a single package.

You can have all this (and some more) using separate tools or just a great programmable editor and extra tools, like Emacs (Vim as well but has a little less IDEbility IMO).

If you find yourself switching a lot between one utility and the next that could be integrated in the environment or if you are missing some of the abilities listed here (and more completely in other posts), maybe it's time to move to an IDE (or to improve the IDEbility of your environment by adding macros or what not). If you have built yourself an 'IDE' (in the sense I mention above) using more than one program, then there's no need to move to an actual IDE.

Elroyels

Answer 8

Having an IDE has the following advantages:

• Compiling is usually "on the fly" which means no more switching to the command line to compile
• Debugging is integrated, and having that in an IDE means that the step debugger actually uses your in-place editor to visually show you which code is executed
• IDE's usually have more semantic knowledge of the language you're working in, and can show you possible problems while typing. Refactoring is much more powerfull than the "search replace".

There are much more, maybe you should give it a try.

Archibold

I can't speak for every minimal editor, but Vim has macros you can script that can do a lot of things like compile and run. – Sudduth

@Corey the point is that YOU have to script them. It should already be available. – Castiglione

Answer 9

Eclipse:

Having code higlighting, compiling in the background, pointing out my errors as I go along.

Integration with javadoc, suggesting variable names with ctrl-Space.

When I compile, I get errors right there. I can double click on an error, and it displays the appropriate line.

Really well integrated with JUnit, ctrl-F11 runs the test, tells me the tests have failed. If there is an exception in the output window, I can double click on a line, and takes me to the line that failed. Not only that, but ctrl-F11 makes sure everything is compiled before it runs the tests (which means I never forget to do that).

Integration with ant. One command to build and deploy the application.

Integration with debuggers, including remote debugging of web servers.

FANTASTIC refactoring tools, searching for references to a section of code. Helps me know the impact of a change.

All in all, it makes me more productive.

Bid

The thing is that Emacs does pretty much all of that, for more languages than Eclipse. – Kathlenekathlin

Answer 10

I have used Emacs as my primary environment for both development and mail/news for about 10 year (1994-2004). I discovered the power of IDEs when I forced myself to learn Java in 2004, and to my surprise that I actually liked the IDE (IntelliJ IDEA).

I will not go into specific reasons since a lot of them have already been mentioned here -- just remember that the different people love different features. Me and a colleague used the same IDE, both of us used just a fraction of the features available, and we disliked each others way of using the IDE (but we both liked the IDE itself).

But there is one advantage with IDEs over Emacs/Vim related environments I want to focus on: You spend less time installing/configuring the features you want.

With Wing IDE (for Python) I'm ready to start developing 15-20 minutes after installation. No idea how many hours I would need to get the features I use up and running with Emacs/Vim. :)

Sporogonium

It takes longer to start, but it it is better 'tailored' afterwards. – Snailpaced

Configuring Emacs/Vim is just a matter of copying the appropriate files to a place where the program can find them. It really isn't that difficult if you keep your configuration files nicely organized in one directory, after which you can put keep them on a flash drive, internet storage, or in a repository so you can clone them whenever you need to set up your work environment. :) – Yeah

Answer 11

It definitely leads to an improvement in productivity for me. To the point where I even code Linux applications in Visual Studio on Vista and then use a Linux virtual machine to build them.

You don't have to memorize all of the arguments to a function or method call, once you start typing it the IDE will show you what arguments are needed. You get wizards to set project properties, compiler options, etc. You can search for things throughout the entire project instead of just the current document or files in a folder. If you get a compiler error, double-click it and it takes you right to the offending line.

Integration of tools like model editors, connecting to and browsing external databases, managing collections of code "snippets", GUI modeling tools, etc. All of these things could be had separately, but having them all within the same development environment saves a lot of time and keeps the development process flowing more efficiently.

Child

Answer 12

An IDE can be a 'superior' choice based depending upon what a developer is trying to accomplish.

A text editor can be 'superior' because IDEs are typically geared toward one (or a small selection) of languages.

If a developer spends most of his/her time in a single languge or a 'cluster' of related languages (like C# and T-SQL), in one OS, then the GUI design, debug, intellisense, refactoring etc. tools offered by a good IDE can be very compelling. If, for instance, you spend most of your time working in VB.NET, with maybe a little T-SQL now and then, in a Windows environment, then you'd be pretty silly to not look at Visual Studio or a comparable IDE.

I have no prejudice towards those who prefer IDEs or text editors, both can be very productive and useful if learned well!

Unable

Answer 13

There might be different reasons for different people. For me these are the advantages.

1. Provides an integrated feel to the project. For instance i will have all the related projects files in single view.
2. Provides increased code productivity like
   1. Syntax Highlighting
   2. Referring of assemblies
   3. Intellisense
   4. Centralized view of database and related UI files.
   5. Debugging features

End of the day, it helps me to code faster than i can do in a notepad or wordpad. That is a pretty good reason for me to prefer an IDE.

Foss

Answer 14

I think it has mostly to do with scope of awareness for the developer. The IDE provides a macroscopic view of the developer's work context. You can simultaneously see class hierarchies, referenced resources, database schemas, SDK help references, etc. And with so many things affected by, and affecting, your keystrokes, and the expanding volume of architectures and architectural intersections, it gets more and more difficult to work solely from one island of code at a time.

OTOH, "just me and vim and the man pages" gives me a much leaner microscopic - but intense and precise - view of my work. This is ok if I have a well-designed, well-partitioned, sparsely coupled highly cohesive codebase built in one language with one set of static libraries to work from - not your typical situation, especially as dev team sizes grow and reshape the code structure over time, distance, and personal preference.

I'm currently working on projects in Flex and .NET. One of the nicer things about Flex is how few different ways there are to accomplish a standard thing - pull data from a database, open/close/read/write a file, etc. (Yet I'm using the Flex Builder/Eclipse IDE - a typical heavy-weight example like VS, because I'm still learning the basics and I need the training wheels. I expect to evolve back to vim once I'm confident of my patterns.) In this view, I can do what I need to do professionally by knowing a few things really really well.

OTOH, I can't imagine getting to that point with .NET because the view I'm expected to maintain keeps expanding and shifting. There much less conceptual integrity, and over several developers on a project over several months, much less consistency - but the IDE supports that, maybe encourages it. So the developer really needs to (and can more easily) know many more things adequately. Which also has the benefit of helping them answer (or even understand) a lot higher percentage of the questions on StackOverflow. I.e. we can have a deeper knowledge stack. And we can respond to a wider variety of help-wanted ads.

Things can go too far in both directions. Maybe with the "editor-only" scope, it's like "if you only have a hammer, everything looks like a nail". With the IDE approach, for whatever you want to fasten together, you have a broad selection of fasteners and associated ranges of tools to choose from - nals/hammers, screws/screwdrivers, bolts/wrenches, adhesives/glue-guns/clamps, magnets, and on and on - all at your fingertips (with a wizard to help you get started).

Pinnate

Answer 15

IntelliSense, the integrated debugger, and the immediate window make me enormously more productive (Visual Studio 2008). With everything at my fingertips, I can keep the vast majority of an enormous project inside of my head while writing code. Microsoft may keep dropping the ball on their OSs, but Visual Studio is one of the finest products ever developed.

Amalgamate

Answer 16

In addition to the other answers, I love combining the developing power of an IDE with the editing power of Vim using something like the ViPlugin for Eclipse.

Connelly

Answer 17

Don't think of it as exclusive. Use the IDE for the benefits it provides, and switch to vim/preferred text editor when you need some serious focus.

I find the IDE better for refactoring and browsing and debugging and for figuring out what to do. Small things are then done right in the IDE, large things I flip to vim to finish the job.

Academic

Answer 18

I do not understand what you are asking. You ask "Should I use an IDE instead of...", but I don't understand what the alternative is - Vim and Emacs fulfil many functions any IDE will give you. The only aspect they do not handle that a larger IDE may are things like UI designers. Then your question boils down to simply "what IDE should I use" with arguments to be made for the simpler realm of Vim and Emacs.

Amalgamate

Answer 19

I also almost exclusively use Vim (almost because I'm trying to learn emacs now) for all my development stuff. I think sheer intuitiveness (from the GUI of course) is the primary reason why people like to use IDEs. By being intuitive, little to no learning overhead of the tool is required. The lesser the learning overhead, the more they can get work done.

Ravenravening

Answer 20

GUI-based IDEs like Visual Studio and Eclipse have several advantages over text-based IDEs like Emacs or vim because of their display capabilities:

• WYSIWYG preview and live editing for GUI design
• Efficient property editors (eg. color selection using a GUI palette, including positioning gradient stops etc)
• Graphical depiction of code outlines, file interrelationships, etc
• More efficient use of screen real-estate to show breakpoints, bookmarks, errors, etc
• Better drag and drop support with OS and other applications
• Integrated editing of drawings, images, 3D models, etc
• Display and edit of database models

Basically with a GUI-based IDE you can get more useful information on screen at once and you can view/edit graphical portions of of your application as easily as text portions.

One of the coolest things to experience as a developer is editing a method that computes some data and seeing the live output of your code displayed graphically in another window, just as your user will see it when you run the app. Now that's WYSIWYG editing!

Text-based IDEs like Emacs and vim can add features like code completion and refactoring over time, so in the long run their main limitation is their text-based display model.

Homoeroticism

Answer 21

An IDE allows one to work faster and more easily... I noticed I spent a lot of time navigating in the code in a simple text editor...

In a good IDE, that time goes down if the IDE supports jumping to functions, to previous editing position,to variables... Also, a good IDE reduces the time to experiment with different language features and projects, as the start-up time can be small.

Lux

Answer 22

A couple of reasons I can think of for using an IDE:

• Integrated help is a favorite.
• The built-in Refactor with Preview of the Visual Studio
• IntelliSense, syntax hightlighting, ease of navigation for large projects, integrated debugging, etc. (although I know with addins you can probably get a lot of this with Emacs and Vim).
• Also, I think IDEs these days have a wider user-base, and probably more people developing add-ins for them, but I might be wrong.

And quite frankly, I like my mouse. When I use pure text-based editors it gets lonely.

Perineurium

Answer 23

To me it's just the the GUI version of everything we did in the good old days of the terminal. I will always agree that IDE are not very superior because they hide a lot of stuff, especially concerning the linking stuff, but they have a notable advantage in some cases, for example with certain development platforms like Qt.

Some IDE like visual of others even seem to parse your code as you type it, and detect errors before you even compile: it seems logics that only an IDE can work closely with a compiler to immediately detect problem in the typed source.

My wild answer that the IDE/Command-line flame war exists is just because the C/C++ executable building is not very well handled from a standardized point of view, unlike with the D language; every platform handles compiling/linking/etc its own way, so to make it less messy they make an IDE.

From your viewpoint it might be more simple to use the command-line, if there would have been only one compiler with standard options, it would have been easy, but the truth is C/C++ is flexible, so in the end, all platform do it their own way, hence the IDE to not waste explaining how to do it.

If you can learn how an executable talks to the kernel or if you know anything about compiler design, maybe there is a way to work with a proper command-line, but I doubt you have.

Microsoft or Apple, all evil they would be, have to propose a straight-forward way to build application without entering in the details, and since building an application depends directly on the architecture of the OS, it will hardly be "standard" as the command-line is.

To put it simple, big and complex applications where you don't want to dig too deep into what it does -> IDE, little pieces of software or simple system software-design -> command-line. Except of course those nifty libraries that embed a Makefile, but that's another story.

Also I think IDE are used when the application delivered has something to do with, ironically, a GUI or something that has an interface or is directly bound to an OS, so again, it's also for people who will use a UI/GUI without knowing how it works, while people who will program systems won't need it all.

IDE is just modern shit, but I think in 100 years the command-line will still exist.

Coelho

Answer 24

My main reason to use one is when the code goes beyond 100 files.

Although ctags can do the work, some IDEs have a pretty good way to navigate the files easily an super fast.

It saves time when you have a lot of work to do.

Hydrocephalus

Answer 25

I'm not sure there's a clear dividing line between a text editor and an IDE. You have the likes of Notepad at one end of the scale, and the best modern IDEs at the other, but there are a lot of thing in between. Most text editors have syntax highlighting; editors aimed at programmers often have various other features such as easy code navigation and auto complete. Emacs even lets you integrate a debugger. The IDEs of even ten years ago had far less features to help programmers than you'd expect of a serious text editor these days.

Pastose

+1 for noting that today's "editors" have more features than yesterday's "ides". – Reflex

Answer 26

Saves time to develop
Makes life easier by providing features like Integrated debugging, intellisense.

There are lot many, but will recommend to use one, they are more than obvious.

Wormy

Thanks for the reply, but if I thought they were obvious, I wouldn't have asked the question in the first place! – Palermo

Answer 27

It's really VERY simple. But this answer is a bit of a paradox in that I am discussing something only EMBEDDED level developers ever encounter. The reason this is an odd view is that frankly when I was doing embedded work (the brief time I was making any real money) an IDE would be down right STRANGE and most of your coworkers would wonder why you can't remember enough about SNMP/ASN.1 or whatever protocol you were dealing with to just /do your job/. BUT you can NOT, as far as I know, do a graphical simulation of what your microcontroller is doing in something like /real time/ without an "IDE".

Amalgamate

Answer 28

For me, an IDE is better because it allows faster navigation in code which is important if you have something in your mind to implement. Supposed you do not use an IDE, it takes longer to get to the destination. Your thoughts may be interupted more often. It means more clicks/more keys have to be pressed. One has to concentrate more on the thought how to implement things. Of course, you can write down things too but then one must jump between the design and implementation. Also, a GUI designer makes a big difference. If you do that by hand, it may take longer.

Yachtsman

I have yet to see a user of any popular IDE match a skilled Vim or Emacs user (like myself) in terms of codebase navigation or editing speed. As for distractions, nothing beats a finely-tuned Emacs or Vim setup with minimal interruptions. – Cursor

Answer 29

I'm not entirely sold on the use of IDEs. However, I think that the most valuable aspect of a good IDE, like Eclipse, is the well-integrated Cscope-style functionality rapid comprehension of a large code base.

For example, in Eclipse, you see a method takes an argument of type FooBar, yet you have no idea what it means. Rather than waste a minute finding the definition the hard way (and risk all sorts of distractions along the way), just select FooBar, hit F3, and it opens the relevant source file to the very line that FooBar is defined.

The downside of IDEs, in my opinion, is that they give you a bigger learning curve, except in the case in which you want to use the absolutely default configuration. (This is true for Emacs as well.)

Amaranthine

Of course, that is why in Python we have docstrings. But alas, not everyone can be so lucky as to work in Python. – Urion

Answer 30

An IDE handles grunt work that saves you time.

It keeps all associated project files together which makes it easy to collaborate.

You can usually integrate your source control into your IDE saving more grunt work and further enhancing collaboration.

If it has auto complete features, it can help you explore your language of choice and also save some typing.

Basically, an IDE reduces non-programming work for the programmer.

Sestos

Basically, an IDE reduces non-programming work for the programmer - I think this is one of the best reasons given in all of the answers – Anodyne

Answer 31

It depends highly on what you're doing and what language you're doing it in. Personally, I tend to not use an IDE (or "my IDE consists of 3 xterms running vim, one running a database client, and one with a bash prompt or tailing logs", depending on how broadly you define "IDE") for most of my work, but, if I were to find myself developing a platform-native GUI, then I'd reach for a language-appropriate IDE in an instant - IMO, IDEs and graphical form editing are clearly made for each other.

Stephaniestephannie

Answer 32

There's only one thing to consider when deciding whether to use an IDE or not, and that's whether it makes you more productive or not.

Short question so short answer :)

Christian

Thanks for the response, but it was obvious that some people believe this before I submitted the question. I really want to know why you think it might make you more productive? Does it make you productive in some scenarios but not others? – Palermo

Answer 33

I like an IDE because it puts a lot of functionality at my fingertips. Editing/Compilation/visibility of files in the project are all things I value in an IDE. I use Visual Studio now but in a former life I used SlickEdit and found that it made my development process more streamlined than when I wasn't using it.

Vergne

Answer 34

I prefer an IDE because it permits me to integrate editing/compiling/debugging, with a 1-click jump from error to line generating the error. Further, it permits multiple panes of information with OS-standard interfaces displaying the information. In short, it gives the user a mouse-based input interface with a modern output interface instead of relying on 1970s technology and interfaces for my help.

There are more sophisticated users and uses for an IDE, I don't claim to use them or to know them all. When I have need, I will learn them.

Troudeloup

Both vim and emacs have. Only the debugging could be a little awkward -- as most other gdb/dbx wrappers. – Cryotherapy

I don't even want to think about the time I'd waste trying to get vim/emacs to do that. Time that I could be happily coding away on Visual Studio....getting real work done. – Troudeloup

Answer 35

Simply put, an IDE offers additional time-saving features over a simple editor.

Amur

What features in particular? This doesn't answer my question at all. – Palermo

Question was "Why should I use an IDE?". Answer is "It saves time". – Amur

What features do you consider the time-saving? – Sabbatarian

Just a few off the top of my (currently caffeine deprived) head. Code completion, code insertion/building. Syntax aware highlighting. Automated builds. – Amur

Its depends, text editor like emacs and vim also can same times via plugins. – Rainie

Emacs is arguably an IDE (and an OS and a programming language of it's own!). :-) – Amur

call Emacs a SIMPLE editor ONE MORE TIME!!! – Testis

Answer 36

A very good reason for using IDEs is that they are the accepted way of producing modern software. If you do not use one, then you likely use "old fashioned" stuff like vi and emacs. This can lead people to conclude - possibly wrongly - that you are stuck in your ways and unable to adapt to new ways of working. In an industry such as software development - where ideas can be out of date in mere months - this is a dangerous state to get into. It could seriously damage your future job prospects...

Afar

A valid point, although I think it depends on where you work. When I had my interview for my current job, I was specifically asked, "what editor do you use?" and when I replied that I use vim, the answer was "good!" – Palermo

Yeah, that sounds a very microsofty view of things. Using an IDE (without being able to code without) implies that you have no idea what's going on, using vi/a cli interface means that you actually know what's happening. – Faucet

@Rich, that is just too funny. LOL. – Afar

I find it amusing that I could be seen as being "stuck in my ways" for using vim (or Komodo with vi-bindings) when I'm 20, starting serious programming 2 years ago, and these bindings for less than a year. Yes, I chose to work on a large-ish Java project in this environment, rather than Eclipse or Netbeans. I also rewrote all the Ant build scripts in Rake, because I consider Ant to be too old and verbose; how's that for not accepting new technologies? – Urion

Most people using IDE actually have no knowledge of things happening behind scenes whereas someone using vim has to have a clear picture.If a company considers You to "stuck up in your ways" for using vim then you should seriously consider joining. – Paynter