Structure Editor Research Articles

From Programming by Demonstration to Programming by WYSIWYG

Programming by demonstration (PBD) promises to enable non-programmers to do more with their computers. However, PBD systems today are either limited to very narrow application domains, or are not reliable enough concerning the correctness of generated programs. We examine the reasons for this gap between generality and reliability and present a proposal for bridging it, thus leading to a design methodology for general-purpose PBD systems. This is achieved by supporting the visual scanning abilities of humans by a diligently designed user interface, immediate feedback, and ‘trial & error demonstration’. Furthermore, we discuss experiences with a prototype system named Visual AWK implementing the new concept. It enables end-users to create rather complex text-processing programs in a structure editor and thus automates repetitive tasks as they encounter them in their work.

A framework for product data

IT support for engineering involves the integration of existing, evolving and future product data, and software that processes that data. Thus, there is increasing interest in the representation of product data in the computer to support CAE applications. To avoid duplication and inconsistency, and to support the use of new implementation technology as it emerges, conceptual models of product data are required. Such models are independent of the software and hardware environments in which they are implemented. System architectures to support the integration of applications at implementation time are becoming an accepted part of engineering information systems. To use these software support environments effectively, integrated product data is required. It must also be possible to extend the integrated product data in a controlled fashion if it is to evolve to support future engineering applications effectively. A framework that is a part of the product data at the conceptual modeling stage helps to satisfy these requirements. The framework presented is a structure for the information content of product data rather than for the implementation of such data. Product data based on the framework can be successfully implemented in a number of different database forms. This paper describes a framework for electromechanical product data that has been implemented in a structure editor and is being used to support a range of engineering applications. The process of product data integration can be improved by using existing integration strategies together with a framework that provides an overall organization for the data.

TRENDS IN STRUCTURE-ORIENTED ENVIRONMENTS

The term Structure Editor (structured environment, structure-oriented environment) is widely used and has been defined, and redefined, many times since the first recognised structure editor, Emily [51]. This paper follows the trends in this field over the last decade in the following areas: environment parameters, environment architectures, tools and the uses of environments, textual manipulation, internal (structure) representation, conceptual programming with its knowledge-based tools, and environment evaluation. The paper contains an historical perspective of technological events shaping this field and concludes with a unifying summary.

Evolution of Novice Programming Environments: The Structure Editors of Carnegie Mellon University

Abstract Beginning in the early 1980s, the Computer Science Department at Carnegie Mellon University developed and used three generations of novice programming environments. The focus of these systems was to apply, advance and tune structure editor technology in support of the teaching and learning of computer programming. The use of these pedagogical systems in Carnegie Mellon's introductory programming courses provided feedback and inspiration to guide the projects. This paper tracks the evolution of the programming environments and courses, documenting important lessons and discoveries about novice programmers and the environments that support them.

ICAF '91 Tokyo. Aeronautical Fatigue Key to Safety and Structural Integrity Editor:A. Kobayashi, Ryoin Co., Ltd. and Engineering Materials Advisory Services Ltd. 1991

Materialwissenschaft und WerkstofftechnikVolume 23, Issue 12 p. 419-419 Buchbesprechung ICAF '91 Tokyo. Aeronautical Fatigue Key to Safety and Structural Integrity Editor: A. Kobayashi, Ryoin Co., Ltd. and Engineering Materials Advisory Services Ltd. 1991 W. Schütz, W. SchützSearch for more papers by this author W. Schütz, W. SchützSearch for more papers by this author First published: Dezember 1992 https://doi.org/10.1002/mawe.19920231206AboutPDF ToolsRequest permissionExport citationAdd to favoritesTrack citation ShareShare Give accessShare full text accessShare full-text accessPlease review our Terms and Conditions of Use and check box below to share full-text version of article.I have read and accept the Wiley Online Library Terms and Conditions of UseShareable LinkUse the link below to share a full-text version of this article with your friends and colleagues. Learn more.Copy URL Share a linkShare onFacebookTwitterLinkedInRedditWechat No abstract is available for this article. Volume23, Issue12Dezember 1992Pages 419-419 RelatedInformation

Automated customization of structure editors

A common method of developing structure editors is by generating them using an environment generation tool, such as Gandalf or the Synthesizer Generator. One weakness of this approach is that the user interfaces to the generated structure editors tend to be difficult to customize to individual languages and users. Customization is typically left to the user with macros and mode settings. An alternative described in this paper is automated customization. To support automated customization, the system must determine what customizations to perform, when to perform them, and how to evaluate them without user intervention. This paper reports on mechanisms added to the Gandalf environment generation system to support automated customization, as well as results of experimentation with these mechanisms. The major results of experimentation are the following. Automated customization resulted in a 7% decrease in the number of commands required to complete a task, and up to 25% reduction in the number of errors encountered. In addition the evaluation mechanism performed well, correctly evaluating 95% of the automated actions.

Generating structure editor interfaces for OR procedures

