What is an integrated development environment (IDE)?

While not strictly essential for software development, as code can be written with any text editor and executed from the command line, IDEs combine features that enhance developer productivity and code quality. Modern IDEs often include the necessary compiler, interpreter or both, depending on the specific coding language. 

Other common IDE features include the features listed here:

• Version control system: Version control is an integral part of modern software engineering and is used to control, organize and track different versions of code. Version control systems help developers monitor code changes and updates while documenting the code history. Although stand-alone options like Git are widely used, many IDEs also offer potentially compatible built-in options. 

• Class browsers: Class browsers enable programmers to browse, explore or visualize the structure of object-oriented programming code. 

• Object browsers: Object browsers allow programmers to examine software packages by component. They can display component hierarchy, properties and events associated with individual objects. 

• Class hierarchy diagram: Essential for software engineering based on object-oriented programming, IDEs can provide class hierarchy diagrams. These static diagrams describe the overarching system structure by object class, including their attributes, operations and relationships among other objects.

While some basic features are considered standard across IDEs, there is no set list of baseline functions for software to qualify as an IDE. That said, most IDEs are likely to contain some degree of most (or all) of tools, features and functions such as these:

• Code editing automation: IDEs offer various automations to help edit and correct various types of programming code. Because different programming languages follow different rules, IDEs can identify and help correct when developers make syntax errors or otherwise deviate from the correct language structure. 

• Smart code autocompletion: IDEs often feature automated tools (similar to autocomplete or search suggestions) to help programmers write code by suggesting common phrases or terms based on recognized code functions or intentions. 

• Syntax highlighting: IDEs can automatically format written code, changing font colors and bolding or italicizing certain words, phrases or symbols. Syntax highlighting can provide immediate feedback on potential syntax errors. This IDE feature makes source code more legible for programmers to review their work.

• Refactoring support: Code refactoring is the process in which effective source code is refined, restructured or rewritten to not just deliver the intended function, but also conform to established principles of simplicity. Sufficiently refactored code is both more efficient and more readable, maintaining the intended function with just the essential scripting. Refactoring is considered an integral part of high-level software design, even though the process can be tedious. In certain scenarios, IDEs help developers improve their code by automatically refactoring source code more quickly.

• Local build automation: IDEs can automate several repetitive development tasks that typically accompany code editing, such as updating previously written lines of code to reflect new changes.

• Compilation and interpretation: Most programmers write in high-level programming languages because they are more human-readable and therefore easier to work with. However, before software can run, it must be translated into a low-level machine language that an operating system, such as Linux or Windows, can understand. Compilers and interpreters are types of software that automate the translation process depending on the language-specific original source code. While compilers and interpreters are both often found as stand-alone pieces of software, many modern IDEs offer built-in compiling and interpreting functions. 

• Testing: Before integrating new source code with existing developer code, IDEs offer developers tools to automate local unit testing. This initial process provides a first round of quality control before testing code in more complex production environments.

• Debugging: The term bug applies as a catchall for a wide range of potential errors that can be found in uncorrected code. While some bugs can manifest as simple typographical or syntactical errors, any code that prevents the intended software function from operating as intended can be considered a bug. The debugging process involves many levels of code review and testing to verify that the code functions as intended in all circumstances. Although IDEs often do not offer fully integrated code debugging, they frequently provide a range of debugging tools. These tools help eliminate as many bugs as possible, often in real time as code is being scripted. One way IDEs support the debugging process is by highlighting code as it runs, line by line, helping developers inspect the code and validate its behavior. 

• Code linting and analysis: Real-time code analysis provides instant feedback, similar to automatic spelling and grammar checkers in common text editors. These tools can go beyond detecting simple typographical errors and help identify a wide range of potential issues. These issues include style violations that can hinder code readability and maintenance, possible bugs, inefficient language patterns and critical security vulnerabilities.

Compared to a standard text editor, working within an integrated development environment (IDE) during application development offers programmers a wide range of conveniences and benefits. IDEs help streamline the entire development process, making it easier for developers to write and debug code and collaborate with project managers and extended teams.

Benefits associated with IDE functions include: 

To meet developer needs, integrated development environments (IDEs) come in a wide range of varieties—from open source to proprietary, beginner-friendly to more complex. Many IDEs offer cross-platform support, while some are more language-dependent. There are some of the most popular types of IDE.

Local IDEs are installed and run locally on a developer's personal or work hardware. These IDEs require extra resource libraries, which developers must download and install locally based on project requirements and personal preferences.

Local IDEs are more customizable, benefit from almost no latency issues and can operate fully even without an active internet connection after setup is complete. However, setting up and configuring a local IDE can be cumbersome, and differences between the local machine and the production environment can lead to unintended software bugs or failures.

Local IDEs are also local hardware-dependent. Relying on a machine's local memory resources, local hardware can struggle to run a local IDE, especially when working with large amounts of complex code.  

Examples of local IDEs include:

• Microsoft Visual Studio

• Eclipse

• JetBrains IDEs like IntelliJ IDEA and PyCharm

Unlike local IDEs, cloud IDEs are browser-based and don’t require developers to download any specific software or libraries to their local hardware. This requirement is contingent on maintaining a strong internet connection to access the cloud effectively.

Compared to local IDEs, cloud-based IDEs come with several advantages. Teams working with cloud-based IDEs can create a standardized development environment, avoiding errors that can arise from varying local hardware configuration differences.

Cloud IDEs can also offer better performance than local IDEs by using cloud-based resources. Certain complex IDE functions often demand significant computational resources. To prevent slowdowns with local IDEs, developers can offload those tasks to robust cloud-based data centers.

Examples of cloud IDEs include:

• AWS Cloud9

• Replit

• CodeSandbox

These types of IDEs are designed specifically for mobile application development. Mobile app development IDEs typically feature mobile technology-specific libraries and exclusive features like emulator support. 

Examples of mobile app development IDEs include:

• Flutter IDE plug-ins for VS code, IntelliJ and others

• Android Studio for Android development

• Xcode for Apple devices, iOS app development, macOS, watchOS and tvOS development

Programming for databases comes with its own set of distinct considerations. These types of IDEs are built with database development in mind, with special features like built-in query builders and database analysis tools. 

Examples of database-specific IDEs include:

• MySQL workbench

• Oracle SQL developer

• pgAdmin

While many IDEs do offer multilanguage support, some are designed to accommodate the particular parameters of certain programming languages. Similarly, other IDEs are specialized depending on a project's purpose. Some examples of language or project-specific IDEs include the IDEs outlined here: 

Java™

• IntelliJ IDEA: A robust IDE designed to support Java, with advanced refactoring, code analysis and build automation. 

• Eclipse: A versatile open source IDE benefiting from a large plug-in ecosystem available on public repositories like GitHub. 

• NetBeans: A popular open source IDE option available for free.

Python

• PyCharm: Offering scientific computing support, this IDE offers many features useful for coding in Python. 

• Spyder: Another IDE designed for data science and scientific computing is the Python language. 

• IDLE: This relatively simple IDE is well suited for beginners learning the Python language. 

Web development

• Visual Studio Code: Lightweight and intuitive, this IDE has become a trusted environment for coders working in web dev.

• WebStorm: A specialized IDE designed for programmers working with JavaScript, TypeScript and similar technologies.