Experiences with an environment generation system
01 May 1991-pp 219-224
TL;DR: The authors report on research experience using the Gandalf environment generation system as a prototyping vehicle for the Inscape environment, which included experimentation, incremental evolution, multiple views, the coupling of semantic and editing actions, and the use of domain-specific facilities.
Abstract: The authors report on research experience using the Gandalf environment generation system as a prototyping vehicle for the Inscape environment. A Gandalf-based environment consists of four parts: a structure editor kernel, which is simply linked into each executable, a set of grammar tables describing the language to the kernel in terms of its abstract syntax, one or more concrete syntax views, and a collection of action routines written in the extension language, ARL. Positive aspects of the research included experimentation, incremental evolution, multiple views, the coupling of semantic and editing actions, and the use of domain-specific facilities. Negative aspects consisted primarily of problems with presentation and object management. >
Citations
More filters
Proceedings Article•
22 May 1999TL;DR: The motivation for Inscape came from the experience of building software systems where I had to use components built by other people: the pieces often did not fit when I put them together and changing code often produced surprising and unexpected results.
Abstract: The motivation for Inscape came from my experience as a programmer, designer and architect There were two major (and inter-related) problems that I encountered while building software systems where I had to use components built by other people: the pieces often did not fit when I put them together and changing code often produced surprising and unexpected results The first problem was due primarily to the informality and often incompleteness of component interfaces The second problem was due ultimately to the complexity of the software and an inability to foresee or determine the consequences of changes These problems result from three essential and intertwined properties of building software systems: composition, evolution and complexity In coming to grips with the problem of composition, using formal interface specifications is the obvious choice Enhancing the syntactic interfaces with semantic information is one way of expressing the intent of the interface provider and enabling the user to have all the information necessary to its correct and effective use How to attack the problem of evolution is not as obvious The approach I took in the Inscape experiment was to use the specifications constructively in order to determine and maintain semantic dependencies Keeping track semantically as to how the interfaces are used is the analog of expressing the interface creator's intent: it is capturing the users intent Given that both interfaces and implementations evolve, keeping track of the dependencies enables the environment to help in understanding the effects of changes and where those effects take place
7 citations
16 May 1999
TL;DR: The first problem was due primarily to the informality and often incompleteness of component interfaces and an inability to foresee or determine the consequences of changes.
Abstract: The first problem was due primarily to the informality and often incompleteness of component interfaces. The second problem .was due ultimately to the complexity of the software and an inability to foresee or determine the consequences of changes. These problems result from three essential [l] and intertwined properties of building software systems: composition, evolution [2] [‘i’] and complexity [5].
6 citations
References
More filters
TL;DR: Gandalf environments integrate programming and system development, permitting interactions not available in traditional environments, and the structure and function of several existing environments are covered.
Abstract: Different programming projects require different environments, but handcrafting a separate environment for each project is not economically feasible. Gandalf solves this problem by permitting environment designers to generate families of software development environments semiautomatically without excessive cost. Environments generated using Gandalf address programming environments, which help ease the programming process, as well as system development environments, which reduce the degree to which a software project is dependent on the good will of its members. Gandalf environments integrate programming and system development, permitting interactions not available in traditional environments. The paper covers the basic characteristics of Gandalf environments. The method used to generate these environments, the structure and function of several existing environments, and ongoing research on the project.
331 citations
"Experiences with an environment gen..." refers methods in this paper
...This paper is about our experiences using a generation facility, specifically the Gandalf system [1], as a prototyping technique for the Inscape Environment [2]....
[...]
15 May 1989
TL;DR: The problems that Inscapo addresses, the research strategies and approaches to solving these problems, and the contributions of the Inscape Environment are discussed.
Abstract: The lnscape Environment is an integrated software development enviroment for building large software systems by large groups of developers. It provides tools that are knowledgeable about the process of system construction and evolution and that work in symbiosis with the system builders and evolvers. These tools are integrated around the constructive use of formal module interface specifications. We first discuss the problems that Inscapo addresses, outline our research strategies and approaches to solving these problems, and summarize the contributions of the Inscape Environment. We then discuss the major aspects of the Inscape Environment: the specification language, system construction, system evolution, use and reuse, and validation, We illustrate these various components with examples and discussions.
163 citations
20 Sep 1993
TL;DR: The purpose of Inquire, the browser and predicate-based search mechanism, is to aid both the environment and the user in the search for the components that will provide the desired predicates that are required to build and evolve an implementation correctly.
Abstract: There are four fundamental aspects of use and reuse in building systems from components: conceptualization, retrieval, selection and correct use. The most important barrier to use and reuse is that of conceptualization. The Inscape environment is a specification-based software development environment integrated by the constructive use of formal interface specifications. The purpose of the formal interface specifications and the semantic interconnections is to make explicit the invisible semantic dependencies that result in conventionally-built systems. The important ingredient provided by Inquire in conceptualization, retrieval, selection and use is the set of predicates that describe the semantics of the elements in the interface. These predicates define the abstractions that are germane to the module interface and describe the properties of data objects and the assumptions and results of operations in a module. Use and reuse of components is based on a component's ability to provide needed semantics at a particular point in a system. It is the purpose of Inquire, the browser and predicate-based search mechanism, to aid both the environment and the user in the search for the components that will provide the desired predicates that are required to build and evolve an implementation correctly. >
40 citations
01 Sep 1986
TL;DR: SMILE presents a ‘fileless environment’, derives and transforms data to shelter users from entering redundant information, automatically invokes programming tools, and actively participates in the software development and maintenance process.
Abstract: SMILE is a multi-user software engineering environment that behaves as an intelligent assistant. SMILE presents a ‘fileless environment’, derives and transforms data to shelter users from entering redundant information, automatically invokes programming tools, and actively participates in the software development and maintenance process. Unlike other intelligent assistants, SMILE is not a rule-based environment: its knowledge of software objects and the programming process is hardcoded into the environment. We describe S MILE’s functionality and explain how we achieved this functionality without reliance on artificial intelligence technology.
39 citations
"Experiences with an environment gen..." refers background in this paper
...These divide into three general classes: dealing with the on-screen presentation of information to the user; dealing with the Gandalf’s management of its data objects containing the program, the specifications, and other information; and dealing with the the lack of appropriate support tools in the underlying environment (Smile [8])....
[...]
TL;DR: This discussion presents how Inscape uses operation specifications (based on Hoare's input/output predicate approach) as the basis for synthesizing the interfaces for such complex languages statements as sequence, selection and iteration.
Abstract: The Inscape Environment research project addresses issues in supporting the development of large systems by large numbers of programmers. One aspect of this research is the “constructive use” of formal module interface specifications - that is, given that you have formal specifications, what can you do with them. In Inscape, the specifications form the basis for providing an environment that is knowledgeable about the process of developing and evolving software systems, an environment that works in symbiosis with the programmer to develop and evolve a software system.In this discussion, I present how Inscape uses operation specifications (based on Hoare's input/output predicate approach) as the basis for synthesizing the interfaces for such complex languages statements as sequence, selection and iteration. In each of these statements, the synthesized interface is a function of the component interfaces.I first present the basic rules for interface specification use and the logical framework for interface propagation and error detection. I then define the rules for propagating the interfaces for sequence, selection, iteration and operation. Finally, I define notions of “implementation completeness and correctness”.
37 citations