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.
Having an IDE has the following advantages:
There are much more, maybe you should give it a try.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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".
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.
Simply put, an IDE offers additional time-saving features over a simple editor.
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...
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 :)
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.
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.
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.
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.
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.
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.
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.
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.
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.
Code completion. It helps a lot with exploring code.
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.
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.
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.
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.
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".
Code completion. It helps a lot with exploring code.
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.
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...
GUI-based IDEs like Visual Studio and Eclipse have several advantages over text-based IDEs like Emacs or vim because of their display capabilities:
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.
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.
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.
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.
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.
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. :)
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.
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.
Code completion. It helps a lot with exploring code.
Having an IDE has the following advantages:
There are much more, maybe you should give it a try.
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.
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 :)
Having an IDE has the following advantages:
There are much more, maybe you should give it a try.
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.
There might be different reasons for different people. For me these are the advantages.
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.
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.
There might be different reasons for different people. For me these are the advantages.
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.
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.)
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.
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.
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...
Code completion. It helps a lot with exploring code.
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.
IDEs are basically:
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.
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!
Having an IDE has the following advantages:
There are much more, maybe you should give it a try.
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.)
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.
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.
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).
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.
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.
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!
IDEs are basically:
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.
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).
Simply put, an IDE offers additional time-saving features over a simple editor.
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.
There might be different reasons for different people. For me these are the advantages.
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.
A couple of reasons I can think of for using an IDE:
And quite frankly, I like my mouse. When I use pure text-based editors it gets lonely.
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. :)
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.
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.
Simply put, an IDE offers additional time-saving features over a simple editor.
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.
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.
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.
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.
A couple of reasons I can think of for using an IDE:
And quite frankly, I like my mouse. When I use pure text-based editors it gets lonely.
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.
IDEs are basically:
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.
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.
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.
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.
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 :)
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.
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).
GUI-based IDEs like Visual Studio and Eclipse have several advantages over text-based IDEs like Emacs or vim because of their display capabilities:
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.
IDEs are basically:
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.
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!
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.)
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. :)
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.
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.
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.
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.
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.
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.
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.
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.
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.
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. :)
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.
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.
A couple of reasons I can think of for using an IDE:
And quite frankly, I like my mouse. When I use pure text-based editors it gets lonely.
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...
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!
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 :)
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.
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.)
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).
Source: Stackoverflow.com