Main image of article Choosing an IDE That's Right for You

Today's software development often requires working with multiple tools in a variety of languages. The complexity can give even the most skilled developer a nasty headache, which is why many try to rely on Integrated Development Environments (IDEs) to accomplish most of the work; in addition to source-code editors and automation, some even feature intelligent code completion. Some developers want to do all their development work within a single tool such as Visual Studio, and never leave it except to debug the application. Others are perfectly comfortable using a bare-bones text editor such as vi, leaving the editor periodically to run make and other command-line development tools. Still others, such as myself, like having a text editor that's advanced enough to provide syntax highlighting and tabs for multiple files, while using the command line for building. Check out the latest developer jobs. With so much choice out there, it’s hard to settle on an IDE, so we’re going to look at a few. While it wouldn't be feasible to list and analyze every platform (there are hundreds available), we did interview several developers, who collectively offered up a list of useful questions to ask when evaluating a particular IDE for use:

Do You Need to Code in Multiple Languages?

Unless you're writing a simple desktop app in Visual Basic for your friends to use, you're likely going to use more than one language (such as one language for the main code, and then SQL for the database work) when building something. Fortunately, many multiple-language IDEs include all the bells and whistles a developer needs for building apps. If you need full SQL debugging, for example, there are multiple options; MySQL provides a plugin for Visual Studio that allows developers to remotely debug stored procedures. Toad is another option. But even with multiple-language support, no IDE can fully cover all developer needs; at some point, you’ll need to rely on something not included in the IDE’s specs. Just something to keep in mind as you choose which IDE you'll use.

Do You Need Syntax Highlighting?

Some people love syntax highlighting; others hate it with the fiery passion of a thousand suns. These days, syntax highlighting is pretty much standard across all IDEs and editors, and can be easily turned off if you don't want it. However, not all IDEs detect languages correctly. I find this especially true when I'm writing HTML code with source code intermixed, particularly when using a templating language with Node. Although the IDE might not immediately recognize the filename extension (such as hbs for Handlebars), you'll want to be able to set the language for the file type. In the case of Web development, you'll often have three languages in one file, such as PHP, HTML, and JavaScript; if you do, and you need syntax highlighting, you'll want to make sure that the tool can handle all three at once.

Do You Need In-Product Compilation?

