This paper assesses the value of including extensibility as a feature of a programming language design. Extensibility means permitting language users to define new language features. Starting with a base language and using various definition facilities an extensible language user can create new notations, new data structures, new operations, and, sometimes, new regimes of control. Given enough insight and craftsmanship, the extensible language user can often create language extensions that are well-adapted to given intended application areas and are useful for writing concise, clear algorithms that are free from contamination with low-level detail. However, experience has revealed that this approach is not as promising as was first hoped. The paper explores the various types of extensibility that have been introduced in the extensible language movement, and it attempts to assess the practical limitations on the use of extensibility. It concludes that extensibility has many more dimensions than was first expected and that extensibility is not the revolutionary idea that some once hoped it would be.

In order to achieve more effective use of interpersonal collaboration, management lifecycle activities, and dynamic retrieval of as well as for ordinary programming chores, it may be useful to take a fresh look at the devices we use to help us conduct our transactions with computers.

This paper presents some new ideas for using large flatscreen displays and dedicated computers as personal workstations.

This questionnaire was produced as a class project for a graduate seminar on programming environments. The class, mation and Computer Science 280B, behan on 24 October 1979 and will conclude on 2 December. It has been taught by professor A. Standish.

At Irvine, we are currently in the initial stages of designing a programming environment, called Arcturus. This paper is a report of work in progress giving our preliminary philosophy and expressing preliminary thoughts on an initial Arcturus design.

Arcturus is an advanced, highly-integrated programming environment intended for use in the late 1980s. We assume that programmers will each be equipped with large flat-screen displays driven by powerful desk-top computers linked into local networks by high band-width channels, and that shared central resources such as archival databases and multifont printing systems will be available.

Arcturus is aimed at "programming in the large", that is, programming by many people, on large programs, with maintenance lifetimes of many years. In such a user setting, problems of management, documentation, training, testing, version control, diagnosis, and debugging must be solved effectively by people who, for the most part, are not authors or designers of the original system.

Some preliminary design concepts that Arcturus supports are as follows:

(1) Arcturus supports a "rapid prototyping" language -- a very high level, strongly extensible language useful for rapid construction of working prototypes of systems (emphasizing cheap, rapid construction at the expense of running efficiency and polish).

(2) Arcturus supports refinement of these prototype programs, or protoprograms, for short, into programs written in program design languages (or PDLs) , which express designs. PDL programs are ultimately refined into concrete, detailed, optimized programs expressed in an implementation language.

(3) Arcturus supports a computer-based form of program documentation in which program forms at various levels of abstraction can have attribute/value pairs attached to any of their granules (granules being well-formed program units of any size such as constants, variables, operators, expressions, statements, blocks, and modules) and in which the attributes may be selectively viewed and queried to suit the needs of different audiences.

(4) The notion of attribute/value attachment to granules of program forms also supplies the principal mechanism for promoting a high degree of environment integration. By attaching to program granules such attributes as clocks, counters, units of programmer and system resources spent, version descriptions, access controls, descriptions of tests passed, task schedule data, computer sizing estimates, and so on, smooth integration between the activities of designers, managers, testers, maintainers, programmers, and documenters can be achieved, and environment tools can cooperate with each other conveniently.

(5) Arcturus supports an advanced programmer's workstation, an interactive programmer's notebook, and extensive software management support tools.

In the framework of the Arcturus effort, we have attempted to rethink afresh issues of epistemology related to the programming process that impact documentation, fault diagnosis, maintenance, training, and software upgrade, so that the design of Arcturus will reflect the relationships between the different kinds of expertise that are required in the programming process. We are also attempting to formulate theories of documentation, debugging, and maintenance to guide the development of computer-based support capabilities that assist in the performance of these activities.

In this context, this paper contains preliminary, tentative expositions of background philosophy and rationale that guide our present thinking about Arcturus.

This paper sets some context, raises issues, and provides our initial thinking on the characteristics of effective rapid prototyping techniques.

After discussing the role rapid prototyping techniques can play in the software lifecycle, the paper looks at possible technical approaches including: heavily parameterized models, reusable software, rapid prototyping languages, prefabrication techniques for system generation, and reconfigurable test harnesses.

The paper concludes that a multi-faceted approach to rapid prototyping techniques is needed if we are to address a broad range of applications successfully -- no single technical approach suffices for all potentially desirable applications.

This Final Report of research conducted under the support of NSF grant MCS75 13875 A01 summarizes results and accomplishments of our research in interactive program manipulation.

Briefly, we developed the Irvine Program Transformation Catalogue which organizes, names, and classifies over 10 groups of program transformations. We discovered how to get a computer to chain together large numbers of simple program transformations with minimal interactive guidance, minimal wasted search, and high efficiency, resulting in dramatic net program improvements. We validated our chaining concepts by building the SPECIALIST system, reported on in the doctoral dissertation of Dennis F. Kibler. We discovered how to verify that transformations in our system preserve program equivalence. Finally, we developed stepwise refinement transformation techniques for mapping abstract program forms into concrete pogram forms involving the use of exchanges between statements in languages of assertion and relation (i.e. logic) and languages of imperative intent. The refinement transformations are mediated by drawing on knowledge and exchange laws from "micro-worlds", such as the "set", "array", and "sequence" microworlds.

Conceptual simplicity, tight coupling of tools, and effective support of host-target software development will characterize advanced Ada programming support environments. Several important principles have been demonstrated in the Arcturus system, including template-assisted Ada editing, command completion using Ada as a command language, and combining the advantages of interpretation and compliation. Other principles, relating to analysis, testing, and debugging of concurrent Ada programs, have appeared in other contexts. This paper discusses several of these topics, considers how they can be integrated, and argues for their inclusion in an environment appropriate for software development in the late 1980's.