Mariano P. Consens

Visualizing and querying software structures

Software engineering problems often involve large sets of objects and complex relationships among them. This report proposes that graphical visualization techniques can help engineers undersland and solve a class of these problems. To illustrate this, two problems are analyzed and recast using the graphical language GraphLog. The first problem is that of simplifying dependencies among components of a system, which translates into removing cycles from a graph. The second problem is that of designing an efficient code overlay structure, which is facilitated in several ways through graphical techniques.

Low-complexity aggregation in GraphLog and Datalog

We present facilities for computing aggregate functions over sets of tuples and along paths in a database graph. We show how Datalog can be extended to compute a large class of queries with aggregates without incurring the large expense of a language with general set manipulation capabilities. In particular, we aim for queries that can be executed efficiently in parallel, using the class NC and its various subclasses as formal models of low parallel complexity. Our approach retains the standard relational notion of relations as sets of tuples, not requiring the introduction of multisets. For the case where no rules are recursive, the language is exactly as expressive as Klugs first order language with aggregates. We show that this class of non-recursive programs cannot express transitive closure (unless LOGSPACE=NLOGSPACE), thus providing evidence for a widely believed but never proven folk result. We also study the expressive power and complexity of languages that support aggregation over recursion. We then describe how these facilities, as well as manipulating the length of paths in database graphs, are incorporated into our visual query language GraphLog. While GraphLog could easily be extended to handle all the queries described above, we prefer to restrict the language in a natural way to avoid explicit recursion; all recursion is expressed as transitive closure. We show that this guarantees all expressible queries are in NC. We analyze other proposals and show that they can express queries that are logspace-complete for P and thus unlikely to be parallelizable efficiently.

ExpLOD: summary-based exploration of interlinking and RDF usage in the linked open data cloud

Publishing interlinked RDF datasets as links between data items identified using dereferenceable URIs on the web brings forward a number of issues. A key challenge is to understand the data, the schema, and the interlinks that are actually used both within and across linked datasets. Understanding actual RDF usage is critical in the increasingly common situations where terms from different vocabularies are mixed. In this paper we describe a tool, ExpLOD, that supports exploring summaries of RDF usage and interlinking among datasets from the Linked Open Data cloud. ExpLODs summaries are based on a novel mechanism that combines text labels and bisimulation contractions. The labels assigned to RDF graphs are hierarchical, enabling summarization at different granularities. The bisimulation contractions are applied to subgraphs defined via queries, providing for summarization of arbitrary large or small graph neighbourhoods. Also, ExpLOD can generate SPARQL queries from a summary. Experimental results, using several collections from the Linked Open Data cloud, compare the two summary creation approaches implemented by ExpLOD (graph-based vs. SPARQL-based).

Database Programming in Transaction Logic

This paper presents database applications of the recently proposed Transaction Logic—an extension of classical predicate logic that accounts in a clean and declarative fashion for the phenomenon of state changes in logic programs and databases. It has a natural model theory and a sound and complete proof theory, but, unlike many other logics, it allows users to program transactions. In addition, the semantics leads naturally to features whose amalgamation in a single logic has proved elusive in the past. Finally, Transaction Logic holds promise as a logical model of hitherto non-logical phenomena, including so-called procedural knowledge in AI, and the behavior of object-oriented databases, especially methods with side effects. This paper focuses on the applications of T r to database systems, including transaction definition and execution, nested transactions, view updates, consistency maintenance, bulk updates, non-determinism, sampling, active databases, dynamic integrity-constraints, hypothetical reasoning, and imperative-style programming.

AxPRE Summaries: Exploring the (Semi-)Structure of XML Web Collections

This paper introduces AxPRE summaries, a formalism that allows exploring the (semi-)structure of large XML collections. AxPRE summaries are implemented in a tool, DescribeX, that supports visualizing XML collections via summaries that can be interactively refined using a powerful and descriptive axis path regular expression language. Experimental results on gigabyte collections have shown that this flexibility does not come at the expense of efficiency.

Structural relevance: a common basis for the evaluation of structured document retrieval

This paper presents a unified framework for the evaluation of a range of structured document retrieval (SDR) approaches and tasks. The framework is based on a model of tree retrieval, evaluated using a novel extension of the Structural elevance (SR) measure. The measure replaces the assumption of independence in traditional information retrieval (IR) with a notion of redundancy that takes into account the user navigation inside documents while seeking relevant information. Unlike existing metrics for SDR, our proposed framework does not require the computation of an ideal ranking which has, thus far, prevented the practical application of such measures. Instead, SR builds on a Markovian model of user navigation that can be estimated through the use of structural summaries. The results of this paper (supported by experimental validation using INEX data) show that SR defined over a tree retrieval model can provide a common basis for the evaluation of SDR approaches across various structured search tasks.

Goals and benchmarks for autonomic configuration recommenders

We are witnessing an explosive increase in the complexity of the information systems we rely upon, Autonomic systems address this challenge by continuously configuring and tuning themselves. Recently, a number of autonomic features have been incorporated into commercial RDBMS; tools for recommending database configurations (i.e., indexes, materialized views, partitions) for a given workload are prominent examples of this promising trend.In this paper, we introduce a flexible characterization of the performance goals of configuration recommenders and develop an experimental evaluation approach to benchmark the effectiveness of these autonomic tools. We focus on exploratory queries and present extensive experimental results using both real and synthetic data that demonstrate the validity of the approach introduced. Our results identify a specific index configuration based on single-column indexes as a very useful baseline for comparisons in the exploratory setting. Furthermore, the experimental results demonstrate the unfulfilled potential for achieving improvements of several orders of magnitude.

Visualizing and querying distributed event traces with Hy

A programmer attempting to understand and debug a distributed program deals with large volumes of trace data that describe the programs behaviour. Visualization is widely believed to help in this and similar tasks. We contend that visualization is indeed useful, but only if accompanied of powerful data management facilities to support abstraction and filtering. The Hy+ visualization system and GraphLog query language provide these facilities. They support not just a fixed way of visualizing data, but visualizations that can be specified and manipulated through declarative queries, like data are manipulated in a database. In this paper we show how the Hy+/GraphLog system can be used by distributed program debuggers to meet their information manipulation and visualization goals.

The continued saga of DB-IR integration

This chapter provides an overview of the different issues and approaches put forward by the information retrieval (IR) and Database (DB) communities, and surveys the DB-IR integration efforts. It discusses both earlier proposals in the context of XML as well as the recent ones. It also presents a variety of application scenarios for DB-IR integration. The world of data has been developed from two main points of view—the structured relational data model and the unstructured text model. These two distinct cultures of database and information retrieval now have a natural meeting place in the Web with its semistructured XML model. As Web-style searching has become a ubiquitous tool, the need for integrating these two viewpoints becomes even more important. The chapter targets the researchers in database systems, as well as developers of Web and database/information retrieval applications.

Efficient, Effective and Flexible XML Retrieval Using Summaries

Retrieval queries that combine structural constraints with keyword search are placing new challenges on retrieval systems. This paper presents TReX—a new retrieval system for XML. TReX can efficiently return either all the answers to a given query or only the top-k answers. In this paper, we discuss our participation in the annual Initiative for the Evaluation of XML Retrieval (INEX) workshop in the ad-hoc track. Our main contribution is to investigate the use of summaries and the flexibility they provide when dealing with structural constraints. We describe algorithms for retrieval using summaries. Experimental results are presented showing that TReX answers queries efficiently and effectively.