Dorothy is an integrated 3D/robotics educational tool created by augmenting the Alice programming environment for teaching core computing skills to students without prior programming experience. The tool provides a drag and drop interface to create graphical routines in virtual worlds; these routines are automatically translated into code to provide a real-time or offline enactment on mobile robots in the real world. This paper summarizes the key capabilities of Dorothy, and describes the contributions made to: (a) enhance the bidirectional communication between the virtual interface and robots; and (b) support multirobot collaboration. Specifically, we describe the ability to automatically revise the virtual world based on sensor data obtained from robots, creating or deleting objects in the virtual world based on their observed presence or absence in the real world. Furthermore, we describe the use of visually observed behavior of teammates for collaboration between robots when they cannot communicate with each other. Dorothy thus helps illustrate sophisticated algorithms for fundamental challenges in robotics and AI to teach advanced computing concepts, and to emphasize the importance of computing in real world applications, to beginning programmers.

This paper presents a formal specification of the Assurance Point (AP) web service composition model. The AP model provides a flexible way of checking constraints and responding to execution errors in service composition. An AP is a combined logical and physical checkpoint, providing an execution milestone that stores critical data and interacts with integration rules (IRs) to alter program flow and to invoke different forms of recovery depending on the execution status. In this paper, the execution and recovery semantics of assurance points have been fully defined in the context of if-else, parallel, and loop control structures. The activities and complex control structures of the AP model have been formalized and tested in the Yet Another Workflow Language (YAWL) engine. By doing so, the correctness of the execution and recovery semantics in the AP model has been verified, demonstrating that YAWL nets of the AP model satisfy the soundness property. Different from existing web service composition models, the AP model presented by this research provides multiple levels of protection against service execution failure with a combination of forward and backward recovery techniques.

This paper presents a recovery algorithm for service execution failure in the context of concurrent process execution. The recovery algorithm was specifically designed to support a rule-based approach to user-defined correctness in execution environments that support a relaxed form of isolation for service execution. Data dependencies are analyzed from data changes that are extracted from database transaction log files and generated as a stream of deltas from Delta-Enabled Grid Services. The deltas are merged by time stamp to create a global schedule of data changes that, together with the process execution context, are used to identify processes that are read and write dependent on failed processes. Process interference rules are used to express semantic conditions that determine if a process that is dependent on a failed process should recover or continue execution. The recovery algorithm integrates a service composition model that supports nested processes, compensation, contingency, and rollback procedures with the data dependency analysis process and rule execution procedure to provide a new approach for addressing consistency among concurrent processes that access shared data. We present the recovery algorithm and also discuss our results with simulation and evaluation of the concurrent process recovery algorithm.

Undergraduate research is becoming increasingly common in colleges and universities, and, to support this, there is a need to have best practices and forums for promoting exchange of ideas. In particular, a working group at a recent National Science Foundation (NSF) Computer and Information Science and Engineering (CISE) Research Experiences for Undergraduates (REU) sites PI's meeting identified four important issues in undergraduate research: 1) how to design a good research project, 2) how to prepare students for research, 3) how to measure outcomes of undergraduate research and 4) incentives for undergraduates to publish as result of their participation in research. The panelists have all served as PIs or Co-PIs on NSF REU projects in computing and have mentored many undergraduates in a large variety of research projects both in REU settings as well as during the regular academic year. They will each address one of the issues identified above, and share their expertise in addressing the issue, providing solid guidance to anyone interested in promoting undergraduate research. A significant amount of time will be set aside for audience participation and discussion.

This research presents a benchmark for the evaluation of active rules within a distributed component integration environment. The benchmark is based on the OBJECTIVE active database benchmark. Our work was specifically performed in the context of the Integration Rules (IRules) project that uses active rules for the integration of distributed software components, which are based on the Enterprise JavaBeans component model. In addition to mapping the test rules of the OBJECTIVE benchmark to the integration rules of the IRules system, we have extended the OBJECTIVE benchmark to test additional features of a component-based active rule system, such as the event detection time, the rule execution time related to the invocation of methods on components, asynchronous coupling modes, and the rule processor execution time under a heavy event load. Although the research presents specific performance evaluation results for the IRules project, the approach more generally demonstrates the manner in which an existing rule processing benchmark for a centralized environment can be adapted and extended for use in a rule-based approach to distributed component integration.