The quest for OR interface development tools that are both flexible (in terms of interfaces produced) and high-level (in terms of developer specification accepted) is based on work in the DSS and UIMS fields. The DSS literature offers a foundation for understanding possible relationships between OR procedures, the data they can use, and the problem statements that cause their executions. The UIMS literature offers mechanisms for interface production. Of these, structure editing has been singled out here as a candidate for advancing OR research into interface construction. The first implementation of a structure editor interface for OR problem statements is described. The result is a direct manipulation user interface that presents LP problem statement images resembling traditional forms, but which allows variants of a single form to dynamically unfold in response to a user's expansion actions.

GENIE: Developing and Assessing State-of-the-Art Integrated Programming Environments

This videotape demonstrates the functionality of Carnegie Mellon's GENIE programming environments. GENIE environment are publicly available on the Macintosh for Pascal and Richard Pattis' Karel the Robot teaching language. They are appropriate for use in introductory and intermediate computer programming methods courses at both the collegiate and secondary school levels. The Karel environment has been used successfully in group settings as early as the fourth grade.GENIE environments are built around syntax directed structure editors. [1, 2] Rather than edit only individual ASCII characters, the editors manipulate elements designated by a specific language grammar. Syntax errors are either prevented altogether or corrected immediately in context.Earlier structure editors often traded their syntax error prevention functionality for highly constrained and clumsy user interfaces. GENIE environments gracefully integrate text and structure editing, such that they have the "look and feel" of a good text editor, with the "intelligence" of a syntax directed structure editor.Through access to a common structure editor data base, GENIE environments combine many advanced tools for program design, comprehension and testing, all integrated in a single, uniform Macintosh user interface. Student program structures are maintained in "unparse" trees which can be mapped to and from text and graphics in many novel ways not constrained by a language's concrete syntax.[3] Different views of a common program database can be displayed and modified concurrently, emphasizing structure and design as well as implementation detail. [4] Similarly, arbitrary pieces of program structure can be hidden from view or displayed at will.At run time GENIE program can be traced at the level of expressions. Graphical data visualizations displaying arbitrary combinations of structured types are updated dynamically during run time and displayed in a representation of the program call stack. [5] Other notable GENIE features include an extensive contextual help system and a "notes" feature useful for project management, course assignments and "on-line" grading.User studies have been conducted at several universities and secondary schools throughout the United States. [6, 7, 8, 9] GENIE students in demanding courses have performed strikingly better than have students using other commercially available Macintosh software configurations.

Dora: a structure-oriented environment generator

This paper describes a generic structure-oriented environment that has been developed as part of the ESPRIT-funded Dragon project. The environment can be instantiated by a tool builder to provide a multiple view structure editor for a particular language or method. This environment kernel is particularly important for two reasons: the environment is composed of an interacting hierarchy of editors, each acting on appropriate components of the target structure; and for each of these ‘substructure’ editors, it is possible that the developer can specify many different views, and that these views are independent within the same editing pane.

Semantic correctness of structural editing

Typical structural editor provides for syntax correctness of an edited text. In this paper some problems are discussed that arise when the semantic analysis is to be included in the tasks of a structural editor. The solution to these problems, already implemented in Modelang editor, is presented. It is based on the concept of multistage editing operations and application of default values. Several examples are given to show how the editor should deal with basic Pascal constructs in order to preserve full semantic accuracy. Additionally, two solutions are proposed to the problem of name maintenance within the structural editor. Structural editing versus conditional compilation is also considered.

Report on the CHI'90 workshop on structure editors

Although work on structure editors has been going on for almost twenty years, the designers and users of syntax-directed editors and graphical structure editors had never met to reflect on these tools' past, present, and future. The CHI'90 Workshop on Structure Editors was organized for the purpose of examining structure editors from a human-computer interaction perspective. We also hoped to increase the intersection between the programming environment and human-computer interaction communities.

An iconic description language: programming support for data structure visualization

An icon description language, named DSIL (Data Structure Iconic Language), is described which facilitates the design of icons depicting data structures and accelerates the development of iconic interfacing tools for program visualization and debugging. By using the DSIL, different users can define or redefine their own icons to satisfy their needs. The DSIL has features of modern programming languages. It is hierarchical, modular, and provides adoption (inheritance). The design of the DSIL is based on the features of data structures in MODULA-2. The implementation of the DSIL in a data structure editor is presented.

QS-Edit 1.0: A query structure editor for the Macintosh for use with the CAS Online Registry and Beilstein databases

QS-Edit 1.0 is a query structure editor created for the Macintosh computer that provides a graphical front end to the CAS Online Registry and Beilstein databases. A query structure drawn with this program is converted to the commands needed by the CAS Online computer to interpret the query. The program has been designed to be used most conveniently with Multifinder and a terminal program. The executable program is included on disk.

The impact of structured editing on introductory computer science education: the results so far

Properly done, introductory computer science courses have great potential, both for preparing future computing professionals and for the broad goals of general education. Yet the performance all too often lags well behind the promise. Poor grades, high failure and drop out rates are all too common at both the collegiate and pre-collegiate levels. However the advent of seamless programming environments based on structure editing provides us with an opportunity to change the situation in fundamental ways. Initial studies show dramatic differences between students who do and do not use a structure editor based environment.

Centaur: the system

