How to decide on the right IDE

Throughout the history of software development, IDEs have evolved to fit the growing demand of a developer’s need for tooling in a variety of programming languages.

With the expanding complexity of these languages, what could once be written in Visual Basic now requires the need for a bit more elbow grease. But what is so important about IDEs? Why do they exist? And why do some developers prefer certain ones over others?

First things first, what even is an IDE?

IDE stands for Integrated Development Environment and put simply, they’re applications used to help facilitate the development of other applications.

Your standard IDE usually consists of a source-code editor, allowing users to read and make changes to their code; a compiler, translating human readable code into machine code to be executed by the CPU; and a debugger, spotting coding mistakes and typos.

The beauty of an IDE is how it bundles up all of the menial tasks necessary for building and deploying applications while providing a streamlined interface. IDEs are even used for building automation tools that automate common developer tasks to save even more time.

The history of IDEs

Before IDEs hit the market, programs were essentially text documents written using simple text editors. Code was then saved as a text document and ran through a compiler. Only then could it be executed and checked for errors.

Turbo Pascal by Borland is widely believed to have pioneered tooling created to speed up the manual process of software development — though there is some dispute. Some believe Microsoft Visual Basic first introduced the idea of an IDE that combined the editor and compiler capabilities back in 1991.

Which IDE do I need?

Now that we’ve got a general idea of what an IDE actually is and a bit of the history behind them, we need to understand the mindset and decision criteria of a developer choosing which IDE to go for.

With so much choice out there, it’s important to understand that each IDE comes with unique benefits and drawbacks.

Multiple Languages?

Unless you’re building a simple .NET application over the weekend using Visual Basic, chances are you’re going to be using more than one programming language in your application (maybe JS for the bulk of the application and some SQL for the database stuff).

Fortunately, most IDEs these days come equipped to deal with multiple languages out of the box, and in fact provide a plethora of open-source plugins that can be installed to support different needs. In the case of SQL debugging, VSCode offers the ‘MySQL’ plugin that allows developers to remotely debug stored procedures, and Toad for Oracle is a multipurpose tool for almost any type of database.

Syntax Highlighting?

Syntax highlighting is another big factor. It’s a cause for contention amongst the dev community, there are those that love it and others that hate it with the burning passion of a thousand suns. That said, it is a staple feature across all IDEs and can simply be toggled on or off.

Despite this however, not all IDEs are able to detect languages correctly. Take working on a simple Web application as an example, pretty early on you’ll be adding HTML intermixed in with some source code. You’ll want to set the language for the file type extension if your IDE doesn’t do that for you, but you have more than one language; so handling the syntax highlighting for those languages may require some extra tooling (try Handlebars 😉).

Out-of-the-box Compiler?

Moving on to what some consider the true distinction between an IDE and a text editor — the ability to compile code straight from the development tool.

To be frank, there aren’t actually that many IDEs that compile codes themselves. Most of them simply spawn an instance of the compiler as a separate process. These days though, this process is so consolidated with the rest of the IDE that it doesn’t feel disconnected.

Visual Studio, one of the most popular open-source IDEs available, technically has separate tooling. However, these compilers are so tightly knit that it feels like VS is doing the compilation on its own.

For example, when developing in C++, Visual studio will rely on command-line tools. Most Linux distributions have the GNU Compiler Collection (GCC) installed and macOS users can get the Clang tools with Xcode to deal with its compilation.

Class Browsers?

A lot of IDEs include a window that lets you easily navigate throughout your code using a code or class browser. This allows you to show your class and, under that, its member functions and member variables. Clicking on the member takes you to the code directly. Some developers find this feature useful. Others, not so much.

IntelliJ (Jetbrains) and Visual Studio Code are examples of IDEs that provide great class-browsing support. It’s a feature that I find helpful when working on code written by a colleague where I want to get a quick snapshot at a glance of the class members without having to scroll through the file.

Autocomplete?

These days, pretty much any IDE has the ability to do some sort of autocomplete, but some are more sophisticated than others.

Often referred to as Intelligent code completion, autocomplete features speed up the process of coding and serve as documentation and disambiguation for variable names, functions and methods.

Take Visual Studio as an example again. This IDE is completely aware of the variables in your code. Typing a variable name followed by a dot will display a picklist of the related member variables and functions, on top of this VS corrects the casing of variables further helping to avoid those pesky typos.

Do you even need an IDE?

This day and age you have IDEs that can do just about anything you want them to, but at some point a developer must sit back and realise that ultimately the crux of software development is in writing code. All these cool (and sometimes novel) bells and whistles are great, but can they get too much, and do they just get in the way.

Reflecting back on the aforementioned questions should help point you in the right direction, and with a bit of experimenting with various text editors, IDEs, configs, and plugins; you’ll find yourself making use of the many benefits that today’s IDEs can offer.