Abstract Business Process Management is called agile when it is able to react quickly and adequately to internal and external events. Agile Business Process Management requires putting the life cycle of business processes on a new paradigm. It is advocated in this paper that social software allows us to satisfy the key requirements for enabling agile BPM by applying the four features of social software: weak ties, social production, egalitarianism and mutual service provision. Organizational and semantic integration and responsiveness (of the business processes engineering, execution and management activities) have been identified as the main requirements for implementing an agile BPM life cycle. Social software may be used in the BPM life cycle in several manners and using numerous approaches. This paper presents seven among them and then analyzes the ‘support’ effects between those approaches and the underlying social software features, and the three requirements for Agile BPM. Copyright © 2011 John Wiley & Sons, Ltd.

Current object-oriented formalisms, such as UML, focus on describing class models and use instance models only for depicting scenarios. Little attention is being devoted to defining how complex systems can be structured in order to conform with those class models and, further, which constraints class models must adhere to so that such conformity is affordable. This paper focuses on instance models, which are models of actual systems (and, as such, they are made up of instances), and discusses the relationships between instance models and class models. A large number of applications, ranging from generic data modeling to enterprise modeling, require instance models. The importance of hierarchical composition is emphasized: its meaning and implications are discussed in both contexts. A novel approach for building templates out of aggregates of instances is also presented. A case study concerning enterprise modeling shows the application of the approach.

Object-oriented software evolves over time, and it would be ideal if we could capture the persistent parts of the software early on and then derive the transient versions of the software from the persistent parts. Capturing the persistent parts of the software allows us to better maintain the integrity of the program during its evolution. This is the goal of software architecture. In this paper, we emphasize an approach called O/sup 3/ML (Operational Object-Oriented Modeling Language) to model complex software systems using a sound software architecture which is centered on the creation of a system prototype with integrated design requirements and a simulation framework. This methodology supports the prototyping of complex computer-based systems by providing: (a) a multi-domain approach to capture the architectural complexity of real-world systems; and (b) a mechanism for the simulation of the conceptual, functional and implementation features of the design and the user requirements.

The development of concurrent applications, which consist of several parallel, often distributed, activities that communicate and synchronize with each other, presents challenging logical and technological issues. In the common practice, technological aspects, which are related to the definition of concurrent processes as well as of their interactions, often place constraints on the logical ones. Consequently, the flexibility that could be attained during design is reduced and, further, an actual implementation where both aspects are deeply intermixed is usually obtained. This paper first presents an expressive and flexible language based on object-oriented high-level nets, which allows designers to naturally represent concurrency and synchronization. Then, it illustrates a powerful software engineering environment, CAB (Concurrent Applications Builder), which supports the building and the simulation/animation of models as well as the automatic generation of applications from models (by transforming the model’s objects into implementation processes). A case study from an actual project for automatic toll collection in motor-ways is illustrated.

The goal of the work reported is to construct a framework that supports the development of concurrent applications. The paper presents the operational structure of an object based architectural system, illustrates the different kinds of relationships that may exist between the objects in an operational structure and how communication between the objects in such relationships is solved by message passing. Examples of synchronous, asynchronous and remote invocation types of process interaction models are also shown.

Current Petri net based methods for modeling and design of real-time systems rely on formalisms that are either expressive or analyzable, but not both. Our goal is to provide a new formalism bridging the gap between these positions. We start from a well known result on timed marked graphs, extend it to more general nets, and enhance the resulting formalism expressiveness by means of a set of transition expansion rules, which also enable hierarchical net structuring. A detailed example is discussed.>

One of the issues in current software engineering research is the formalization of the production of large-scale software systems. Basically, the knowledge about a production process relies on three models: the product, the organization and the process model. Product and organization models are information models: an extended entity-relationship formalism is suitable to build such models. On the other hand, process models are behavioral models which react to temporal events or to user actions on the repository. The authors' research aims at providing conceptual models which support the construction of rigorous and verifiable organization and process models. They have developed two formalisms: Quid for building E-R models and generating the corresponding repository, and Protob for expressing process models in terms of high level nets. This paper illustrates the formalisms and present examples of process models.>

Abstract The PROTOB object‐oriented methodology for the executable specification of large‐scale event‐driven systems is introduced and described. Two supporting features of PROTOB are also presented: the graphic and textual language that formally describes the behaviour of objects, which is based on high‐level Petri nets called “PROT nets” and which is demonstrated to be more powerful than SA/RT dataflows; and a CASE environment with tools for specification, modelling, simulation and prototyping. Use of PROTOB is illustrated by discussion of the automated generation of distributed systems running on a network of VMS and UNIX computers.

TOPNET is a software package for the simulation of communication networks that is being developed with the aim of exploiting as much as possible the visual aspects of a simulation experiment. The communication network topology and architecture are described by drawings, the system dynamics are represented with a class of timed Petri nets, the simulation experiment is controlled through menus and buttons activated with a mouse, and results are graphically displayed on the screen. With the help of an example, the main characteristics of the user interface and the internal architecture of TOPNET are described.>

Production scheduling on a flexible manufacturing system is a mixed continuous combinatorial optimization problem. Closed queueing network analysis is the technique we used to solve the continuous problem. Around it a rule based module has been established to heuristically solve the combinatorial problem. Two schedulers have been implemented, considering shorter or longer intervals of time, both based on the new solution paradigm for production scheduling.

Prot nets are an extension to Petri nets, since they can be given a sophisticated semantics by assigning formal inscriptions to the objects of the net. In several applications to CIM (computer integrated manufacturing) systems they proved to give suitable support to object oriented programming, operational specification and rapid prototyping. In this work we present a graphical language, based on Prot nets, for building the specification of discrete event simulation models, and we illustrate its application to the simulation of a manufacturing cell.

This paper presents an object-oriented approach for building distributed systems. An example taken from the field of computer integrated manufacturing systems is taken as a guideline. According to this approach a system is built up through three steps: control and synchronization aspects for each class of objects are treated first using PROT nets, which are a high-level extension to Petri nets; then data are introduced specifying the internal states of the objects as well as the messages they send each other; finally the connections between the objects are introduced by means of a data flow diagram between classes. The implementation uses ADA as the target language, exploiting its tasking and structuring mechanisms. The flexibility of the approach and the possibility of using a knowledge-based user interface promote rapid prototyping and reusability.

A methodology for the rapid prototyping of process control systems which is based on an original extension to classical Petri nets is presented. The proposed nets, called PROT nets, provide a suitable framework to support the following activities: building an operational specification model; evaluation, simulation, and validation of the model; and automatic translation into program structures. PROT nets are shown to be translatable into Ada program structures concerning concurrent processes and their synchronizations. The authors illustrate this translation in detail using, as a working example, the problem of tool handling in a flexible manufacturing system.

Abstract The process interaction approach is proposed for developing a discrete simulation environment in Ada. The introduction of simulation facilities in Ada not only concerns the classical aspect of model building, but allows a new class of problems to be tackled, that is the testing of correctness of programs intended for real‐time applications. In this paper attention is focused on the presentation of the process scheduling in the simulation context and on the definition of standard forms of interactions among processes. Simulation facilities are organized by making use of Ada's structuring concepts.