Integrated development environment

From IDE Collections
Jump to: navigation, search
This page contains changes which are not marked for translation.

Other languages:
English • ‎日本語

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.

Historical perspective

1950s: no computational support

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.

1960s: birth of IDE

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.

1970s: text-based IDE for professionals

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[1], 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.

1980s: focus on end-users

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[2], are readily available. It is more difficult to find work discussing the design of development environments; however, some examples will be covered later[3][4].

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[5].

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[6]; however, text-based IDEs remain the primary means of programming for most professional programmers.

1990s: facing complexity of application development

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[7] to programming. He pointed out difficulties in understanding the dynamic behavior of a program from the static text-based source code[8]. 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.

2000s: towards natural programming

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[9], which was initiated by Myers and colleagues in 1998. Their previous work highlighted usability issues for novice programmers in programming language design[3], 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[4] and discussed the gulf of execution and evaluation, which develops some of Lieberman's ideas[8]. Various technical contributions were made following the study.

Three factors made the proliferation of such ideas feasible.

  1. The Internet has enabled new ways of collaboration between programmers, and given rise to the remarkable growth in open-source technologies. This work includes collecting, analyzing and utilizing anonymized usage data of IDEs to identify areas for improvements and provide targeted support for cooperative work through the Internet.
  2. The variety of programs has continued to evolve, and has done so at an ever-increasing rate, with growing emphasis on physical interaction, including interactive camera applications and robotics applications. The development of such programs requires tool support, and enhancements to IDEs.
  3. Several technological shifts have made IDEs more extensible, including extension frameworks, open-source distribution of IDEs, and instrumentation features of programming languages, such as application programming interface for reflection. They allowed the programmer to concentrate on the improvements and leave the rest as provided by the existing IDEs.

References

  1. David R. Barstow, Howard E. Shrobe, Erik Sandewall, Stephen W. Smoliar. Interactive programming environments
    Vol. 9, ACM, New York, NY, USA, July 1984. [URL] [BibTeX]
  2. C. A. R. Hoare. Hints on Programming Language Design
    Programming Languages, pp.31-40, 1983. [URL] [BibTeX]
  3. 3.0 3.1 John F. Pane, Brad A. Myers. Usability issues in the design of novice programming systems
    1996. [BibTeX]
  4. 4.0 4.1 Andrew J. Ko, Brad A. Myers, Htet Htet Aung. Six Learning Barriers in End-User Programming Systems
    Proceedings of the 2004 IEEE Symposium on Visual Languages and Human-Centric Computing, pp.199-206, 2004. [BibTeX]
  5. Brad A. Myers. Visual programming, programming by example, and program visualization: a taxonomy
    Proceedings of the SIGCHI Conference on Human Factors in Computing Systems, pp.59-66, New York, NY, USA, 1986. [URL] [BibTeX]
  6. Brad A. Myers, Scott E. Hudson, Randy Pausch. Past, present, and future of user interface software tools
    ACM Transactions on Computer-Human Interaction (TOCHI), 7(1):3-28, New York, NY, USA, March 2000. [URL] [BibTeX]
  7. Donald A. Norman, Stephen W. Draper. User Centered System Design; New Perspectives on Human-Computer Interaction
    L. Erlbaum Associates Inc., Hillsdale, NJ, USA, 1986. [URL] [BibTeX]
  8. 8.0 8.1 Henry Lieberman, Christopher Fry. Bridging the gulf between code and behavior in programming
    Proceedings of the SIGCHI Conference on Human Factors in Computing Systems, pp.480-486, New York, NY, USA, 1995. [URL] [BibTeX]
  9. Brad A. Myers, John F. Pane, Andy Ko. Natural programming languages and environments
    Communications of the ACM, 47(9):47-52, New York, NY, USA, September 2004. [URL] [BibTeX]