experience with marvel  marvel is a kernel for software development environments that enacts a processing modeling notation, called the marvel strategy language (msl). the software process is defined in msl as a collection of modular strategies, where different (sets of these) strategies are appropriate for different tool suites, user roles, phases of the lifecycle, management policies, etc. each strategy specifies a partial object-oriented data model and a partial rule- based process model. the strategies are supplemented by a collection of envelopes, each of which describes how to apply one or more of the external tools used during software development activities; this includes the mapping from the inputs/outputs of these tools and the marvel objectbase and the command lines to invoke these tools. multiple msl strategies are merged to obtain the full data and process models for enaction by the marvel kernel.  each software development activity is described in msl by a rule specifying the precondition and multiple postconditions of the activity. both preconditions and postconditions are written in a subset of the first order predicate logic, stylized to incorporate directives for efficient queries and updates. a precondition is a logical statement that must be true before the activity is initiated; a postcondition is a logical statement asserted to be true when the activity completes. multiple mutually exclusive postconditions reflect the multiple possible results of many activities. an activity is typically a particular combination of software development tool, options specific to that tool, and typed arguments. the notion of activity could be extended to include loading a new set of strategies to take over at this point in the process, to support both nesting of hierarchical activities and successive activity phases.  enaction of an msl process model is implemented by what we call opportunistic processing, consisting primarily of forward and backward chaining among the rules. when a user initiates an activity, marvel applies backward chaining to attempt to satisfy its precondition. if this is not possible, marvel could use the rules in the style of an expert system to explain the problem. once an activity has completed, marvel asserts one of its postconditions and uses forward chaining to automatically carry out other activities whose results are presumed to be needed in the near future.  we have designed two facilities for controlling this processing, to prevent runaway automation. hints are additional msl preconditions that affect automatic but not user-initiated invocation of tools. implicit queries represent a reflective capacity to keep tabs on estimated costs of automatic behavior and request user confirmation when certain user-selected thresholds are reached.  marvel version 2.10 was recently completed, an upgrade over the version 2.01 that was demonstrated at the 3rd psde conference in november 1988. this latest version of marvel adds an x11 windows graphical user interface and new subsystems called marvelizer and organ. marvelizer is a tool for immigrating existing software systems from the unix file system or (a restricted class of) existing software development environment into a marvel objectbase. organ is a set of commands for reorganizing marvel objectbases as the project and/or system structure evolves. marvelizer has been used to immigrate marvel itself, including about 35,000 lines of c code, into a c/marvel objectbase. we would like to use the c/marvel set of msl strategies, which support activities using the user's favorite editor, lint, cc, ar, ranlib, less (and soon rcs, dbx and mail), for our own further development of marvel. both marvel and c/marvel were in use during the spring 1989 semester by students in my e6123y programming environments and software tools course (admittedly a captive audience).  we have discovered several difficulties with the marvel paradigm that seem likely to apply at least partially to enaction of other notations for software process modeling. first, constructing and debugging a process model is hard. we have run into many unanticipated interactions among rules, particularly among those defined in different strategies that happen to be loaded into the marvel kernel at the same time. we are working on debugging facilities that will uncover all direct and transitive dependencies by constructing a graphical dataflow graph of the currently loaded rules. it is feasible for a user to enable and disable individual rules, both during debugging to see how that affects the dataflow among rules and also during operation because certain behavior is not currently desired. this would be dangerous, however, if done by a naive user: if rules were turned off and on at arbitrary points, it would be possible for marvel to get into what is an inconsistent state with respect to the full set of rules in such a way that automatic recovery is impossible.  similar difficulties seem likely to arise for any enactable process modeling paradigm. the following questions need to be answered: how does an implementor go about writing, testing and debugging a process model? for non-trivial processes, the model is likely to be very large and hence should be modularized. what is the appropriate style of interface among process model modules and how is it enforced? is the process model visible to the users and, if so, how is it presented? if the users can modify the process model during enaction, how does this affect continuing the process? should (can) consistency be enforced or should (can) inconsistencies be detected and repaired?  second, constructing envelopes is even harder. we currently use the shell languages (e.g., cshell) as notations for defining envelopes. writing the shell scripts requires an intimate knowledge of both the tool and the mapping of the marvel objectbase onto the file system. although there is no way to avoid the former, we hope to minimize the latter by developing a higher level envelope language that understands the marvel objectbase implementation so the envelope writer doesn't have to. however, this is currently a relatively low priority due to lack of manpower.  again, similar difficulties seem inevitable for other enaction mechanisms intended to work with external tools. the questions: is it possible (or desirable) to support existing tools, particularly tools where retrofitting is impractical? if only new tools are supported, can a relatively simple standard interface be developed and published so these tools can be developed separately by vendors? would such an interface pre-empt too many design decisions, or would it be feasible for vendors to upgrade their current products?  third, supporting multiple users is hardest of all. the current marvel kernel does not provide any facilities for concurrency control. it would be easy to add locking of the entire objectbase, but a more flexible transaction model is needed. we are working on a number of alternative models that we think are promising for incorporation into the marvel kernel. commit-serializability introduces two new transaction operations, split-transaction and join- transaction, that manipulate in-progress transactions to support coordination among multiple users. participant transactions (aka participation domains) distinguishes participants in group software development tasks from observers, and relaxes serializability as viewed by participants to permit cooperation.  it is essential for enactable process models to support coordination and cooperation among the members of software development teams. there are two sets of questions: first, what are appropriate processes for programming-in- the-many? this is itself an active area of research, and there is certainly no consensus. one opinion, voiced at the previous workshop, is that the community should not be enacting process models until we understand the processes we are modeling. an opposing opinion is that enaction gives the community the capability to experiment with different processes without prematurely making a full scale commitment to a particular process. assuming agreement with the second view, what process modeling notations and enaction mechanisms can support a reasonable range of cooperative work facilities?  the database and operating system communities have agreed on atomic and serializable transactions, which can be implemented using a wide variety of technologies, as the basis for data consistency, failure recovery and concurrency control across their traditional application areas. can the software engineering community develop an equally all- encompassing "transaction" model? or is there some characteristic of the software development process such that coordination and cooperation policies will always require special support on a case-by-case basis? if so, what does this say about enaction of process models in general?  in summary, marvel is implemented and in limited use, it works in some cases, it doesn't work in others, it raises a lot of questions, and both we the marvel group and we the software engineering community have a lot more work to do.  gail e. kaiser