Antoni Olivé

Conceptual Modeling - ER 2006

Keynote Papers.- Suggested Research Directions for a New Frontier - Active Conceptual Modeling.- From Conceptual Modeling to Requirements Engineering.- Web Services.- A Context Model for Semantic Mediation in Web Services Composition.- Modeling Service Compatibility with Pi-calculus for Choreography.- The DeltaGrid Abstract Execution Model: Service Composition and Process Interference Handling.- Quality in Conceptual Modeling.- Evaluating Quality of Conceptual Models Based on User Perceptions.- Representation Theory Versus Workflow Patterns - The Case of BPMN.- Use Case Modeling and Refinement: A Quality-Based Approach.- Aspects of Conceptual Modeling.- Ontology with Likeliness and Typicality of Objects in Concepts.- In Defense of a Trope-Based Ontology for Conceptual Modeling: An Example with the Foundations of Attributes, Weak Entities and Datatypes.- Explicitly Representing Superimposed Information in a Conceptual Model.- Modeling Advanced Applications.- Preference Functional Dependencies for Managing Choices.- Modeling Visibility in Hierarchical Systems.- A Model for Anticipatory Event Detection.- XML.- A Framework for Integrating XML Transformations.- Oxone: A Scalable Solution for Detecting Superior Quality Deltas on Ordered Large XML Documents.- Schema-Mediated Exchange of Temporal XML Data.- A Quantitative Summary of XML Structures.- Semantic Web.- Database to Semantic Web Mapping Using RDF Query Languages.- Representing Transitive Propagation in OWL.- On Generating Content and Structural Annotated Websites Using Conceptual Modeling.- Requirements Modeling.- A More Expressive Softgoal Conceptualization for Quality Requirements Analysis.- Conceptualizing the Co-evolution of Organizations and Information Systems: An Agent-Oriented Perspective.- Towards a Theory of Genericity Based on Government and Binding.- Aspects of Interoperability.- Concept Modeling by the Masses: Folksonomy Structure and Interoperability.- Method Chunks for Interoperability.- Domain Analysis for Supporting Commercial Off-the-Shelf Components Selection.- Metadata Management.- A Formal Framework for Reasoning on Metadata Based on CWM.- A Set of QVT Relations to Assure the Correctness of Data Warehouses by Using Multidimensional Normal Forms.- Design and Use of ER Repositories: Methodologies and Experiences in eGovernment Initiatives.- Human-Computer Interaction.- Notes for the Conceptual Design of Interfaces.- The User Interface Is the Conceptual Model.- Towards a Holistic Conceptual Modelling-Based Software Development Process.- Business Modeling.- A Multi-perspective Framework for Organizational Patterns.- Deriving Concepts for Modeling Business Actions.- Towards a Reference Ontology for Business Models.- Reasoning.- Reasoning on UML Class Diagrams with OCL Constraints.- On the Use of Association Redefinition in UML Class Diagrams.- Optimising Abstract Object-Oriented Database Schemas.- Panels.- Experimental Research on Conceptual Modeling: What Should We Be Doing and Why?.- Eliciting Data Semantics Via Top-Down and Bottom-Up Approaches: Challenges and Opportunities.- Industrial Track.- The ADO.NET Entity Framework: Making the Conceptual Level Real.- XMeta Repository and Services.- IBM Industry Models: Experience, Management and Challenges.- Community Semantics for Ultra-Scale Information Management.- Managing Data in High Throughput Laboratories: An Experience Report from Proteomics.- Policy Models for Data Sharing.- Demos and Posters.- Protocol Analysis for Exploring the Role of Application Domain in Conceptual Schema Understanding.- Auto-completion of Underspecified SQL Queries.- iQL: A Query Language for the Instance-Based Data Model.- Designing Under the Influence of Speech Acts: A Strategy for Composing Enterprise Integration Solutions.- Geometry of Concepts.

Updating knowledge bases while maintaining their consistency

When updating a knowledge base, several problems may arise. One of the most important problems is that of integrity constraints satisfaction. The classic approach to this problem has been to develop methods forchecking whether a given update violates an integrity constraint. An alternative approach consists of trying to repair integrity constraints violations by performing additional updates thatmaintain knowledge base consistency. Another major problem in knowledge base updating is that ofview updating, which determines how an update request should be translated into an update of the underlying base facts. We propose a new method for updating knowledge bases while maintaining their consistency. Our method can be used for both integrity constraints maintenance and view updating. It can also be combined with any integrity checking method for view updating and integrity checking. The kind of updates handled by our method are: updates of base facts, view updates, updates of deductive rules, and updates of integrity constraints. Our method is based on events and transition rules, which explicity define the insertions and deletions induced by a knowledge base update. Using these rules, an extension of the SLDNF procedure allows us to obtain all possible minimal ways of updating a knowledge base without violating any integrity constraint.

Conceptual schema-centric development: a grand challenge for information systems research

