David S. Wile

Acme: an architecture description interchange language

Numerous architectural description languages (ADLs) have been developed, each providing complementary capabilities for architectural development and analysis. Unfortunately, each ADL and supporting toolset operates in isolation, making it difficult to integrate those tools and share architectural descriptions. Acme is being developed as a joint effort of the software architecture research community as a common interchange format for architecture design tools. Acme provides a structural framework for characterizing architectures, together with annotation facilities for additional ADL-specific information. This scheme permits subsets of ADL tools to share architectural information that is jointly understood, while tolerating the presence of information that falls outside their common vocabulary. In this paper we describe Acmes key features, rationale, and technical innovations.

Program developments: formal explanations of implementations

Abstract : Automated program transformation systems are emerging as the basis for a new programming methodology in which high-level, understandable specifications are transformed into efficient programs. Subsequent modification of the original specification will be dealt with by reimplementation of the specification. For such a system to be practical, these reimplementations must occur relatively quickly and reliably, in comparison with the original implementation. We believe the reimplementation requirement necessitates that a formal document--the program development--be constructed during the development process to explain the resulting implementation to future maintainters of the specification. The overall goal of our work has been to develop a language for capturing and explaining these developments and the resulting implementations. This language must be capable of expressing: the implementors goal structure, all program manipulations necessary for implementation and optimization, and plans of such optimizations. In this report, we discuss the documentation requirements of the development process and then describe a prototype system for constructing and maintaining this documentation information. Finally, we indicate the many remaining open issues and the direction to be taken in the pursuit of solutions. (Author)

Operational specification as the basis for rapid prototyping

This paper describes a set of freedoms which both simplify the task of specifing systems and make the resulting specification more comprehensible. These freedoms eliminate the need, in specific areas, to consider: the mechanisims for accomplishing certain capabilities, the careful coordination and integration of separate operations, the costs of those operations, and other detailed concerns which characterize implementation.These freedoms are partitioned into the areas of efficiency, method, and data, and providing them has resulted in a novel formal specification language, Gist. The main features of this language are described in terms of the freedoms it affords. An overview of the language is then presented together with an example of its use to specify the behavior of a real system.

Worlds: an organizing structure for object-bases

Object-bases are certain to supplant todays file systems in future program development environments. Unfortunately, file systems implicitly provide several important environmental features that are difficult or impossible to obtain using existing object-bases, such as focus of attention, garbage detection and collection, and data sharing. These deficiencies arise from the absence of mechanisms for naming and maintaining aggregations of information in structures larger than single relations or single object classes. This paper proposes a model for information in programming environments, called worlds, which naturally describes clusters of information forming conceptual units in an object-base. Because the model arose from the need to represent well-formed grammatical structures, the concept unifies syntax-directed manipulation with object-base facilities. In addition, this clustering capability provides a foundation in object-bases for the features lost from file systems. We illustrate worlds through their use to maintain persistence in the object-base of our programming environment, the Common Lisp Framework.

Organizing Programming Knowledge into Syntax-Directed Experts

Programming environments of the future are certain to be knowledge-based. Succinct statements of expertise, currently applied implicitly by programmers, will be available for explicit application by future programmers as well as opportunistic application by the environment itself. Considerable tension will exist between the desire to represent knowledge in a flat, decomposed form, and the desire for the efficiency available in compiled representations of this knowledge, as used in automatic processors, such as compilers, simplifiers, and code analyzers. I advocate specifying programming knowledge uniformly but organizing the knowledge into experts which solve syntax-directed problems, problems whose solution decomposition resembles the structure of the input data itself. This organization allows the efficiency of current ad hoc representations to be obtained and the resulting experts can coexist-in fact, cooperate-with more sophisticated problem solvers, including people.

Automated derivation of program control structure from natural language program descriptions

This paper describes a system which organizes a natural language description of a program into a conventional program control structure, as a part of a larger system for converting informal natural language program specifications into running programs. Analysis of the input program fragments using a model of a human “reader” of specifications has been found to be a very successful adjunct to conventional “planning” methodologies. Natural language descriptions of programs can frequently be characterized as “rubble”—a very loosely organized set of almost independent description fragments [Schwartz]. Such specifications are often quite robust, due to a large degree of redundancy; they are also frequently quite concise, due to reliance on the readers innate knowledge and their knowledge of the application domain. This paper discusses a paradigm for structuring the portion of “rubble” program descriptions which maps into conventional programming language control constructs and definition facilities.

