software process support through software configuration management  software development embodies a range of software processes. such processes can be captured in software process models. two of the reasons for describing software processes through models are to document and communicate a particular process to others, and to encode knowledge of the process in a form processable by computer. software process modeling has received attention by researchers in recent years - as this series of workshop indicates. efforts are expended on determining what processes are to be modeled, what of power of the modeling language is, and how the model can be instantiated and executed.  this position paper examines a different trend to supporting software processes. software development environments (sde) support the evolution of software through teams of developers by providing software version and configuration management and system build functionality. this sde functionality supports and embodies certain aspects of the software process. we have examined and experimented hands-on with a number of commercial software development environments. the environments include the rational environment, apollo dsee, sun nse, ist istar, biin sms, and atherton software backplane. these environments have advanced the functionality provided to support software evolution over commonly used development support tools such as unix make/rcs, and dec vms mms/cms.  a number of observations can be made about these environments and the way they have attempted to - at least partially - capture (i.e., instantiate) software processes.  separation of mechanisms and policy: this notion has been in practice in operating systems for a number of years. the primitives (mechanisms) should be abstract enough to contain some of the semantics of the process model to be instantiated. for example the concept of managed workspace or transaction provides a higher-level abstraction than the check-out/check-in primitives and a working directory. a good set of primitives does not unnecessarily restrict the ability to build desirable executable process models. such restrictions are detected when process model instantiations and executions are attempted. for example, the check-out operation usually performs two functions - making a program unit modifiable, and locking the unit to prevent concurrent modification. if optimistic development (i.e., permit concurrent development) is to be supported the user would have to resort to the branching function. sun nse directly supports optimistic development, but currently does not provide the primitives to provide serialized development (i.e., locking). policies can generally be encoded by writing an envelope of functions on top of the available primitives. in summary, slow progress is being made in separation of mechanism and policy and in encoding process models.  source code control evolves to software configuration management: development support in common practice provides source code control for individual files and a system build facility. newer sdes have expanded their functionality to support object code management, management of configurations, transparent access to source repositories, management of work areas, and primitives for reflecting development activities. in doing so, they relieve developers from managing versions of object code themselves, from constantly retrieving copies of files from the repository for viewing purposes, and from concerning themselves with the version history of individual files while being focused on evolving a system. the models embedded in the functionality of these environments are often not clearly described by the manufacturer, and sometimes best understood when related to the model in another environment.  configuration composition vs. evolution: these are two major approaches in maintaining configurations. configuration composition refers to defining a configuration template, which lists the components. together with a set of selection criteria, this template can be instantiated into a bound configuration. the binding may take several steps, such as source variant selection, version selection, tool version selection, and tool parameter selection. appropriate selection criteria allow for a range of desirable configuration instantiations. such as experimental, conservative, or stable. apollo dsee is an good example of this approach. the evolution approach is reflected in environments such as sun nse. the user initially creates a system configuration, populates it with elements, and preserves it. changes to the system are performed relative to a preserved configuration. most configuration management operations are performed at the level of configurations, while versioning of individual files is largely transparent. the rational environment is an environment that combines the two approaches. each of the two major approaches gives different perspective of a development process.  repository-oriented vs. transaction-oriented: again, two major approaches in managing software evolution will create different perceptions of a development process. the repository-oriented approach (or product-oriented approach) centers its support for development management on the products to be managed. the history of product evolution is reflected in the repository and its organization. environments, such as biin sms, have applied the repository mechanisms to provide for management of the work area. the transaction- oriented approach (or process-oriented approach) is centered around the changes and the activities necessary for the changes. istar is an example of a purely process-oriented support facility by directly modeling development steps and integrating it with project planning. other transaction-oriented environments, such as sun nse, take a more modest approach by providing nested transactions as a key concept. a transaction plays the role of a change activity. a transaction log reflects product history. non-terminating transactions act as repositories. as a matter of fact, one can find a spectrum of environment support ranging from repository-oriented to transaction- oriented: repository, work area management, nested transactions, activities/tasks, trigger-based task instantiation, and plan-based task instantiation.  concurrency and coordination: some environment builders have recognized the need for different degrees of freedom in concurrency and coordination of development. a closely cooperating team of developers working on a particular subsystem want more freedom passing partially complete pieces among themselves than developers of different subsystems. some environments are supporting both a cooperating team producing the next configuration releasable outside the team, and teams independently working on different development paths of the same subsystem (e.g., field release with bug fixes and further development) or different subsystems (i.e., partitioning of the system). this is new functionality and different environments provide different degrees of freedom.  scopes of visibility: related to the previous point is the desire to provide scopes of visibility. individual developers should be able to made snapshots of their work by freezing a configuration without making it visible to others. developers should be able to make their work available to their team mates before it becomes visible to a test team or the general public. various approaches are being tried. use of access control mechanisms seems to be an obvious choice, but they tend to be one of the least developed areas in environments. the use of multiple repositories (one for each scope of visibility) has the problem of potentially high cost of recompilation as elements are moved from repository to repository. some repository mechanisms provide a viewing mechanism based on a status attribute. different users are limited to viewing elements with different attribute values. evolution- oriented environments utilize nested transactions to reflect restrictions in visibility of changes.  the above reflects the state-of-the-art in commercial software development environments and their support for the process of software evolution. many of these environments are reasonably robust that they can be employed in real projects and scaled up to handle management of large system development. on one hand, it is encouraging to see that there is progress being made in the functionality provided by these environments. on the other hand it can be a little discouraging to see the limitations that exist in capturing software processes, validating their model, instantiating them, and evolving and adapting them. this is, where researchers in the area of processing modeling can provide guidance to environment builders as to appropriate mechanisms to be made available, as well as facilities for capturing process models, executing them, and allowing for adaptations and changes during execution.  peter p. feiler