Nobody has worried too much about
Integrated Drive Electronics in a long time; it was superceded by
EIDE (
Enhanced IDE), then both were retroactively named
ATA (because the interface,
ATAPI, applies to more than spinning hard drives). Then with the advent of
SATA (
Serial ATA), the artist formerly known as EIDE was retroconned to
PATA (
Parallel ATA). IDE, as it applies to hard drives, is a quaint archaism unless you are on a hunt for a replacement drive for a 286 or an early 386. (Later machines used EIDE/PATA; non-ISA machines tended to use SCSI, and current machines tend to use SATA.) That being said...
An
Integrated Development Environment is much more than just a code-aware editor. Of course, it has to have some code-specific editing features in order to lift it above the common crowd, like syntax highlighting, brace and tag matching, keyword completion, auto-indenting, and code folding (the ability to collapse blocks of code so that only those elements you're interested in appear on-screen). It'll also have room for snippets and boilerplate, a good search-and-replace facility, and probably a diff/delta function so you can compare files. A clever editor that still wouldn't be an "IDE" might even be able to parse symbols (your variable names) and offer syntax hinting locally, along with the ability to rename variables without having to get clever with regular expressions. That takes a good parsing routine and a large language/platform syntax file, but it's still within the realm of "code editor" -- you can design your own language and (with a lot of effort) write Lisp macros to turn Emacs into this level of editor for your language. You can even get it to recognise things that will become "compile time" errors and highlight them (sort of like spell checking for code). It'll add years to your life, reduce baldness, and so on, but it's still not an IDE.
Of course, you'll want the editor to be able to handle all of the ancillary files as well -- configuration files, style sheets, JavaScript for your web pages, and so on -- so you don't need to have a specialised editing application open for every file type and can make quick changes across multiple file types when necessary. But then most editors more advanced than Notepad can do that sort of thing.
Crank the volume up a little bit more, and the editor gains the ability to import from other files, giving you syntax hinting from classes and methods that are neither part of the language itself, nor local to the file you're working on. And you can "clump" your files together into projects, so all of the related files are available at a glance, and all of the files you had open last time will open again when you launch the application. It doesn't matter whether the imported code is a framework or just code modules you've written yourself, this makes your world a better place. Now we have a very good code editor, and can do some serious refactoring, but it's still not an IDE -- yet. Somewhere around this level (or maybe a bit lower down) you also start to see the ability to connect seamlessly with a versioning system (SVN, CVS, Mercurial, Git, etc.) either natively or through a plugin. Again, that's a necessary but insufficient feature for an IDE.
(You
are using a version control system, even on solo projects, right? I mean, your mental health is
your business, of course, but you don't really want your picture to appear on the local news along with your neighbors telling everyone, "he was such a quiet, good-natured fellow -- I never saw
that coming," do you?)
For something like web development on the xAMP stack, that may be all you need. After all, you can install the stack (XAMPP, WAMP, or some variant) on your local machine, maintain current versions of your files in the web directory, and use a bunch of browsers to test drive your masterpiece. That's not "integrated", but it works. There are several good editors out there at this level; some of them call themselves IDEs for marketing reasons, but they're still missing a lot of true IDE features (which are often available in the costs-money "pro" version). Again, they may be all you ever need.
An IDE, though, should allow you to test and debug your code. That means having a run-time or two built into (or called by) the IDE, and for most languages, it means having a compiler and at least a rudimentary make/build function to create a runnable version of the code you're testing. Bonus points for being able to step through the source code, watch variables and execution contexts, and set break points. (That isn't always easy to do -- functional languages like Clojure (on the JVM) and F# (.NET) often have huge differences between the source code and the machine code/byte code their compilation results in.) "Live" editing in the debugger is always a Good Thing when you can get it. And you may need more than one run-time/debugger going at any given time -- a web app under test, for instance, would need to be able to handle both the server-side code and the JavaScript in the browser, but at this point we're really starting to ask a lot. Don't be surprised if you need to rely on separate browsers and their debuggers (Firebug or the excellent tools built into Chrome) to work with the front-end code anyway, since your IDE is unlikely to have multiple built-in rendering and JS engines.
A "proper" IDE needs to have the ability to make/build an application and, where possible, to deploy the application as well. That can range from something as simple as FTP or WebDAV to put files on your web server to creating Ant or makefiles -- whatever is appropriate to the language and platform you're using.
There's one thing conspicuously absent from the typical IDE, and that's a facility for "real" graphics. My guess is that there's some sort of long-standing division-of-labour agreement between
Doozers and Fraggles, leaving us Doozers with only the non-exclusive ability to create ICO images when absolutely necessary. Those of us who are mixed-race (I'm a Fraggle on my father's side and a Doozer on my mother's) just have to learn to use different tools for different tasks where code and graphics mix.
I've probably missed a few things along the way, but I can point you to a good example of what an IDE ought to be -- Microsoft's Visual Studio. No, I'm not a MS fanboi, nor am I a lover of the .NET framework in any way. (Okay, I prefer C# over Java, but in the way that a person on a "bland food" diet might prefer mashed potatoes over Cream of Wheat.) But VS is an excellent IDE -- if you're working on a Microsoft platform. Everybody in the IDE game should be aspiring to what MSVS does.
Eclipse -- or, rather, the specialised IDEs based on Eclipse -- is also
very good in every way except for speed and responsiveness. (Personally, I find it very reminiscent of Ye Olde Dayes, waiting for your keystrokes to be echoed back from the minicomputer to the terminal screen. All it's missing, really, is the amber-on-black colour scheme.) If you have a reasonably modern desktop computer (fast processor, good graphics, lots of RAM) it's great, but it's a pig on last year's laptop (no matter what the year). Aptana Studio and Zend Studio fall into the Eclipse category -- if your machine can run 'em, they're both great (although the best parts of Zend Studio cost money).
These days I find myself using Netbeans for PHP, not because it's "the best", but because it's the best
free compromise I've found between features and performance for the crappy old machines I have. DevPHP isn't bad on older machines either, but it has some horrible rendering problems if you don't use the default font (and I
hate the default font) so your cursor isn't where it appears to be, and the HTML rendering engine is more like NCSA Mosaic than a modern browser -- it takes some getting used to. If you can live with Courier (as opposed to something more readable and rational, like Lucida Console, Consolas, Proggy Clean, Droid Mono or Anonymous Pro) then DevPHP isn't a horrible choice.
