An integrated development environment (IDE) is an environment equipped with a set of interactive user interfaces with which the programmer can write, execute, and debug a program. It contains programming languages, compilers, debuggers, toolkits and other tools that may be used for programming. The environment supports the entire workflow of programming activity, while general tools for programming usually covers a subset of programming activities.
This page provides a historical perspective on the evolution of IDEs. For the list of academic conferences related to IDE research, see Category:Academic conferences. For the list of implementations of IDEs whose descriptions are available, see Category:Integrated development environments.
In the early days of computer programming, there were very few interactive user interfaces. The programmer used punched cards to write machine code to provide commands to the computer. Punching cards was a physical task, and there was no computational support.
The first IDE is commonly said to be Dartmouth BASIC, which was developed in 1964, after character-based user interfaces and high-level text-based programming languages had appeared. It was equipped with a text-based editor, as well as a compiler, which could compile and run a program within the environment. At this time, computers were not personal, rather shared by a number of users in a similar manner to the way in which supercomputers are used today. Dartmouth BASIC was an environment for the Dartmouth Time Sharing System (DTSS), and everyone using this system was a professional programmer.
Much of the pioneering work on the interactive features that are widely considered to be essential prerequisites for modern IDEs was carried out in the 1970s, and details of this work can be found in the book Interactive Programming Environments<ref> David R. Barstow, Howard E. Shrobe, Erik Sandewall,
Stephen W. Smoliar. Interactive programming environments
</ref>, including the appearance of integrated debuggers, program analysis tools and structured editors. Providing a more interactive develop environment was thought to be important for productivity. For instance, Interlisp, an IDE with a built-in debugger and analysis tools, was actively developed from 1967 into the 1970s at Xerox PARC. The Cornell Program Synthesizer and MENTOR were IDEs equipped with structured editors for the PL/I and Pascal programming languages, respectively.
In the 1980s, human factors in programming began to receive greater attention. This followed IBM's introduction of the IBM Personal Computer in 1981, as the number of novice programmers and end-users with little knowledge of programming increased significantly. Some researchers who were interested in human factors began to focus on end-user programming and graphical user interfaces (GUIs), which can be used without prior knowledge of programming. Major forums for research into human–computer interaction (HCI) were born of this age. Forums specific to programming also appeared in the 1980. Research into software engineering and programming language design was also growing rapidly at this time. While there have been some research projects aiming to enhance text-based IDEs, this area of research has received less interest than programming language design. Design principles for text-based programming languages, such as those described in Hoare's paper<ref>
C. A. R. Hoare. Hints on Programming Language Design
</ref>, are readily available. It is more difficult to find work discussing the design of development environments; however, some examples will be covered later<ref name="pane1996usability" /><ref name="ko2004six" />.
The end-user typically uses a program as it is. Therefore, they must map their intention to existing commands, and often must repeat such commands many times. To avoid such tedium, they may wish to create, modify or extend existing programs. End-user programming is a research topic that addresses many of the difficulties that such end-users and novice programmers have with programming. We can identify two approaches: one is to make programming easier, and the other is to eliminate explicit programming completely. For instance, research into structured text editors and visual programming falls into the first category and research on programming by example falls into the second category. These are described in Category:Visual programming and Category:Programming by example. The taxonomy is explained well in Myer's survey paper<ref> Brad A. Myers. Visual programming, programming by example, and program visualization:
a taxonomy
</ref>. While visual programming languages usually come with their own graphical development environments, text-based IDEs have retained a similar look since the days of BASIC. They include a file manager, a text-based code editor, and a text-based debugger (e.g. Eclipse). There are few graphical representations. While tools for programmers have previously focused on providing supplemental features that are not supported by text-based IDEs, the text-based IDEs themselves have not significantly changed. User interface toolkits have been widely studied<ref>
Brad A. Myers, Scott E. Hudson, Randy Pausch. Past, present, and future of user interface software tools
</ref>; however, text-based IDEs remain the primary means of programming for most professional programmers.
Throughout the 1990s, programming became more complex and involved. For instance, it is not straightforward to specify a GUI using solely a text-based approach. Visual Basic 1.0 was released in 1991 and addressed this issue by integrating a graphical GUI builder into a text-based IDE. It allowed the programmer to seamlessly move between the interface design and implementing functionality. In 1995, Lieberman applied the famous concept of Norman's gulf of execution and evaluation<ref>
Donald A. Norman, Stephen W. Draper. User Centered System Design; New Perspectives on Human-Computer Interaction
</ref> to programming. He pointed out difficulties in understanding the dynamic behavior of a program from the static text-based source code<ref name="lieberman1995bridge">
Henry Lieberman, Christopher Fry. Bridging the gulf between code and behavior in programming
</ref>. To address this issue, he proposed a visual debugger named ZStep, integrated with a text-based IDE which shows the programmer the relationship between an expression in the source code and its output at runtime.
In the 2000s, many enhancements to text-based IDEs appeared. One of the most prominent projects in the enhancement of text-based IDEs is the Natural Programming project<ref>
Brad A. Myers, John F. Pane, Andy Ko. Natural programming languages and environments
</ref>, which was initiated by Myers and colleagues in 1998. Their previous work highlighted usability issues for novice programmers in programming language design<ref name="pane1996usability">
John F. Pane, Brad A. Myers. Usability issues in the design of novice programming systems
</ref>, and the Natural Programming project places more emphasis on the IDE and accompanying libraries. Their work takes a human-centered approach: they first investigate the programmer's behavior and then address the difficulties. For instance, they studied six learning barriers in end-user programming systems<ref name="ko2004six">
Andrew J. Ko, Brad A. Myers, Htet Htet Aung. Six Learning Barriers in End-User Programming Systems
</ref> and discussed the gulf of execution and evaluation, which develops some of Lieberman's ideas<ref name="lieberman1995bridge" />. Various technical contributions were made following the study.
Three factors made the proliferation of such ideas feasible.