The relationship between XML and database management systems has become an important topic for coverage at the undergraduate level. This paper presents an approach to teaching the use of XML through the study of data exchange. After a brief review of XML, the paper provides a tutorial on the different features that are provided in major relational database products for the import and export of XML, providing a discussion of how these features can be used as implementation exercises for students. In addition to addressing the use of XML for data exchange in relational systems, the paper also provides an overview of several teaching tools that are also used in the study of XML for object-oriented data and also for the exchange of object-oriented and object-relational data.

This paper illustrates the manner in which UML can be used to study mappings to different types of database systems. After introducing UML through a comparison to the EER model, UML diagrams are used to teach different approaches for mapping conceptual designs to the relational model. As we cover object-oriented and object-relational database systems, different features of UML are used over the same enterprise example to help students understand mapping alternatives for each model. Students are required to compare and contrast the mappings in each model as part of the learning process. For object-oriented and object-relational database systems, we address mappings to the ODMG and SQL99 standards in addition to specific commercial implementations.

Delta abstractions are introduced as a mechanism for managing database states during the execution of active database rules. Delta abstractions build upon the use of object deltas, capturing changes to individual objects through a system-supported, collapsible type structure. The object delta structure is implemented using object-oriented concepts such as encapsulation and inheritance so that all database objects inherit the ability to transparently create and manage delta values. Delta abstractions provide an additional layer to the database programmer for organizing object deltas according to different language components that induce database changes, such as methods and active rules. As with object deltas, delta abstractions are transparently created and maintained by the active database system. We define different types of delta abstractions as views of object deltas and illustrate how the services of delta abstractions can be used to inspect the state of active rule execution. An active rule analysis and debugging tool has been implemented to demonstrate the use of object deltas and delta abstractions for dynamic analysis of active rules at runtime.

This paper describes the design and functionality of courseware developed to demonstrate the JDBC API. The courseware is used in an advanced undergraduate database course that emphasizes the use of Web access to database systems. The JDBC courseware is written using Java Servlets and Java Server Pages, allowing the user to view the metadata associated with a database, to view and browse the information in a database according to the database metadata, and to query and/or manipulate data using SQL statements. The advantage of the courseware is that it demonstrates the main functionality of the JDBC API in an application-independent manner. The courseware can access any ODBC-compliant database, emphasizing the generality of the JDBC API and helping students understand how JDBC can be used to query the metadata of the database as well as the database contents.

This paper describes the design and functionality of a graphical user interface (GUI) written in Java Swing that is used to support instructional activities associated with teaching object-oriented database (OODB) concepts. The GUI supports the manipulation of objects in an OODB, assuming the implementation of a specified interface for interacting with an OODB. By using the interface, students can focus on object-oriented design and programming concepts associated with OODB concepts rather than the development of a user interface. Since the GUI uses the Extensible Markup Language (XML) for defining the database schema and data import/export, the use of the GUI provides the added benefit of demonstrating the manner in which XML interacts with database technology.

This paper describes the development of a second database course for undergraduates, preparing students for the advanced database concepts they will experience in industry. Assuming an introductory course on relational database systems as a prerequisite, the topics addressed in the course include object-oriented data modeling, object-oriented database systems, object-relational database systems, Web access to databases, and professionalism and ethics. We present our experience with teaching the course, elaborating on the topics and assignments. We also present feedback from students and industry partners as well as our own assessment of future course refinements.

