Naser S. Barghouti

Concurrency control in advanced database applications

Concurrency control has been thoroughly studied in the context of traditional database applications such as banking and airline reservations systems. There are relatively few studies, however, that address the concurrency control issues of advanced database applications such as CAD/CAM and software development environments. The concurrency control requirements in such applications are different from those in conventional database applications; in particular, there is a need to support non-serializable cooperation among users whose transactions are long-lived and interactive, and to integrate concurrency control mechanisms with version and configuration control. This paper outlines the characteristics of data and operations in some advanced database applications, discusses their concurrency control requirements, and surveys the mechanisms proposed to address these requirements.

Preliminary experience with process modeling in the MARVEL software development environment kernel

The authors define a software development environment kernel called MARVEL. Implementing several prototypes and small environments has uncovered some significant flaws and revealed open design problems. Problems connected with the construction and debugging of a process model, with envelope construction, and with support of multiple users are considered. The authors note that they have investigated only a small fraction of the potential for rule-based process modeling and controlled automation. They observe that they do not yet fully understand how rule-based process modeling or controlled automation works and whether the combination is indeed a solid foundation for a software-development environment architecture.<<ETX>>

Rule chaining in Marvel: dynamic binding of parameters

Marvel is a software development environment that uses a rule-based model of the development process. When a user issues a command, Marvel invokes the corresponding rule and binds the rules formal parameter to the object selected by the user. If firing the rule changes the object in a way that satisfies the conditions of other rules, Marvel automatically fires each of these rules and tries to bind their formal parameters to objects. Marvel must infer which objects to bind to the formal parameters of the rules in the chain. A problem arises when the classes of the objects manipulated by the rules are different, because Marvel has to determine which object to bind to the parameter of each rule in the chain. Recursive data definitions cause chaining between rules that act on different objects in the same class. Methods developed to address this chaining problem are discussed. >

Scaling Up Rule-Based Software Development Environments

Rule-based software development environments (RBDEs) model the software development process in terms of rules that encapsulate development activities, and assist in executing the process via forward and backward chaining over the rule base. We investigate the scaling up of RBDEs to support (1) multiple views of the rule base for multiple users and (2) evolution of the rule base over the lifetime of a project. Our approach is based on clarifying two distinct functions of rules and chaining: maintaining consistency and automation. By definition, consistency is mandatory whereas automation is not. Distinguishing the consistency and automation aspects of RBDE assistance mechanisms makes it possible to formalize the range of compatible views and the scope of mechanizable evolution steps. Throughout the paper, we use the Marvel RBDE as an example application of our ideas.

SCALING UP RULE-BASED SOFTWARE DEVELOPMENT ENVIRONMENTS

Rule-based software development environments (RBDEs) model the software development process in terms of rules that encapsulate development activities, and assist in executing the process via forward and backward chaining over the rule base. We investigate the scaling up of RBDEs to support (1) multiple views of the rule base for multiple users and (2) evolution of the rule base over the lifetime of a project. Our approach is based on clarifying two distinct functions of rules and chaining: maintaining consistency and automation. By definition, consistency is mandatory whereas automation is not. Distinguishing the consistency and automation aspects of RBDE assistance mechanisms makes it possible to formalize the range of compatible views and the scope of mechanizable evolution steps. Throughout the paper, we use the MARVEL RBDE as an example application.

Implementation of a knowledge-based programming environment

MARVEL is a knowledge-based programming environment that assists its users during the implementation, testing, and maintenance phases of software projects. Solutions to the pragmatic problems of MARVELs implementation are discussed. MARVELs knowledge is supplied as strategies, where each strategy consists of classes that define the structure of objects, relations that define the semantic interconnections among objects, tools that define the processing that can be performed on objects to derive new objects, and rules that control the integration and automation of tools. The primary focus is the strategy language, its translator, and run-time support. An explanation is given of tool envelopes, which provide a mapping from the software objects defined in the current strategies to/from the file system representation expected by existing tools. The interactions between envelopes and the forward and backward chaining among the rules used to achieve controlled automation is described.<<ETX>>

