Abstract: Active database management systems (DBMSs) are a fast-growing area of research, mainly due to the large number of applications which can benefit from this active dimension. These applications are far from being homogeneous, requiring different kinds of functionalities. However, most of the active DBMSs described in the literature only provide a fixed, hard-wired execution model to support the active dimension. In object-oriented DBMSs, event-condition-action rules have been propo sed for providing active behaviour. This paper presents EXACT, a rule manager for object-oriented DBMSs which provides a variety of options from which the designer can choose the one that best fits the semantics of the concept to be supported by rules. Due to the difficulty of foreseeing future requirements, special attention has been paid to making rule management easily extensible, so that the user can tailor it to suit specific applications. This has been borne out by an implementation in ADAM, an object -oriented DBMS. An example is shown of how the default mechanism can be easily extended to support new requirements.

Abstract: A method and system for reducing the amount of information sent across a socket when invoking an application using a remote method invocation. The present invention involves creating a list of the classes and fields contained within the application that is to be distributed and determining which of the fields are actually required for the remote method invocation under analysis. Any fields that are in the method but are not necessary for the invocation are marked with place holders.

Abstract: Strong, static typing is useful because it can improve the readability, reliability and optimizability of programs. The usability of an object may change over time. However, conventional type systems for object-oriented languages presume that objects are always used in the same way. In this paper an extension of Ada's type concept is presented: Possible changes of object usabilities can be specified as part of type declarations for passive and active objects. This extension is compatible with inheritance and supports static type checking.

Abstract: Active object databases (AODBs) consist of active objects that have the capability to autonomously and asynchronously respond to event occurrences The response of active objects to events is specified by object-centered active rules that are similar to event-condition-action rules For many AODB applications, the nondeterministic nature of active rule execution raises the problem of verification of termination and confluence as important run-time properties of active rule sets A rule set has the termination property if it does not allow infinite rule execution sequences A rule set has the confluence property if the final database state does not depend on the order of execution of active rules This dissertation develops a comprehensive set of methods for analysis and verification of termination and confluence These methods are applicable to a general AODB framework having a well-defined structural data model, a logic-based query language, and a rule-based specification of active object behavior The structural data model is developed using an order-sorted algebraic specification approach The query language is an instance of the constraint logic programming scheme, where derived data are defined and queried over the stored database viewed as a constraint domain Active rules are modeled as conditional rewrite rules that operate over the universe of database states Since termination and confluence are generally undecidable properties, they are approached by identifying sufficient conditions and a machinery for verification of the sufficient conditions Three complementary termination methods are presented: the triggering graph method (based on the acyclicity of the rule triggering graph), the refined triggering graph method (based on the satisfiability of well-defined triggering formulae), and the termination orderings method (based on well-founded term orderings) Confluence analysis relies on the notion of a conditional critical pair (CCP) that is defined for any rule pair Convergence of all CCPs is a sufficient condition for confluence of the rule set Three types of CCPs are identified along with sufficient convergence conditions The use of termination and confluence methods in a transactional context is also addressed

Abstract: The Active Objects Model (AOM) as a model-based user interface development environment is presented. The paper highlights the convenience of the trajectory notion in the description of the structure and functionality of graphical user interfaces. The AOM model consists of a set of active agents with private rule based behaviours. Model entities involve topological information which defines the behaviour of active objects, parallel and cooperative evolution of agents, time controlling, event oriented or supervised behaviour, interactive techniques, visual programming constructs, rapid prototyping, and intelligent user interfaces. All model entities may be defined by direct manipulation techniques.

Abstract: Summary form only given. Active database management systems (active DBMS) support the definition, management and execution of event/condition/action rules specifying reactive application behavior. Although the advantages of active mechanisms are nowadays well known, there is still no wide use in practice. One main problem is that especially for large rule sets, defined by different persons at different points in time, potential conflicts and dependencies between rules are hard to predict and rule behavior is difficult to control. Therefore, tools are needed to assist the development and maintenance of rule bases. These tools should provide for graphical interfaces supporting both, "static" activities (performed during rule specification) such as rule editing, browsing, design, rule analysis, and "dynamic" activities (performed at runtime, during the execution of an application) such as testing, debugging and understanding of rule behavior. The aim of the article is to show the use of three of these tools, namely the rule editor, the browser and the termination analyzer in the process of developing applications for the active object oriented DBMS SAMOS.

Abstract: CoOperative Objects (COOs) are a concurrent object oriented modelling and programming language, which uses the Petri net theory to define the concurrency within each object, among objects, and also the inter object asynchronous communication. SYROCO is a C++ implementation of CoOperative Objects which proves to be efficient and convenient enough to support real size applications. The paper aims to show that intra object concurrency is of paramount importance for models of object oriented concurrency, and that intra object concurrency is smartly supported by the integration of the object oriented and Petri net paradigms. Namely, it discusses the model of concurrency adopted by COOs, and details how it is implemented in SYROCO.

