process programming and process models  at the fourth software process workshop the final session was devoted to identifying "emerging issues". the issues that were identified fell into two categories. one had to do with language issues --- how to provide the facilities that support the writing of the process programs that implement process models. the other had to do with reporting on experience with writing, evaluating, and sharing process models.  since the last workshop we have made significant progress on several of the issues concerned with specifying and implementing process programs. in the paragraphs below we will comment briefly on these.  the context in which we have explored these issues is the e-l system, a new programming language and supporting environment that became operational in prototype form in the summer of 1989. while we cannot provide much detail about e-l here, we believe that it provides many of the facilities --- including both language and system facilities --- required to support process modeling and programming.  a central concern of e-l is extensibility, both in the language as well as the environment. the environment has a shared software development database, accommodates multiple simultaneous users, and facilitates communication and cooperation among a variety of users.  from the user's point of view, the material that would constitute a "program" or "module" in a conventional environment is, in e-l, organized into documents. a document has parts, recursively, and, ultimately, is composed of various objects like program fragments, text, and pictures.  we call document as well as their constituents artifacts. an artifact is typed --- examples being documents, text in latex format, pictures in postscript, and e-l program fragments in the surface syntax or some extension of it.1 in general, an artifact includes other artifacts and has a predecessor2. once an artifact has been created (and committed) it is not subject to change, although an edit that starts with a copy of it may be the basis for developing its successor. a given artifact is, typically, shared in the sense of being included in several different documents. examples of sharing include references to library entities, a reference to some artifact in the "current" version of some document as well as references to that same artifact in "previous" versions, and a reference to an artifact in the "current release" of a product as well as in one or more "current developments" of that product.  there are three major reasons for using documents and artifacts in the organizing framework for e-l. the first is to provide for literate programming in the sense articulated by knuth. that is, program constructs like functions and types are presented in the context of a document3 that motivates, explains, and defends the design decisions that underlie these constructs. an "implementation module" is simply the collection of leaves of some document that are program entities. the second reason is to provide for sharing of artifacts so that, given two versions of some document, we can identify what is common and what is different about them. the third reason is that the structure provided facilitates the addition of new types of artifacts.  the user interface to e-l provides each user with a "window" into the collection of artifacts that are of interest to that user and supports three main activities. the first is browsing --- following various "links" to inspect some collection of artifacts and attributes. in addition to the includes and included- by links that provide a natural way to navigate within a document, there are other links that may be followed like calls, called-by, and recently-modified. the second activity that is supported is editing --- evolving some document or set of documents. the editor insures that the integrity of artifacts is maintained.4  the third activity is program execution, usually aided by a collection of sophisticated debugging tools.  the user is not concerned with conventional tool invocation \--- calling compilers, analyzers, text processing tools, and the like. in general, such tools, whose purpose is to derive new artifacts or attributes, are scheduled automatically and run opportunistically.  a number of the programming language and environment issues that were identified at the last workshop are dealt with directly by e-l, including:  the basic system provides facilities for dealing with concurrency and communication, including mechanisms that provide "notification" to interested users upon the occurrence of certain events.  the artifact machinery provides the basis for sharing and containment as well as for hierarchies and decomposition.  the type system of the e-l language is quite rich and permits user-defined type constructors, expandable unions, and type templates --- "types", useable in function headers, that contain parameters that are bound for use in function bodies.  several other issues are being investigated:  long term execution a model for writing programs that execute indefinitely has been developed, a mechanism that transforms such models into program fragments that contain the necessary constructs to insure the persistence of such programs between "active" periods has been designed, and a prototype implementation of the facility is scheduled to be operational in the fall of 1989.  rules an extension to e-l that provides for rules that react to changes in the database and permit arbitrary programmed responses to such changes has been designed. a preliminary overview of this extension is provided in [che89].  sketches a "sketch" is a representation of a process program that depicts the process as a state transition diagram. we are currently designing a sketch facility for which we expect to have an operational prototype early in 1990.  specific process models we are currently developing specifications for several process models, probably including models for handling software trouble reports, cooperative program development and modification, and developing and maintaining families of programs targeted for a variety of parallel architectures. we are also investigating a process model that has nothing to do with the software process but is concerned with the usaf process for issuing rfps.  support for process modeling and analysis we are presently investigating the use of colored hierarchical petri nets (see [jen86]) for high level specification of process models as well as the use of the design/cpm tool5 construct graphical representations of these models. our experience to this point is very positive.  thomas e. cheatham