Rule Chaining In MARVEL: Dynamic Binding Of Parameters

Marvel is a software development environment that uses a rule-based model of the development process. When a user issues a command, Marvel invokes the corresponding rule and binds the rules formal parameter to the object selected by the user. If firing the rule changes the object in a way that satisfies the conditions of other rules, Marvel automatically fires each of these rules and tries to bind their formal parameters to objects. Marvel must infer which objects to bind to the formal parameters of the rules in the chain. A problem arises when the classes of the objects manipulated by the rules are different, because Marvel has to determine which object to bind to the parameter of each rule in the chain. Recursive data definitions cause chaining between rules that act on different objects in the same class. Methods developed to address this chaining problem are discussed.<<ETX>>MARVEL is a rule-based development environment (RBDE) that assists in the process of developing software projects. MARVEL encapsulates each software development activity in a rule that specifies the condition for invoking the activity and effects on the components of the project under development. These components are abstracted as objects and stored in a persistent objectbase. Each rule applies to a specific class of objects, specified as the rules parameter. Firing a rule entails binding its formal parameter to a specific object. If the rule changes the object in such a way that the conditions of other rules become satisfied, these rules are automatically fired. A problem, arises when the classes of the objects manipulated by the rules are different, because MARVEL has to determine which object to bind to the parameter of each rule in the chain, based on the object manipulated by the original rule that initiated the chain. We describe both heuristic and algorithmic approaches for solving this problem.

Object-oriented data modeling in rule-based software development environments

Abstract Object-oriented databases (OODBs) were developed to support advanced applications for which traditional databases are not sufficient. The data management requirements of these new applications are significantly different from more traditional data processing applications. More light needs to be shed on these requirements in order to identify the aspects of OODBs that can lead to standards. We have studied the data management requirements of one class of advanced database applications: rule-based software development environments (RBDEs). RBDEs store project components in an object database and control access to these objects through a rule-based process model, which defines each development activity as a rule. The components are abstracted as instances of classes which are defined by the projects data model. In this paper we discuss the constructs that a data modeling language for RBDEs should provide, and then explore some of the data management requirements of RBDEs. We use the Marvel system we developed at Columbia as an example.

Preliminary Design of an Object Management System for Multi-User MARVEL

The object-oriented data model is reasonably rich, and supports object identity, classes treated as run-time types, multiple inheritance, overriding and late binding, set attributes of objects, and both composite objects and links among objects, but not full encapsulation - since the user interface displays the values of raw attributes. The “methods” are in the form of rules, with multiple objects as parameters, whose preconditions may iuvolve relatively complex queries, whose activity may update objects in both the hidden file system and externally, and whose postconditions may update objects in the in-meinory objectbase. The rule engine supports opportunistic backward and forward chaining among the rules to automate components of the software process. The user interface supports browsing and rather limited querying of the in-memory objectbase. Persistence and crash recovery is supported to some degree by checkpointing the entire in-memory objectbase after most update commands, but it is not feasible to checkpoint the file system.

Consistency and Automation in Multi-User Rule-Based Development Environments

We investigate the scaling up of a class of single-user software development environments, which we call rule-based development environments (RBDEs), to support multiple developers cooperating together on a project. RBDEs model the software development process in terms of rules that encapsulate activities, and execute forward and backward chaining on the rules to provide assistance in carrying out the development process. There is a spectrum of assistance models, ranging from pure automation to strict consistency preservation. We describe three problems whose solutions are dependent on the choice of assistance model: (1) multiple views; (2) evolution; and (3) concurrency control. We discuss how the two extremes of the spectrum restrict the possible approaches to multiple views and evolution. In order to explore different aspects of the concurrency control problem across multiple points on the spectrum of RBDEs, we develop a maximalist assistance model and propose an approach to synchronization of cooperating developers within the context of this model.