Current software development tools let developers model a software system and generate program code from the models to run the system. However, generating code and installing a non-trivial system induces a time delay between changing the model and executing it that makes rapid model prototyping awkward if not impossible. This paper presents the architecture of a virtual machine for UML that interprets UML models without any intermediate code-generation step. The paper shows how to embed UML in a metalevel architecture so that a key property of model-based systems, the causal connection between models and model instances, is guaranteed. With this architecture, changes to a model have immediate effects on its execution, providing users with rapid feedback about the model's structure and behavior. This approach supports model innovation better than today's codegeneration approaches.

Abstract: We have noticed a common architecture in many systems that emphasize flexibility and run-time configuration. In these systems, business rules are stored externally to the program such as in a database or XML files. The object model that the user cares about is part of the database, and the object model of the code is just an interpreter of the users ’ object model. We call these systems “Adaptive Object-Models”, because the users ’ object model is interpreted at runtime and can be changed with immediate (but controlled) effects on the system interpreting it. The real power in Adaptive Object-Models is that the definition of a domain model and rules for its integrity can be configured by domain experts external to the execution of the program. These systems are important when flexibility and dynamic runtime configuration is needed, but their architectures have yet to be described in detail. This paper describes the Adaptive Object-Model architecture style along with its strengths and weaknesses. It illustrates the Adaptive Object-Model architectural style by outlining examples of production systems.

Many object-oriented information systems share an architectural style that emphasizes flexibility and run-time adaptability. Business rules are stored externally to the program such as in a database or XML files instead of in code. The object model that the user cares about is part of the database, and the object model of the code is just an interpreter of the users' object model. We call these systems "Adaptive Object-Models", because the users' object model is interpreted at runtime and can be changed with immediate (but controlled) eftcts on the system interpreting it. The real power in Adaptive Object-Models is that they have a definition of a domain model and rules for its integrity and can be configured by domain experts external to the execution of the program. This paper describes the Adaptive Object-Model architecture along with its strengths and weaknesses. It illustrates the Adaptive Object-Model architectural style by describing a framework for Medical Observations (following Fowler's Analysis Patterns) that we built.

This report describes an experiment in using AspectJ to extract a feature from a Java code base in order to make it unpluggable. We describe issues and obstacles encountered while performing a series of code transformations and next present a collection of manual aspect-oriented refactorings, based on the experience gained in the process. These are described in detail and compounded with a self-contained example placing each refactoring in its proper context. 1.

An increasing number of software developers are turning to workflow to separate the logic and the control aspects in their applications, thus making them more amenable to change. However, in spite of recent efforts to standardize and provide reusable workflow components, many developers build their own. This is a challenging endeavor and involves solving problems which seem incompatible with the object paradigm and current object-oriented programming languages. In the context of an object-oriented workflow framework, this paper demonstrates a novel approach that resolves this impedance mismatch with techniques drawn from programming language theory. This successful cross-pollination narrows the gap between the results of decades of research in programming languages and developers working hard to cope with change.

Abstract. The prospect of aspect-orientation receiving widespread acceptance and adoption in the near future begs the question of how to deal with a large base of object-oriented legacy code. We propose to investigate refactoring techniques for restructuring object-oriented source code so that it can leverage the mechanisms of aspect-orientation in order to become easier to adapt, extend and evolve. Our approach is to adopt an object-oriented framework in the area of workflow as a non-trivial case study. We plan to analyse its source code, develop an aspect-oriented version through the progressive use of manual refactorings, and build a catalogue of refactoring operations based on the experience gained through the process. 1.

The environments where workflow management systems are typically used in are constantly changing. It is nearly impossible to foresee, at business process design stage, all the combinations of tasks needed to achieve the process ’ goals. Workflow management systems capable of supporting dynamic changes on executing instances in a flexible manner are thereby demanded. Former approaches have proposed a solution to this issue based on workflow type versioning and workflow instance migration. However, the operations that handle the modification of workflow types as well as the migration algorithm for workflow instances are tied to a particular representation of workflow types. This means that whenever the representation changes, the migration algorithms and the modification operations have to change accordingly. This is a current problem due to the uprising of different specifications for workflow definition languages, which are far away from stabilizing. In this paper, we address this problem by clearly decoupling the modification operations of workflow types from the internal structures and algorithms responsible for the instances ’ migration. In this manner we enable the use of different workflow definition languages while keeping the same internal structures and migration algorithms. 1.

Workflow management systems have come a long way from the first office automation prototypes of the late 1970s. Today, workflow systems are deployed in a variety of situations, ranging from the coordination of document-centric processes in office environments to the automation of application data flow in enterprise application integration scenarios. The variety of applications as well as the diversity of the workflow systems available easily leads to confusion, when the most suitable system for a specific setting has to be identified.

Service-Orientation (SO) is a design and integration paradigm that is based on the notion of well defined, loosely coupled services. Within SO, services are viewed as computational elements that expose functionalities in a platformindependent manner and can be described, published, discovered, and consumed across language, platform, and organizational borders. SO principles emphasize composability, by which a set of services can be composed to achieve the desired functionality. Service orchestration is the dominate approach to service compositions. A key issue in implementing service orchestrations is their efficient concurrent execution. This paper focuses on the scalability challenges of simultaneously executing many long-running service orchestration instances. We present a novel approach for implementing service orchestrations called BUST (Break-Up State Transition) that significantly improves processing rate and scalability. Categories and Subject Descriptors C.2.4 [Computer-Communication Networks]: Distributed

Despite the large number of commercial workflow systems, object-oriented developers implement their business processes with home-made workflow solutions. Current workflow architectures are based on requirements and assumptions that don't hold in the context of object-oriented software development. Microworkflow, a new workflow architecture, bridges the gap between the type of functionality provided by existing workflow systems and the type of workflow functionality required by developers. Micro-workflow provides a better solution when the focus is on customizing the workflow features and integrating with other systems.