What makes up an integrated development environment?

An introduction to IDEs

Integrated development environments or IDEs are a useful tool when developing code. As the name suggests, they are a single environment which integrates many of the development tools which programmers use. This can help make programming easier and more efficient.

For example, a modern IDE will contain:

• a code editor
• a compiler or interpreter
• a debugger
• a project manager
• version control.

Let’s see each of those in a little more detail:

Code editor

This is where you can see and write your code. It’s a bit like Word or Notepad, except with some extra features which are specific to programming.

For example, most IDE editors include syntax highlighting which will automatically change the colour of code to make it easier to see what it does.

Many IDEs also have autocomplete functions which can close brackets and quotation marks, helping to make programming faster and reduce the number of mistakes which we make.

Another common feature of editors is hover-over information which allows programmers to quickly see information about the functions and classes which they are using – this makes looking up information quick and easy.

Compiler/interpreter

This is what actually runs the code – computers cannot understand most programming languages (what we call high-level languages) and needs to translate them into a low-level language which it can actually run.

Compilers create an executable file which can be run (you might be familiar with .exe files, which are used on Windows), while interpreters run code line by line without creating a separate executable file.

This feature allows programmers to run their code without having to create the file themselves, making it quicker to check that their program does what they expect.

Debugger

Sometimes, the code we write doesn’t work the way we want it to. A debugger can help programmers find their errors by doing things like setting breakpoints which allow them to stop their code in a specific place, which is often useful when trying to work out where your code is going wrong.

This also lets you step through your code, which means running it line by line. This helps to find out exactly where your code is incorrect and fix errors fast.

Debuggers also allow you to see the contents of variables while the code is running, which makes it quicker and easier to find issues.

Project manager

This tool can help you to organise your code. Many programmers work on multiple projects at once, so keeping code separate in its own window is very helpful.

This keeps your files separate from each other and may allow you to have specific settings, for example debugger or compiler settings for each project – this is very useful for people who work with more than one programming language.

Version control

This is a tool which allows you to keep track of changes which you make in your code. If you have used Google Docs or Word Online, you may have seen that you can see previous versions of your documents – this is the same idea, but for code!

This means that if you make a big mistake, you can easily roll back your code to a previous version. It is also very useful when you are working with a team, which is common for software engineers and programmers! It allows everyone to work on their own version of the code, and then merge their versions at the end.

Conclusion

This should have given you an idea of what an IDE is and some of the different components you might find in one. Overall, an IDE is a very powerful tool which can make programming quicker and easier for experienced developers.

For people who are just starting out, you might find some of these tools aren’t needed for your first few projects – and we will be looking at some more basic IDEs with simpler features.

But you might also be asking yourself – what did programmers do before IDEs become common?

In the next section, you will learn more about the basic command line tools and basic editors which programmers have been using since the dawn of modern computing in the 1970s.