Integrated development environment

From IDE Collections
Revision as of 11:37, 13 January 2014 by Jun Kato (talk | contribs) (Marked this version for translation)
Jump to navigationJump to search

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.

Historical perspective

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, and Erik Sandewall. 1984. Interactive Programming Environments. McGraw-Hill, Inc., New York, NY, USA.</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, including the ACM SIGCHI Conference on Human Factors in Computing Systems (called simply CHI since 1982) and ACM Symposium on User Interface Software and Technology (UIST, where the first workshop was held in 1982). Forums specific to programming also appeared in the 1980s, including the Workshop on Empirical Studies of Programming (1986–1999) and the IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC since 1984). Research into software engineering and programming language design was also growing rapidly at this time. The International Conference on Software Engineering (ICSE) has been the premier software engineering conference, and has been cohosted by the ACM and the IEEE since 1975. Programming language design remains an ongoing research topic, with forums including the ACM SIGPLAN conference on Programming Language Design and Implementation (PLDI), the ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL), and the ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA). 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. 1973. 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 in this subsection.

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 will be described in Visual Programming and Programming by Example. The taxonomy is explained well in Myer's survey paper on visual programming and program visualization <ref>Brad A. Myers. 1990. Taxonomies of visual programming and program visualization. Journal of Visual Languages and Computing. 1, 1 (March 1990), 97-123.</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 Myers, Scott E. Hudson, and Randy Pausch. 2000. Past, present, and future of user interface software tools. ACM Transactions on Computer-Human Interaction (TOCHI). 7, 1 (March 2000), 3-28.</ref>; however, text-based IDEs remain the primary means of programming for most professional programmers.

References

<references group=""></references>
Other languages:
English • ‎日本語