The recent emergence of object-relational technology into the commercial database market has caused new challenges for the implementation of conceptual database designs. This paper presents our experience with using the Oracle 8 object-relational data model in the implementation of an engineering application described using the EXPRESS conceptual modeling language. EXPRESS is part of the engineering community's Standard for the Exchange of Product Data and can be characterized as a structurally object-oriented modeling language, supporting the notion of entities, entity hierarchies, complex constraints on entity hierarchies, relationships and inverse relationships between entities, and user-defined types. As a result, EXPRESS provides an excellent framework for studying the mapping of conceptual modeling concepts into an object-relational model. In this paper, we describe the way in which the features of EXPRESS can be mapped into object-relational features such as object tables, object references, and nested tables. We also describe the manner in which features such as member functions on object types, triggers, and stored procedures can be used to support the implementation of constraints associated with a conceptual schema. Although the mappings presented are specific to EXPRESS and Oracle 8, the mappings are generalizable to conceptual modeling languages and object-relational models with similar features. Our work defines how traditional mapping concepts must be revised in order to make adequate use of the features now found in object-relational models. As part of this paper, we also compare our mapping approach using Oracle 8 to mapping issues for the PostgreSQL object-relational model and the Objectivity/DB object-oriented data model. Copyright © 2000 John Wiley & Sons, Ltd.

Many computer applications today require some form of distributed computing to allow different software components to communicate. Several different commercial products now exist based on the Common Object Request Broker Architecture (CORBA) of the Object Management Group. The use of such tools, however, often requires the modification of existing systems, rather than the development of new applications. The objective of this research has been to integrate the use of a CORBA tool into an existing engineering design application for the purpose of (1) evaluating the amount of re-engineering that is involved to effectively integrate distributed object computing into an existing application, and (2) evaluating the use and performance of distributed object computing in an engineering domain, which often requires the transfer of large amounts of information. The results of this work demonstrate that CORBA technology can be easily integrated into existing applications. The ease of the integration as well as the efficiency of the resulting system, however, depends upon the degree of modification that developers are willing to consider in the re-engineering process. The most transparent approach to the use of CORBA requires less modification and generally produces less efficient performance. The less transparent approach to the use of CORBA can potentially require significant system modification but produce greater performance gains. This work outlines issues that must be considered for the partitioning of functionality between the client and the server, development of an IDL interface, development of client and server-side wrappers, and support for concurrent, multi-user access. In addition, this work also provides performance and implementation comparisons of different techniques for the use of wrappers and for the transfer of large data files between the client and the server. Performance comparisons for the incorporation of concurrent access are also presented. Copyright © 1999 John Wiley & Sons, Ltd.

Integrating the practical use of a database product into the theoretical curriculum of a database management course is a challenge, The approach described minimizes the amount of class time that is allocated to teaching students the use of a database product, while providing guidance to the students in the use of the tool.Introduction of the database product is accomplished through cooperative learning, where students help each other learn the intricacies of the system.To facilitate this process, the students are provided with a complete database implementation example.Using this example, students gradually advance from a tutorial exercise, to a step-by-step extension of the example, and finally to more difficult extensions.These self-paced assignments provide a solid foundation for the students' knowledge in the implementation of their own cooperative group project. MicrosoftAccess, Version 2.0.

This research extends an existing framework for translating global queries over a heterogeneous network of databases, focusing on the consolidation of query results and the resolution of semantic differences between component databases and the global schema. The research uses an object-oriented database for the global platform and a self-describing global schema as a means for providing access to database information. During query consolidation, query results are read into object classes along with the metadata needed to resolve the semantic differences. Through encapsulated procedures, query results are transformed and merged into the global format. This research identifies the information needed in the global schema for resolution of semantic heterogeneity during consolidation of query results.

Presents the notion of refined triggering graphs (RTG) for analyzing termination of active rules in object-oriented databases (OODBs). The RTG method consists of mapping the possibility that one active rule can trigger another to the satisfiability of a well-defined logic formula called a triggering formula. The unsatisfiability of the triggering formula is then an indication that the rule triggering possibility is nil. We identify three increasingly more powerful types of triggering formulae and give pointers to the corresponding satisfiability procedures.