A multi-formalism specification environment

This paper describes initial work on a software development environment capable of smoothly integrating modules written in different languages. The focus of this work is on supporting the construction of executable, multi-formalism specifications , where each part of a problem is described in a language that is close to its underlying domain. We distinguish specifications from programs to emphasize the closeness of the formalism to these domains rather than underlying computational models, and to indicate that we are not attempting to integrate existing implementations of programming languages. Rather, we provide a grammar-based framework for the construction and integration of interpreters for different specification formalisms. The key to our approach is that formalisms communicate through grammatically described interfaces . Such interfaces hide incompatible aspects of different formalisms, allowing new combinations of formalisms to be created easily.

Adding relational abstraction to programming languages

‘The most successful formal method is abstraction. Functional abstraction, abstract data types, objectoriented type-inheritance, and built-in high-level modeling primitives, like sets, sequences, and maps (with their attendant operators), all raise the level of language with which programmers communicate and hence, promote the production of dependable, adaptable software. Relational abstraction is an abstraction mechanism that has had too little emphasis in the development of programming languages. We have found it to be a useful adjunct to the other abstraction mechanisms mentioned above; in effect,ion mechanisms mentioned above; in effect, relational access to data can be used to regularize idiosyncratic usage of abstract data types. I have designed and implemented a set of macros in Common Lisp that extends it to allow definition, update and queries of abstract relations. It is unusual in that the relations are lightweight: relations are not necessarily the repositories of ‘bulk data’, but are lised as a common abstraction of a wide variety of conventional program data structures. In this paper principles for integrating relational access into programming languages in general are put forth and demonstrated through this design. Of special interest is the ability to compile these abstractions into arbitrary data structures without fear of penalties from poor implementations or run-time overhead. *Sponsored by Defense Advanced Research Projects .gency, Information Science and Technology Office, ARPA Order No. 6096, issued by Defense Supply Service (Washington) under contract no. MDA903-87-C-0641 Permission to copy without fee all or part of this material is granted provided that the copies are not made or distributed for direct commercial advantage, the ACM copyright notice and the title of the publication and its date appear, and notice is given that copying is by permission of the Association for Computing Machinery. To copy otherwise, or to republish, requires a fee and/or specific permission. @ 1990 ACM 089791.4155/90/0010-0128...

On the use of programming knowledge to understand informal process descriptions

1.50 1 Abstraction Methods lLIost researchers identify formal methods with methodological support for the production of software, often independent of the programming languages used. However, linguistic support for formal methods embodied in programming language design can sometimes aid the methodologies considerably. In some sense, when a methodology is understood well enough, support for it migrates into programming languages themselves. For example, ‘top down programming’ as a methodology preceded the ‘gotoless’ languages with their enhanced support for looping and, especially, exiting control. Similarly, ‘abstracting data access’ as a methodology preceded language support for ‘abstract data types.’ The use of abstraction, “reduction to a short statement of the most important ideas,‘” is a formal method for separating concerns: people are encouraged to reason about properties made evident by abstraction before dealing with properties involving details masked by abstraction. Software development methods abstract some aspect of the programming process in order to reduce the variety and complexity of details considered by a programmer at any one time, and hence over time, the totality of the details

Aggregation, Persistence, and Identity in Worlds

The goal of improving and simplifying communication with computers has been pursued largely through the creation and use of better formal languages. This paper investigates an alternative approach by exploring the variety and extent of informal constructs which can be introduced into a formal language without impairing communication. These informal constructs represent the suppression of certain explicit information which must be inferred from the surrounding context.In general, each informal construct has several possible interpretations, only one of which was intended by the speaker. The systems task is to use the existing context to focus attention on a small ordered subset of the most probable alternatives and to further reduce it by applying any constraints or well-formedness rules. The most probable remaining alternative is selected as the intended one.Program descriptions were chosen as the example task domain to test this approach because its rules of context and well-formedness are fairly well developed and because we, as computer scientists, are our own domain experts.