-
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.
-
Intellisense. It helps a lot with exploring code.
-
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.
-
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
- 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.
-
There might be different reasons for different people. For me these are the advantages.
- Provides an integrated feel to the project. For instance i will have all the related projects files in single view.
- Provides increased code productivity like
- Syntax Highlighting
- Referring of assemblies
- Intellisense
- Centralized view of database and related UI files.
- 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.
-
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.
-
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.
-
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.
-
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 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...
-
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.
-
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 :)
-
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 IDE's 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.
-
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'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.
-
Simply put, an IDE offers additional time-saving features over a simple editor.
-
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.
-
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.
An IDE 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!
-
Being the author of the response that you highlight in your question, and admittedly comming in to this one a bit late :) I'd have to say that among the many many reasons that have already been listed, the productivity of a professional developer is one of the highest regarded skills of a developer.
By productivity, I mean the ability to do you job efficiently with the best possible results. IDE's provide this to you on many levels. Im not an emac expert, but I doubt that there are features that emacs have that any of the major IDE player dont have.
Design, Document, Track, Develop, Build, Analyse, Deploy, Maintain (being key stepping stones in an enterprise application) can all be done within an IDE.
I just dont see why you wouldnt use something so powerful if you have the choice.
As an experiment, why dont you force yourself to use an IDE for, say, 30 days, and just commit youself to it, and after that 30 days, see how you feel. I would love to read your thoughts on what was learnt, etc...
-
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 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).
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 WingIDE (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 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.
-
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.
-
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.
-
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.
-
Because ReSharper for vim and ReSharper for emacs don't exist.
-
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.
e.g. 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.)
-
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 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.
-
Intellisense, the integrated debugger, and the immediate window make me enormously more productive (VS 2008). With everything at my fingertips, I can keep the vast majority of an enormous project inside of my head while writing code. MS may keep dropping the ball on their OSs, but VS is one of the finest products ever developed.
-
An ide allows 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.
-
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.
-
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.
-
Its 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/ASN1 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 ucontroller is doing in
something like /real time/ without an "IDE".