lhis paper describes the use of cooperative group learning concepts in support of an undergraduate database mrtnagement course that emphasizes the theoretical and practical aspects of database application development.'Ihe course project is divided into three main phases, involving requirements analysis and conceptual design, relational database mapping and prototyping, and database system implementation using Microsoft Access.The project deliverables are designed so that students not only develop a database implementation, but also evaluate their design in terms of functional dependencies, normal forms, the lossless join property, and the dependency preservation property, thus establishing the need for sound database design principles.Students are required to actively participate in each phase, with students assuming different roles in each phase to allow them to experience different leadership responsibilities.As part of the grading process, students evaluate their own performance as well as the perfomce of others in the group.This paper describes our experience with the structure and administration of cooperative groups and provides a discussion of the lessons we have learned, including initial observations of the effectiveness of the approach.

This paper describes the communications component of a multidatabase environment for engineering design. The environment uses the STEP (Standard for the Exchange of Product Data) product model as a global conceptual view of data that exists within CAD tools. The meta data component stores information about the global view of the design and serves as an interface description repository. The communications component then uses the interface description repository to dynamically build operation calls. Interface and operation descriptions can easily be modified and new descriptions can be added to the environment at any time. The flexibility provided by this approach enhances interoperability among the tools of the environment and makes it easy to configure different sets of design tools.>

Presents an approach to query processing in a multidatabase system that uses an object-oriented model to capture the semantics of other data models. The object-oriented model is used to construct a global schema, defining an integrated view of the different schemas in the environment. The model is also used as a self-describing model to build a meta-database for storing information about the global schema. A unique aspect of this work is that the object-oriented model is used to describe the different data models of the multidatabase environment, thereby extending the meta-database with semantic information about the local schemas. Structural mappings between the global schema and each local schema are then easily supported. An object algebra provides a query language for expressing global queries, using the structural mappings to translate object algebra queries into SQL queries over local relational schema The object algebra can be used to directly retrieve temporarily-stored data from the object-oriented database or to transparently retrieve data from local sources using the translation process described in this paper.>

A framework for supporting ad-hoc declarative update requests in an object-oriented database (OODB) while maintaining database consistency and atomicity of update requests is described. The framework is based on the emulation of classic update methods in an OODB by a controlled, active, and user-transparent interaction between a predefined set of elementary updates and a set of integrity methods designed to maintain database consistency upon violations of integrity constraints. Given an object-oriented data model and a declarative query language, this framework is extended by isolating declaratively stated integrity constraints as a separate concept, developing a high-level update language on top of the query language, and developing active integrity methods from the integrity constraints. The advantage of this approach is that users can freely pose declarative ad-hoc updates without jeopardizing database consistency.>

The authors present the design of ORL, an object retrieval language interface to the EQUAL object algebra. ORL has an extended SQL syntax and is implemented on top of the ONTOS object-oriented database system. The complete system provides an interactive query facility as an alternative to the programatic OSQL interface provided by ONTOS. In general, ORL provides a more concise, user-friendly approach to the expression of queries over objects than the object algebra on which it is based. The translation of ORL queries to their equivalent object algebra expressions is described.>

The authors describe an approach to the declarative representation of integrity constraints in an object-oriented database and the use of integrity maintenance rules for the active maintenance of constraints. A semantic data model is used to automatically generate class definitions and state-altering database operations with constraints represented as objects in the database. Integrity maintenance production rules are automatically generated from constraints and stored as extensions to class operations, hiding the details of constraint checking and rule triggering. High-level transactions call state-altering operations and invoke the integrity maintenance process at commit time. Integrity constraints are declaratively represented in the database system, with operations encapsulating rules about how to respond to constraint violations. An analysis of problems associated with cyclic and anomalous rule behavior.>

The notion of object-centered (O-C) constraints, a subset of range-restricted Horn clauses with existential variables is presented. O-C constraints correspond, intuitively, to sets of clauses that involve connected objects or objects that can be located through navigation. Other types of constraints, e.g. transition or other temporal constraints are not specifically addressed. The research philosophy adopted is that such constraints can be expressed by introducing additional constructs into the schema, e.g. old-Student or new-Student and then expressing constraints in the same manner as the O-C constraints. This approach is conceptually accurate; it provides a uniform method for expressing and enforcing constraints using generalized constraint analysis. It allows the user to precisely describe the intended semantics, e.g. when to delete the old values after an update. This philosophy basically states that database constraints necessarily constrain database objects; in order to address additional issues like old/new values, the additional structures should be brought into the purview of the database by defining them in the database schema.>

