Benefits of an IDE?
 

Hello,

What are the benefits of using a full-fledged IDE (i.e., Eclipse, Code::Blocks, KDevelop, etc.) over an advanced text editor (i.e., VIM, emacs, kate, etc.)?

It really depends on your preference.

Using an IDE can make it easier to build complex projects, as the compiling, linking, etc of multiple files are automated.

Of course, everything that is done in an IDE can also be done using a text editor, and tools such as make.

--Ian

Autocomplete :o)
 

Many IDE's also spur nice features like autocompletion of your code - an IDE like Eclipse has a lot of nifty plugins - GUI editors (ever coded a fully functional gridbag layout based interface yourself... mwaaaah ;o), some of them come with fully exportable and executeable pure java code.

BlueJ is a good beginners IDE allowing you to instanciate objects without running the entire program.

Some IDE's help you to format your code more properly, there is the whole refactoring thing etc. etc.

However don't discount the simple text editor which is very useable as well.

The point is choose the tools which you feel suits you the best.

The nice thing of IDEs is that it initially hides stuff away that you don't care about (like linking) and that the help gives examples that use other functions as well so you get more easily familiar with all functions of the language.

Disadvantage is that as you e.g. don't know what linking is, you will not understand why building fails when you try to compile an app that needs a specific library.

I started of with TurboC (under DOS) and learned a lot through the IDE. Now I only use vi and the man pages.

If you don't know what you are doing, an IDE will go a long way to protect you from having to learn. If you do know what you are doing, the IDE will make a serious attempt to compel you to do it the IDE's way.

The IDE will group all of your development environment in one big window, and will prevent you from spreading things out over the desktop to suit yourself - unless, of course, you can do that while remaining within the one big window.

Because the IDE knows more than you do, it will stop you from doing things that are baaad. For instance, if you look at a chunk of code and say: "this code should be moved into a subroutine", the IDE will make your life hell when you first write a call statement for your new subroutine right above the block of code, then write the subroutine statement (or function statement...whatever is appropriate for this language) on the next line, then write the closing statement for the subroutine below the block of code, all without first moving the code out of the function in which it resides.

Because it knows better than you, the IDE informs you of all your errors trying to write a subroutine within a subroutine. Because it knows better than you, it puts up repeated error messages while you are attempting to match up your argument lists between the calling line and your new subroutine, whose defining statement is in the body of a routine and directly below the calling line. It complains when you make those indicated changes to the block of code to make that block of code part of this new subroutine.

And it isn't even nice enough to apologize when you then cut/paste that new subroutine out of the middle of a routine and into a place of its own, after you are done defining everything.

In theory you can turn off these "helpful features" that are blocking you from being productive and getting on with the job. To do that you have to find the correct tab on the correct sub-requester beneath the correct tab on the correct requester which is started from the correct sub-menu under the correct menu item on the proper menu, which can be accessed from the big IDE window when the conditions are right.

Autocomplete is nice, and showing you the members of an object is also nice, except when you didn't want that and the tooltips box is obscuring the next three lines, which is what you really are interested in.

IDEs do have their place. As far from me as possible.

jiml8, text editors and make all the way.

By reading the replies to this question it would appear, to the casual observer, that in the main IDE's don't help with development and all that you need is an editor.

First I would like to say that if you can master a good text editor then you can achieve an awful lot, however I've never been in that category, having spent a lot of my early years on mainframes and struggling with a limited environment I then felt liberated when I started using Mac in the early 90's after that I have found myself firmly entrenched in the GUI camp.

Like a good text editor you need to spend the time configuring the IDE to suit your needs and match with the way that you choose to develop. However because the control of features with an IDE is typically controlled by dialogue boxes it is here (rather that the underlying configuration file) where the changes need to be set. For some reading a dialogue box can be easier than scouring the configuration file.

It can be argued that an IDE makes it easier when you are starting off on the big adventure. You get to focus on the editing and the IDE manages the compiling, linking, running and debugging for you. But as you progress you can also (just like all the other tools) add switches and options typically via the IDE dialogue boxes to give instructions to the compiler or linker etc.

Personally I think that the fact that an IDE really integrates the debugging process is a big plus, but of course that can all be done from the command line, or if you prefer standalone visual debugging tools.

Just as a good text editor can do everything that a good IDE does a good IDE can do everything that a good text editor does. Both take time to master, as individuals we work differently, for some the text editor is the best approach, for others an IDE is the best. Use both but select the one that you feel most comfortable with.

personally, I started using sun studio when I got solaris 10 but went back to
the old fashioned way because I could get things done quicker.


mind you I am a whizzkid with vi(m).

When I started we only had cmd line editors, so I'm used to and happy with those, currently vi(m).
Then again, like most programmers I'm prob a ctrl freak underneath, so I don't like the system getting in the way...
;)

Hello,

Thanks for all the replies. I am definitely getting the impression that it is best to use the tools that you find most effective for you. I am starting to think that I am not a nut for thinking that I don't need a big all-inclusive IDE to program. That I can successfully program even large programs with vim, gcc/make, gdb and a good sense of organization and/or a version control system like CVS/Subversion.

Yep, unless you are required to do otherwise, use whatever works for you.
:)

It's certainly handy to be able to use the cmd line tools, because you can't always guarantee your favourite IDE will be avail.
That's why I recommend all programmers etc learn at least the basics of vi/vim, because it's the one editor you can (afaik) guarantee will be avail on a *nix system.
Also low overhead if you have a low bandwidth cxn or are using a rescue CD.
Ditto on a real console.

Hello,

Cool. I'll stop worrying about it and learn my hand tools really well.

I think I might play around with an IDE for a little bit for kicks, just to see what all the hoopla is about.