Abstract: This report discusses application design for active databases, in particular for the active object-based database programming language DEGAS. In DEGAS one modularisation principle, the object, is applied to all elements of the application, including rules. We discuss a design process consisting of four phases, corresponding with the four kinds of capabilities in a DEGAS object, attributes, methods, rules, lifecycles. The elements of this design process are similar to those found in a design methodology such as OMT. To illustrate the design process we use the example of workflow management. In addition, it shows that the application of one modularisation to all elements of an active database leads to a clear modularisation of the workflow application, Furthermore, this modularisation facilitates all important workflow evolutions.

Abstract: PROBLEM TO BE SOLVED: To provide a system and a method for acquiring and correcting the management information of a remote computer and the execution of server processing in a distributed object programming environment. SOLUTION: A network compuer system 100 includes plural host computers 101 provided with servers for providing various functions to respective distributed clients 105 connected to a network 103. Even when a certain client 105 has only a function for referring to an object in a server when a 1st class object executed in each server processing exists, the client 105 can access the execution information of a server connected to a remote host computer. The 1st class object judges the identification of each server processing, an active object in the server processing and the counting of execution of the server processing and is used for controlling tracing and logging functions provided from an application program interface used by the server.

Abstract: This paper presents features of an object based concurrent language called Actel. In particular, it introduces the mechanisms of inter and intra-object concurrency and synchronisation. Inter object concurrency is achieved with conventional message passing (value and priority) and also with a new mode of message passing called the semi-reference. Intra-object concurrency may be achieved with parallel functions, parallel compound statements, simultaneous compound statement, and multiple methods invocation. Synchronisation may be achieved with simple, multiple, or overloaded future variables. An example illustrates various Actel features.

Abstract: Automated allocation tools do not achieve the same efficiency for all kinds of applications. A parallel programming environment should integrate high-level tools to permits users to easily adapt the behaviour of the automated allocation tools to the peculiar application needs. The paper faces this problem and presents a set of high-level directives to specify the allocation needs of the components of parallel applications based on the active object model. The allocation directives can drive the allocation decisions of the automated tools, by tuning their general-purpose behaviour to the peculiar application needs.

Abstract: This paper concerns methodology for the development of large socio-technical systems on the basis of GRADE (Graphical Reengineering Analysis and Design Environment) tool.* GRADE toolset and methodology supports all stages of system life cycle—from problem definition and requirement gathering to implementation and maintenance. The paper gives an overview on the GRADE tools and methodology and concentrates mainly on the transition from object view (in a form of object hierarchy) to the Business Model of the system. System description and requirement specification in GRADE are represented as a hierarchy of Active Objects (producers of results), Passive Objects (results produced) and Activities (Process Objects performed by the Active Objects in order to manipulate with Passive Objects and produce expected results). Each object can have also numeric attributes describing their physical properties. This enables evaluation of reactive and dynamic characteristics of the system, as well as the simulation and optimization of system. Business model in GRADE can be represented by several alternative diagramming techniques (Object hierarchy, Task Communication Diagram, Process Diagram and/or Event driven Process Chain).

Abstract: Active database management systems(ADBMS) are finding increasing application in diverse domains and especially in different kinds of control applications and long duration activity management. An ADBMS gives users the facility to define dynamic semantics of the application as a part of the database. In this paper, we propose a modeling scheme for ADBMS applications. Our approach allows modeling in three orthogonal dimensions viz. object dimension, event dimension and transaction dimension. The application semantics is viewed as an interrelationship among the modeled components in each of these dimensions. A novel modeling technique has been used in our scheme whereby the application independent activeness aspect of the database can be separated out from the application dependent part. This is done by separating out the global and local events/rules of the applications. Thus applications having different activeness requirement over the same database may be designed instead of putting all activeness aspects statically in the database schema.

Abstract: Retaining a satisfactory performance for a program has been an important yet difficult task for software maintenance. This difficulty can largely be attributed to the performance ripple effect of software modifications which, in turn, is caused by the performance dependencies between program entities. Among various linguistic mechanisms contributing to the causes of performance dependencies, module invocation may be the one most commonly used. This mechanism, however, may appear in a variety of syntactic forms in a program, ranging from a simple form such as subprogram invocation to more complex forms such as task communication and data abstraction. This paper presents an approach to the modeling of module invocation based performance dependencies among program entities for Ada1 programs. This approach is based on an extended program invocation graph model. In this model, an Ada program is analyzed and partitioned into primitive program entities that will be mapped into vertices of this graph mod...

Abstract: An active database is a database in which some operations are automatically executed when specified events happen and particular conditions are met. Several systems which support active rules in an object-oriented data model have been proposed. However, many issues related to the integration of triggers with object-oriented modeling concepts have been devoted so far limited attention and still need investigation. In this paper, we discuss the problems related to trigger inheritance and refinement in the context of the Chimera active object-oriented data model.