A design process for an object-oriented database design environment, known as constraint analysis, is presented. Given the increased level of semantics associated with an object-oriented database schema, constraint analysis makes use of semantics expressed as database constraints to support the flexible specification of propagation actions for operations on objects. Constraints are formally represented using Horn logic. The constraint analysis process then reasons about constraints at design time to help the designer understand the effects of constraints on object manipulation, identifying possible constraint violations as well as design alternatives for handling violations. An advantage of constraint analysis is that both inherent and explicit schema constraints are included in the analysis process. A formal representation is given that supports the analysis of constraints and the automatic identification of design alternatives for responding to constraint violations.>

A declarative constraint language, ALICE, for the expression of complex, logic-based constraints in an object-oriented database environment is presented. The translation of ALICE constraints to logic was developed to support a design approach that uses techniques from deductive databases to explain constraints at design time and to specify propagation actions. Two different translations for ALICE constraints are described: one that allows a relaxed interpretation in the presence of null values and one that enforces a stricter interpretation in which the use of null values is limited. An important contribution of ALICE is that the formal, declarative nature of the language forms the basis of a constraint management facility for intelligent object-oriented database environments.>

An approach known as constraint analysis is presented for specifying updatable perspectives of class objects in an object-oriented data schema. Perspectives provide a way of defining the scope of a user's view of a schema. Operations on class objects are then defined in terms of specific perspectives based on the semantics associated with the schema. Schema semantics are represented as a set of integrity constraints expressed in Horn logic. The constraint analysis process then reasons about schema constraints to support a flexible approach to update propagation. The advantage of constraint analysis is that both inherent and explicit constraints can be used to support the automated specification of updatable perspectives that preserve object integrity. >

This paper presents the notion of forming user perspectives over a semantic schema. Perspectives are a mechanism for providing user-oriented views of abstract objects. The perspectives of interest to each user group are collected into user views to provide a modularization tool for semantic schemas. A novel aspect of the approach to forming perspectives is that the semantics expressed within a schema are actively used to present design alternatives in the formation of perspectives and in the manner in which exception violations are handled. As a result, perspectives and their associated update operations are developed in a manner that conforms to the integrity constraints of the underlying semantic schema.

Semantic data models have been influenced by abstraction techniques used in knowledge representation. Early semantic models concentrated on the structural aspects of an application. More recently, researchers in semantic modeling have realized the importance of capturing the dynamic and temporal aspects of an application as well. This paper presents a detailed and uniform analysis of the structural, dynamic, and temporal aspects of object-oriented semantic models that support classification, aggregation, generalization, and association abstractions.

This paper describes an approach to software specification development with interpretation as applied to an information storage and retrieval system. Machine execution of software specifications is possible with both partial and complete specifications. A partial specification is interpreted using abstract execution. The Descartes specification language is utilized to describe a functional aspect of an existing information storage and retrieval system, namely, the MADAM (Multics Approach to Data Access and Management) system at the University of Southwestern Louisiana. Brief descriptions of both the Descartes language and the MADAM system precede the example specification. The paper concludes with a discussion of the expected results that this methodology could have on the pragmatic development and evolution of information systems.

This paper describes an approach to software specification development with interpretation as applied to an information storage and retrieval system. Machine execution of software specifications is possible with both partial and complete specifications. A partial specification is interpreted using abstract execution. The Descartes specification language is utilized to describe a functional aspect of an existing information storage and retrieval system, namely, the MADAM (Multics Approach to Data Access and Management) system at the University of Southwestern Louisiana. Brief descriptions of both the Descartes language and the MADAM system precede the example specification. The paper concludes with a discussion of the expected results that this methodology could have on the pragmatic development and evolution of information systems.