Albert Tort

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.

An approach to test-driven development of conceptual schemas

Test-Driven Development (TDD) is an extreme programming development method in which a software system is developed in short iterations. In this paper we present the Test-Driven Conceptual Modeling (TDCM) method, which is an application of TDD for conceptual modeling, and we show how to develop a conceptual schema using it. In TDCM, a systems conceptual schema is incrementally obtained by performing three kinds of tasks: (1) Write a test the system should pass; (2) Change the schema to pass the test; and (3) Refactor the schema to improve its qualities. We also describe an integration approach of TDCM into a broad set of software development methodologies, including the Unified Process development methodology, the MDD-based approaches, the storytest-driven agile methods and the goal and scenario-oriented requirements engineering methods. We deal with schemas written in UML/OCL, but the TDCM method could be adapted to the development of schemas in other languages.

Fixing Up Non-executable Operations in UML/OCL Conceptual Schemas

An operation is executable if there is at least one information base in which its preconditions hold and such that the new information base obtained from applying its postconditions satisfies all the integrity constraints. A non-executable operation is useless since it may never be applied. Therefore, identifying non-executable operations and fixing up their definition is a relevant task that should be performed as early as possible in software development. We address this problem in the paper by proposing an algorithm to automatically compute the missing effects in postconditions that would ensure the executability of the operation.

A computer-guided approach to website Schema.org design

Schema.org offers to web developers the opportunity to enrich a website’s content with microdata and schema.org. For large websites, implementing microdata can take a lot of time. In general, it is necessary to perform two main activities, for which we lack methods and tools. The first consists in designing what we call the website schema.org, which is the fragment of schema.org that is relevant to the website. The second consists in adding the corresponding microdata tags to the web pages. In this paper, we describe an approach to the design of a website schema.org. The approach consists in using a human-computer task-oriented dialogue, whose purpose is to arrive at that design. We describe a dialogue generator that is domain-independent, but that can be adapted to specific domains. We propose a set of six evaluation criteria that we use to evaluate our approach, and that could be used in future approaches.

Computing repairs for constraint violations in UML/OCL conceptual schemas

Updating the contents of an information base may violate some of the constraints defined over the schema. The classical way to deal with this problem has been to reject the requested update when its application would lead to some constraint violation. We follow here an alternative approach aimed at automatically computing the repairs of an update, i.e., the minimum additional changes that, when applied together with the requested update, bring the information base to a new state where all constraints are satisfied. Our approach is independent of the language used to define the schema and the constraints, since it is based on a logic formalization of both, although we apply it to UML and OCL because they are widely used in the conceptual modeling community.Our method can be used for maintaining the consistency of an information base after the application of some update, and also for dealing with the problem of fixing up non-executable operations. The fragment of OCL that we use to define the constraints has the same expressiveness as relational algebra and we also identify a subset of it which provides some nice properties in the repair-computation process. Experiments are conducted to analyze the efficiency of our approach.

An approach to website schema.org design

Schema.org offers to web developers the opportunity to enrich a websites content with microdata and schema.org. For large websites, implementing microdata can take a lot of time. In general, it is necessary to perform two main activities, for which we lack methods and tools. The first consists in designing what we call the website schema.org, which is the fragment of schema.org that is relevant to the website. The second consists in adding the corresponding microdata tags to the web pages. In this paper, we describe an approach to the design of a website schema.org. The approach consists in using a human-computer task-oriented dialogue, whose purpose is to arrive at that design. We describe a dialogue generator that is domain independent but that can be adapted to specific domains. We propose a set of six evaluation criteria that we use to evaluate our approach and that could be used in future approaches.

On Checking Executable Conceptual Schema Validity by Testing

Ensuring the semantic quality of a conceptual schema is a fundamental goal in conceptual modeling. Conceptual schema testing is an emerging approach that helps to achieve this goal. In this paper, we focus on “what to test” and, more specifically, on the properties that test sets of conceptual schemas should have. We propose and formally define a set of four adequacy criteria which can be automatically checked in order to ensure, by testing, the necessary conditions for schema validity (correctness and relevance). The proposed criteria are independent from the languages of the schema and of the testing program. The criteria have been implemented in a prototype of a test processor able to execute test sets. The criteria have been applied to the test sets of large conceptual schemas.

Former Students' Perception of Improvement Potential of Conceptual Modeling in Practice

Several authors have pointed out a significant gap between Conceptual Modeling CM theory and practice. It is then natural that we try to find answers to questions such as: What is the nature of the gap? Which is the magnitude of the gap? Why does the gap exist? and What could be done to narrow the gap? In this paper, we try to answer those questions from the point of view of the former students of a Requirements Engineering and Conceptual Modeling course that have been involved in professional projects. We have surveyed over 70 former students to know how they perceive the degree to which a set of four conceptual modeling artifacts are created in practice, and how they perceive the improvement potential of the creation of those artifacts in practice. For each artifact, we asked a question on the use of the artifact, and one on the recommendation of use of the artifact. We try to identify the reasons why the artifacts were not created, and what would be needed to convince stakeholders and developers to create the artifact, when it is recommended to do it.

Former students' views on the usefulness of conceptual modeling education

A big challenge for education and research in Requirements Engineering and Conceptual Modeling (RE/CM) is the need for much more empirical research about the use in practice of RE/CM, including the practical impact of CM education. Former students of RE/CM are potential prescriptors of the RE/CM concepts, methodologies and tools that they have learnt, but they are also conditioned by the current use of those same issues in practice. In this paper we focus on the views that former students of a RE/CM course have, now as young professionals, on the usefulness of the received CM education. We have surveyed over 70 former students to know their opinions on the usefulness of the education on a representative set of CM artifacts. Our results show that our former students find quite useful in general their received CM education, with different usefulness degrees for the various learned artifacts.

Testing Conceptual Schema Satisfiability

Satisfiability is one of the properties that all conceptual schemas must have. Satisfiability applies to both the structural and the behavioral parts of a conceptual schema. Structurally, a conceptual schema is satisfiable if each base or derived entity and relationship type of the schema may have a non-empty population at certain time. Behaviorally, a conceptual schema is satisfiable if for each event type there is at least one consistent state of the information base and one event of that type with a set of characteristics such that the event constraints are satisfied, and the effects of the event leave the information base in a state that is consistent and satisfies the event postconditions. There has been a lot of work on automated reasoning procedures for checking satisfiability but it is well known that the problem of reasoning with integrity constraints and derivation rules in its full generality is undecidable. In this chapter, we explore an alternative approach to satisfiability checking, which can be used when conceptual schemas are developed in the context of an environment that allows their testing. The main contribution of this chapter is to show that when conceptual schemas can be tested then their satisfiability can be proved by testing.