The goal of automating information systems building was stated in the sixties. Forty years later it is clear that the goal has not been achieved in a satisfactory degree. One of the problems has been the lack of standards in languages and platforms. In this respect, the recent efforts on standardization provide an opportunity to revive the automation goal. This is the main purpose of this paper. We have named the goal “conceptual schema-centric development” (CSCD) in order to emphasize that the conceptual schema should be the center of the development of information systems. We show that to develop an information system it is necessary to define its conceptual schema and that, therefore, the CSCD approach does not place an extra burden on developers. In CSCD, conceptual schemas would be explicit, executable in the production environment and the basis for the system evolution. To achieve the CSCD goal it is necessary to solve many research problems. We identify and comment on a few problems that should be included in a research agenda for CSCD. Finally, we show that the CSCD goal can be qualified as a grand challenge for the information systems research community.

Modeling events as entities in object-oriented conceptual modeling languages

Most current conceptual modeling languages and methods do not model events as entities. We argue that, at least in object-oriented (O-O) languages, modeling events as entities provides substantial benefits. We show that a method for behavioral modeling that deals with event and entity types in a uniform way may yield better behavioral schemas. The proposed method makes extensive use of language constructs such as constraints, derived types, derivation rules, type specializations and operations, which are present in all complete O-O conceptual modeling languages. The method can be adapted to most O-O languages. In this paper we explain its adaptation to the UML.

Advanced Conceptual Modeling Techniques

A workflow management system (WfMS) is a software system that supports the coordinated execution of different simple activities, assigning them to human or automatic executors, to achieve a common goal defined for a business process. Temporal aspects of stored information cannot be neglected and the adoption of a temporal database management system (TDBMS) could benefit. By this paper we scratch the surface of the topic related to the use of a TDBMS in a WfMS, identifying some advantages in managing temporal aspects by a TDBMS inside some of the components of a WfMS. E.g., queries to reconstruct the schema of the business process or to assign activities to executors balancing their workload over time, or the definition of constraints among tasks can benefit from the use of a TDBMS.

An approach to testing conceptual schemas

Conceptual schemas of information systems can be tested. The testing of conceptual schemas may be an important and practical means for their validation. We present a list of five kinds of tests that can be applied to conceptual schemas. Two of them require schemas comprising both the structural and the behavioral parts, but we show that it is possible and useful to test incomplete schema fragments, even if they consist of only a few entity and relationship types, integrity constraints and derivation rules. We present CSTL, a language for writing automated tests of executable schemas written in UML/OCL. CSTL includes language primitives for each of the above kinds of tests. CSTL follows the style of the modern xUnit testing frameworks. We describe a prototype implementation of a test processor, which includes a test manager and a test interpreter that coordinates the execution of the tests. Tests written in CSTL can be executed as many times as needed.

The Events Method for View Updating in Deductive Databases

We propose a new method for view updating in deductive databases. The method is based on events and transition rules, which explicitly define the insertions and deletions induced by a database update. Using these rules, an extension of the SLDNF procedure allows us to obtain all valid translations of view update requests. The main advantages of the method are its simplicity, the uniform treatment of insert and delete requests and the integration of integrity checking during the derivation process. The method has the full power of the methods developed so far, without some of their limitations.

A method for pruning ontologies in the development of conceptual schemas of information systems

In the past, most conceptual schemas of information systems have been developed essentially from scratch. Currently, however, several research projects are considering an emerging approach that tries to reuse as much as possible the knowledge included in existing ontologies. Using this approach, conceptual schemas would be developed as refinements of (more general) ontologies. However, when the refined ontology is large, a new problem that arises using this approach is the need of pruning the concepts in that ontology that are superfluous in the final conceptual schema. This paper proposes a new method for pruning ontologies in this approach. We also show how to adapt the method to prune ontologies in other contexts. Our method is general and it can be adapted to most conceptual modeling languages. We give the complete details of its adaptation to the UML. On the other hand, the method is fully automatic. The method has been implemented. We illustrate the method by means of its application to a case study that refines the Cyc ontology.

Integrity Constraints Definition in Object-Oriented Conceptual Modeling Languages

We propose two new methods for the definition of integrity constraints in object-oriented conceptual modeling languages. The first method applies to static constraints, and consists in representing them by special operations, that we call constraint operations. The specification of these operations is then the definition of the corresponding constraints. The second method, which is a slight variant of the previous one, applies to creation-time constraints, a particular class of temporal constraints. Both methods allow the specialization of constraints and the definition of exceptions. We include also an adaptation of the two methods to the UML.

Building Conceptual Schemas by Refining General Ontologies

In practice, most conceptual schemas of information systems and databases are developed essentially from scratch. This paper deals with a new approach to that development, consisting on the refinement of a general ontology. We identify and characterize the three activities required to develop a conceptual schema from a general ontology, that we call refinement, pruning and refactoring. The focus of the paper is on the differences of the new approach with respect to the traditional one. The pruning activity may be automated. We formalize it and present a method for its realization. Besides, we identify a particular problem that appears during the refactoring activity, determining whether two types are redundant, and provide two sufficient conditions for it. We illustrate the approach with the development of a conceptual schema by refinement of the Cyc ontology. However, our results apply to any general ontology. The conceptual modeling language we have used is the UML, but we believe that our results could be applied to any similar language.