For some people, the true distinction between an IDE and a plain text editor is the ability to compile your code right inside the tool. Realistically speaking, though, few IDEs actually perform compilation themselves, instead spawning the compilers as separate processes. Many IDEs provide such tight integration with the compilers that you never have to open up a command prompt to do the compilation. Visual Studio is an example of a tool that technically spawns separate tools to perform its compilation, but those compilation tools are so closely integrated that it feels like Visual Studio is doing the compilation itself. While you can technically set up Visual Studio to call make files, doing so isn't the easiest, and it quickly becomes clear that this really isn’t Visual Studio’s strong point; Visual Studio simply prefers its own project configuration files. (Because of that, if you're developing in languages Visual Studio wasn't built for, most likely you'll be unhappy trying to use it.) Eclipse, on the other hand, makes it easy to interface with different build tools, such as make, gradle, or any number of others, allowing for a full in-product compilation experience (even though, as with Visual Studio, Eclipse still technically isn't doing the compilation for you). Realistically, most command-line tools aren't that difficult to use. Although there are some massive make files and make configuration files out there, it's not hard to throw together a quick make file. If you want to excel in software development, use the in-product compilation if you want to, but learn how to use command-line build tools, as well. One last point here: source code control. IDEs such as Visual Studio, Eclipse, and many others include addins that allow you to check out files, make changes, check in files, and so on right from the editor itself. Nonetheless, take the time to learn command line tools; you'll be much happier later on, especially when you aren't turned down for a job simply because you said you don't know how to check out a git branch from the command line.

Do You Need Extensibility?

There are different kinds of extensibility, including macros and add-ins. Do you need to write simple macros to automate small tasks? Or do you need to use and/or build sophisticated extensions to the IDE itself? Microsoft recently got rid of its macro support in Visual Studio, much to the chagrin of many developers, but it still allows addins, which are compiled extensions to the tool. Eclipse has always been at the forefront of extensibility, creating a massive community that has taken the platform in hundreds of different directions, resulting in an IDE that includes support for virtually all of the most popular languages. The open-source Geany IDE provides a nice model for building plugins, and there are dozens of plugins available.

Do You Need Debugging Built Into the IDE?

Knowing how to use a good debugger is vital to being a successful software developer. This is one area you can't skimp on. Today, pretty much every IDE provides decent debugging. But there's a caveat: Things get a little tricky when dealing with some forms of client-server debugging, such as Web debugging; you might end up running two debuggers simultaneously, one in the IDE for your server-side code, and one in the debugger for client-side code. Depending on the IDE, debugging via a tablet can also be a problem.

Do You Need Drag-and-Drop Layout for GUIs? What About Code Generators?

This is where your options start to become limited. Not every IDE includes drag-and-drop GUI builders, but there are some really nice options if you need them. MySQL Workbench, while a standalone product, is quite nice for designing databases and tables without having to code directly in SQL. Both Visual Studio and Eclipse have some sophisticated tools for designing databases. And if you're doing C# or VB.NET development, then Visual Studio provides its form builders. Although these designer tools are certainly helpful, you'll still want to learn the language that the tool is generating for you. (With a quick caveat within a caveat: Desktop development with C# and VB.NET revolves heavily around the designers, and it's hard to escape that, and probably not worth trying to.) With languages such as SQL, dragging and dropping a table and picking and choosing its fields is great for generating large amounts of create table commands; but you'll still want to know how to create table syntax itself. Why? Because otherwise you're limiting what you can do; the generated SQL shouldn't be a foreign language to you, and you don't want to be turned down for a job because of it.

Do You Need Class Browsers?

A lot of IDEs include a window that lets you easily navigate throughout your code using a code or class browser. The window will show your class, and under that, its member functions and member variables. You can click on the member in order to be taken to the code directly. Some developers find this feature important; others don't.

Do You Need Autocomplete?

These days, nearly all IDEs that are worth anything have some form of autocomplete. Visual Studio's autocomplete with C# is an example of one of the best. Visual Studio is totally aware of all the variables in your code; when you type a variable name followed by a dot, you'll see a popup list of the member variables and functions available for the variable. Further, Visual Studio will correct the casing of your variables. Other IDEs and editors have autocomplete, but some aren't as sophisticated; Geany has a vague awareness of the identifiers in your project, and will make suggestions in a popup list, but is nowhere near as complete as Visual Studio. (For many of us, that's not a problem at all; although the autocomplete in Visual Studio is certainly nice, I happen to personally like Geany's overall tools, and make do without the advanced autocomplete.)

Do You Really Need an IDE at All?

Products such as Visual Studio try to be everything including the kitchen sink, but there's a point when a developer starts to realize that ultimately software development is primarily about writing code. The bells and whistles of the IDEs are great, but some developers simply feel they get in the way. It's hard to beat a good, strong editor that lets you easily navigate through your files and code. I personally love the editor called SciTE; it's free and open source, too. If you’re willing to pay money, there are some premium editors that are fantastic and well within most budgets: Sublime Text is an example of one that's really taken the programming world by storm. Then there are online editors that work in the Web browser; one of my favorites there is the Cloud 9 IDE. The prevalence of editors means that developers don’t need to rely on do-everything IDEs. Visual Studio will likely be here for a long time; Eclipse seems like it's been around forever. But when you go to smaller, newer developer shops, you're seeing a lot more standalone editors and command-line tools. Maybe you don't need an IDE at all; instead, you might just need a good editor, and to master the command-line tools for the languages you use.

The List

As I mentioned, there are lots of IDEs out there, with more coming regularly. Begin by tallying up the languages in which you work on a regular basis, factor in the “side languages” you use more infrequently, and then go from there. Wikipedia offers a comprehensive list of IDEs, for those in the midst of exploring. Again, ask yourself the important question of whether you truly need a full IDE. If you're doing C# code, then you'll likely need Visual Studio and won't want to go the editor-only route. If you're doing Web development in PHP, you might not want an editor at all, as a lot of Web developers prefer standalone editors. When evaluating an IDE, ask the questions we've presented here; then look at the different options. And yet again, learn the command line tools. IDEs can prove insanely useful, but don’t let them become a crutch.