opm: an object process modeling environment0  this document as an attempt to give an overview of opm, a process modeling environment . by an environment we mean a user interface through which process model templates are designed, instantiated, and tracked as they execute. the two novel features of opm that we want to stress here are: (i) the way opm uses conventional case tool graphical notations for describing process templates, and (ii) the way opm supports model instantiation, resource management, and cooperative work among a team of developers.  we begin with some basic definitions. a process is a collection of activities that will be carried out over time. an activity is a basic unit of work and it minimally contains a name, and some attributes such as a duration or some resources. often the activities are ordered in some way, but not necessarily. if an ordering is available, then we can talk about an activity's predecessors and successors. when a process is being carried out (instantiated), typically more than one activity is going on at the same time. the result of an activity may be a product or simply a confirmation that it has concluded. an activity can invoke other processes. in fact, there is no logical reason to distinguish between an activity and a process, so in the future we will use these terms interchangeably.  there are several basic features of processes that we assume. in particular:  there are several ways a process may be started, e.g. by human intervention, by the arrival of a message, or by the completion of some product;  an action by a computer may end a process and start a new one;  a process may require access to resources before it can begin;  sometimes the time for a process can be reliably estimated and sometimes it cannot;  processes must have the ability to look at (access) directories, files, test file attributes, express conditions, and invoke programs.  figure 1 contains a description of how debugging takes place within some hypothetical organization. a database of bug reports is collected and there is an available pool of programmers to work on them. each instantiation of debugging process will assign a bug report to a programmer for fixing. when the programmer is done, he submits his fix to the qa (quality assurance) group who confirm that his fix is correct. if not, it is returned for further work. if so, then a report is written and submitted to the manager.  from this example we can draw conclusions that extend our earlier notions about processes and their descriptions. the use of dataflow diagram notation is suitable for describing this process. rectangles are used to represent resources and ovals are used to represent processes. arrows indicate process flow and they may carry data. other examples we have done indicate that a wide variety of processes can be adequately described by this natural notation. to refine further the debugging example, we assume that when the programmer submits the corrected code to the quality assurance group, a new process is started. that process is shown in figure 2. from this elaboration we conclude that processes may have lower levels which contain process descriptions. therefore we see that a process description should be thought of as a hierarchical object.  another observation from this example is that there may be several people all following this process description at the same time. therefore we see the need to view the process description as a template and talk about its instantiations. when the template of figure 1 is instantiated we interpret this to mean that a new bug has been assigned to a programmer for repair. observe that when a single programmer is selected to fix a single bug, that instantiation of the debugging process may give rise to multiple instantiations of the working on bug subprocess. therefore we see that when a process is executing, subprocess templates may be instantiated multiple times.  yasuhiro sugiyama ellis horowitz