This paper describes the organization of the CENTAUR system and its main components. The system is a generic interactive environment. When given the formal specification of a particular programming language-including syntax and semantics — it produces a language specific environment. This resulting environment includes a structure editor, an interpreter/debugger and other tools, all of which have graphic interfaces. CENTAUR is made of three parts: a database component, that provides standardized representation and access to formal objects and their persistent storage; a logical engine that is used to execute formal specifications; an object-oriented man-machine interface that gives easy access to the system's functions. CENTAUR is essentially written in Lisp (Le_Lisp). The logical engine is Prolog (Mu-Prolog). The man-machine interface is built on top of the virtual graphics facility of Le_Lisp, itself primarily implemented on top of X-Windows.

Centaur: the system

This paper describes the organization of the CENTAUR system and its main components. The system is a generic interactive environment. When given the formal specification of a particular programming language-including syntax and semantics — it produces a language specific environment. This resulting environment includes a structure editor, an interpreter/debugger and other tools, all of which have graphic interfaces. CENTAUR is made of three parts: a database component, that provides standardized representation and access to formal objects and their persistent storage; a logical engine that is used to execute formal specifications; an object-oriented man-machine interface that gives easy access to the system's functions. CENTAUR is essentially written in Lisp (Le_Lisp). The logical engine is Prolog (Mu-Prolog). The man-machine interface is built on top of the virtual graphics facility of Le_Lisp, itself primarily implemented on top of X-Windows.

Fine tuning selection semantics in a structure editor based programming environment: some experimental results

Structure editing holds much promise for improving the quality of introductory programming education. However early structure editors have often been clumsy and counter intuitive to use. This study reports the results of a laboratory experiment in which the user interface of a structure editing environment was modified in several ways to make its semantics more closely resemble what students seem naturally to expect. Analysis suggests that it is possible to improve students' editing performance, without getting bogged down in unnecessary details of language and environmental semantics.

A retrospective on DOSE: An interpretive approach to structure editor generation

AbstractDOSE is unique among structure editor generatiors in its interpretive approach. This approach leads to very fast turn‐around time for changes and provides multi‐language facilities for no aditional effort or cost. This article compares the interpretive approach to the compilation approach of other structure editor generators. It describes some of the design and implementation decisions made and remade durign this project and the lessons learned. It emphasizes the advantages and disadvantages of DOSE with respect to other structure editing systems.

Explicit Models in Intelligent Interface Design

AI has made significant advances in the design of graphical knowledge-based interfaces. One type of knowledge-based interface, the graphical model editor, extends the "toolkit notion of interface", exemplified by Bill Budge's Pinball Constructor Set 1. In these interfaces, "the desired operations are done simply by moving the appropriate icons onto the screen and connecting them together. Connecting the icons is the equivalent of writing a program... There are no hidden operations, no syntax of command names to learn." 2) The end user can quickly, and with minimal training, build up a description of a complex structural model, run that model to observe its behavior, and then modify the structure if desired. The user of this class of interface never needs to be aware of the complexities of the internal representations that actually support the model.AI has contributed flexible tools for building these interfaces such as Impulse 3) the steamer graphics editor, 4) and KEE pictures TM5, as well as representation techniques that facilitate mapping a complex domain model onto a graphical interface. However, the class of text editors known as structure editors can also serve as a useful analogy for extending our understanding of graphical model editors.In this paper, we will first define what we mean by graphical knowledge-based structure editors and then discuss one class of structure editors, those that can be built using SimKit TM, a general tool for building model editors. We will then speculate about the specific types of knowledge typically represented in knowledge-based structure editors and the appropriate graphical metaphors for presenting that knowledge.

Graphical Knowledge-Based Structure Editors

We discuss our experience with an interface that gives users the ability to directly represent and manipulate goals at several levels of detail. The interface is built into Bridge, a tutorial environment for novice programmers [Bonar88]. The name comes from our intended "bridge" between novice and expert conceptions of programming. In order to understand student designs and partial programs, Bridge provides languages that allow a student to talk about his or her high-level designs and partial work. We call the vocabulary of these languages plans. Plans are bundles of knowledge about the standard subtasks in a domain, designed and organized based on a typical user's point of view.Many intelligent interfaces monitor low-level user actions, attempting to infer higher level plans. These inferences are typically implemented with partial matching schemes, based on a plan catalog (see, for example, [Johnson86]). The inferences allow the system to complete user actions, correct errors, or provide tutorial assistance. This approach to inference of user intentions is quite difficult. We propose a different approach, designed to more effectively and accurately capture user intentions.Our approach gives users a very high-level plan language. By "high-level" we mean a language that is informal, vague, contains much implicit information, and is designed to represent goals of interest to a particular class of users. In particular,the plan language makes assumptions about the user's background knowledge and overall intentions. This is consistent with our interest in providing interfaces to professionals and domain experts who have no programming experience. We focus on users who are experts in a particular task domain and are using a computer to extend or augment that expertise. Our system must take such a user's specification and derive an implementation using the primitives provided by a standard computer system. In the rest of the article we begin by developing a framework for approaching intelligent interfaces. In particular, we discuss the dilemma of a very high-level programming language intended for use by experts who are not programmers.