Integrated Development Environments

Software Engineering; System-Level Programming

An integrated development environment (IDE) is a computer program that brings together all of the tools needed for software development. These tools usually include a text editor for writing source code, a compiler for converting code into machine language, and a debugger to check programs for errors. The programmer writes the code, runs the code through the debugger, and then compiles it into a program.

Computers are not intelligent, even though they can process information much faster than humans. They only know what to do when a human tells them. One way of doing this is by typing instructions using the computer's command line, but this has several drawbacks. First, it requires that a human be present whenever the program has to be run. Second, typing commands into a text-based interface may be uncomfortable or even impossible for some users. They prefer to use a graphical user interface (GUI), which lets them click on icons to run applications (apps). To avoid the need to type commands, computer programmers write programs. These are sets of instructions for a computer to perform, like a recipe used for cooking. Instead of typing in dozens of commands to do each task, the user can simply run the program that contains all of the commands. The computer will follow the instructions just as a cook follows a recipe.

Programs are created using a programming language, such as Java, C++, or Python. A programming language is not as complete as a traditional language such as English or Mandarin, but it contains enough words and rules of syntax to allow programmers to create instructions, or code. Once the source code has been written, the next step is to translate it into machine language that a computer can process. An app called a “compiler” performs this translation. The compiler produces an executable version of the program. This version can be run by any user as long as it is executed on the computer platform it was designed for (such as Windows or Mac).

Programmers often use an integrated development environment (IDE) when coding. An IDE is software that makes programming easier by providing many tools within a single program and automating some simple tasks. An IDE usually includes an editor to write source code, a debugger to fix errors, and build automation tools. Many also have intelligent code completion, which autocompletes commonly used programming expressions.

The first programmers did not use IDEs. They had to create programming languages before they could even write programs. They used many separate programs, including text editors, debuggers, and compilers, to craft their software. This sometimes made the process of programming more complicated. Programmers had to learn how to use several distinct apps that had been designed separately. Thus, it took longer to learn how to use each one. The different tools sometimes conflicted or were incompatible. Tiring of this, some programmers began to develop IDEs made up of multiple programming tools, each designed to work with the others.

The first IDEs were largely text-based, because this is how programming was then done. However, programming gradually took a more visual approach, in the same way that other types of apps went from text-based interfaces to GUIs. Visual programming allows software developers to use a mouse to drag and drop pieces of code in order to design apps. This is often a much more intuitive method for designing an app and can be less time consuming than typing out lines of source code. Today, several IDEs support visual programming. Using these tools, programmers can create blocks of code in one window, then click to debug and compile the code.

The introduction of IDEs was not greeted with universal praise. Some programmers, even in the twenty-first century, view such tools as limiting their own creativity as programmers. IDEs force programs to be written in certain ways in order to comply with the environment's design. These programmers prefer to write code the old-fashioned way, even if doing so is more labor intensive and time consuming.

One consequence of the emergence of visual IDEs is that younger programmers may never be exposed to the text-based development tools that their predecessors made and used. These contemporary programmers learn in visual environments where there is less need for memorizing programming commands. Veteran programmers have suggested that this is not necessarily a good thing. Not every app or programming task lends itself to visual development, they argue, so programmers should be able to use text-based development tools as well as visual ones.

—Scott Zimmer, JD