8,373 research outputs found
XML document design via GN-DTD
Designing a well-structured XML document is important for the sake of readability and maintainability. More importantly, this will avoid data redundancies and update anomalies when maintaining a large quantity of XML based documents. In this paper, we propose a method to improve XML structural design by adopting graphical notations for Document Type Definitions (GN-DTD), which is used to describe the structure of an XML document at the schema level. Multiples levels of normal forms for GN-DTD are proposed on the basis of conceptual model approaches and theories of normalization. The normalization rules are applied to transform a poorly designed XML document into a well-designed based on normalized GN-DTD, which is illustrated through examples
Discovery Agent : An Interactive Approach for the Discovery of Inclusion Dependencies
The information integration problem is a hard yet important problem in the field of databases. The goal of information integration is to provide unified views on diverse data among several resources. This subject has been studied for a long time. The integration can be performed using several ways. Schema integration using inclusion dependency constraints is one of them. The problem of discovering inclusion dependencies among input relations is NP-complete in terms of the number of attributes.
Two significant algorithms address this problem: FIND2 by Andreas Koeller and Zigzag by Fabien De Marchi. Both algorithms discover inclusion dependencies among input relations on small scale databases having relatively few attributes. Because of the data discrepancy, they do not scale well with higher numbers of attributes.
We propose an approach of incorporating human intelligence into the algorithmic discovery of inclusion dependencies. To use human intelligence, we design an agent called the discovery agent, to provide a communication bridge between an algorithm and a user. The discovery agent demonstrates the progress of the discovery process and provides sufficient user controls to govern the discovery process into the right direction. In this thesis, we present a prototype of the discovery agent based upon the FIND2 algorithm, which utilizes most of the phase-wise behavior of the algorithm and demonstrate how human observer and algorithm work together to achieve higher performance and better output accuracy.
The goal of the discovery agent is to make the discovery process truly interactive between system and user as well as to produce the desired and accurate result. The discovery agent can deliver an applicable and feasible approximation of an NP-complete problem with the help of suitable algorithm and appropriate human expertise
Free composition instead of language dictatorship
Historically, programming languages have been—benevolent—dictators: reducing all possible semantics to specific ones offered by a few built-in language constructs. Over the years, some programming languages have freed the programmers from the restrictions to use only built-in libraries, built-in data types, and builtin type-checking rules. Even though—arguably—such freedom could lead to anarchy, or people shooting themselves in the foot, the contrary tends to be the case: a language that does not allow for extensibility is depriving software engineers of the ability to construct proper abstractions and to structure software in the most optimal way. Therefore the software becomes less structured and maintainable than would be possible if the software engineer could express the behavior of the program with the most appropriate abstractions. The idea proposed by this paper is to move composition from built-in language constructs to programmable, first-class abstractions in a language. We discuss several prototypes of the Co-op language, which show that it is possible, with a relatively simple model, to express a wide range of compositions as first-class concepts
Requirements modelling and formal analysis using graph operations
The increasing complexity of enterprise systems requires a more advanced
analysis of the representation of services expected than is currently possible.
Consequently, the specification stage, which could be facilitated by formal
verification, becomes very important to the system life-cycle. This paper presents
a formal modelling approach, which may be used in order to better represent
the reality of the system and to verify the awaited or existing system’s properties,
taking into account the environmental characteristics. For that, we firstly propose
a formalization process based upon properties specification, and secondly we
use Conceptual Graphs operations to develop reasoning mechanisms of verifying
requirements statements. The graphic visualization of these reasoning enables us
to correctly capture the system specifications by making it easier to determine if
desired properties hold. It is applied to the field of Enterprise modelling
Exchange-Repairs: Managing Inconsistency in Data Exchange
In a data exchange setting with target constraints, it is often the case that
a given source instance has no solutions. In such cases, the semantics of
target queries trivialize. The aim of this paper is to introduce and explore a
new framework that gives meaningful semantics in such cases by using the notion
of exchange-repairs. Informally, an exchange-repair of a source instance is
another source instance that differs minimally from the first, but has a
solution. Exchange-repairs give rise to a natural notion of exchange-repair
certain answers (XR-certain answers) for target queries. We show that for
schema mappings specified by source-to-target GAV dependencies and target
equality-generating dependencies (egds), the XR-certain answers of a target
conjunctive query can be rewritten as the consistent answers (in the sense of
standard database repairs) of a union of conjunctive queries over the source
schema with respect to a set of egds over the source schema, making it possible
to use a consistent query-answering system to compute XR-certain answers in
data exchange. We then examine the general case of schema mappings specified by
source-to-target GLAV constraints, a weakly acyclic set of target tgds and a
set of target egds. The main result asserts that, for such settings, the
XR-certain answers of conjunctive queries can be rewritten as the certain
answers of a union of conjunctive queries with respect to the stable models of
a disjunctive logic program over a suitable expansion of the source schema.Comment: 29 pages, 13 figures, submitted to the Journal on Data Semantic
Creation dependencies of evolutionary artefact and design process knowledge
As design progresses, artefact and process knowledge often evolve together. However, there is very limited knowledge on the true nature of the dependencies between these two elements of knowledge. This paper presents the first attempt to clearly define 'creation' dependencies, which cause a change in design knowledge. Three data analyses were used to identify the dependencies: two were in-depth protocol analyses of a single student product design project and a senior ship designer’s daily work, and a third was a quantitative questionnaire analysis involving seven experienced complex system designers from industry. The analyses revealed a set of 52 previously unknown creation dependencies between artefact and design process knowledge with commonality found in only 5, with additional dependencies being identified that were specific to the design being studied. Different frequencies of dependency occurrence and particular dependency loops were identified. In addition, the importance and role of domain knowledge were explicitly revealed. The described research highlights the need for further work to provide a more comprehensive definition of the nature of evolutionary artefact and design process knowledge dependencies. Identification of these dependencies offers a significant opportunity to develop tools and techniques with an enhanced ability to support 'what–if' analyses during design
Liberating Composition from Language Dictatorship
Historically, programming languages have been—although benevolent—dictators: fixing a lot of semantics into built-in language constructs. Over the years, (some) programming languages have freed the programmers from restrictions to use only built-in libraries, built-in data types, or built-in type checking rules. Even though, arguably, such freedom could lead to anarchy, or people shooting themselves in the foot, the contrary tends to be the case: a language that does not allow for extensibility, is depriving software engineers from the ability to construct proper abstractions and to structure software in the most optimal way. Instead, the software becomes less structured and maintainable than would be possible if the software engineer could express the behavior of the program with the most appropriate abstractions. The new idea proposed by this paper is to move composition from built-in language constructs to programmable, first-class abstractions in the language. As an emerging result, we present the Co-op concept of a language, which shows that it is possible with a relatively simple model to express a wide range of compositions as first-class concepts
- …