Search operations in databases require special support at the physical level. This is true for conventional databases as well as spatial databases, where typical search operations include the point query (find all objects that contain a given search point) and the region query (find all objects that overlap a given search region). More than ten years of spatial database research have resulted in a great variety of multidimensional access methods to support such operations. We give an overview of that work. After a brief survey of spatial data management in general, we first present the class of point access methods, which are used to search sets of points in two or more dimensions. The second part of the paper is devoted to spatial access methods to handle extended objects, such as rectangles or polyhedra. We conclude with a discussion of theoretical and experimental results concerning the relative performance of various approaches.

/pdf/multidimensional-access-methods-4jxurm5el0.pdf

Multidimensional access methods

Constraint Logic Programming (CLP) is a merger of two declarative paradigms: constraint solving and logic programming. Although a relatively new field, CLP has progressed in several quite different directions. In particular, the early fundamental concepts have been adapted to better serve in different areas of applications. In this survey of CLP, a primary goal is to give a systematic description of the major trends in terms of common fundamental concepts. The three main parts cover the theory, implementation issues, and programming for applications.

Constraint logic programming : A survey

ly, this program guesses nondeterministically the correct permutation via permutation(Xs,Ys), and ordered checks that the permutation is actually ordered. Operationally, the behavior is as follows. A query involving sort is reduced to a query involving permutation and ordered. A failure-driven loop ensues. A permutation of the list is generated by permutation and tested by ordered. If the permuted list is not ordered, the execution backtracks to the permutation goal, which generates another permutation to be tested. Eventually an ordered permutation is generated and the computation terminates. Permutation sort is a highly inefficient sorting algorithm, requiring time super-exponential in the size of the list to be sorted. Pushing the tester into the generator, however, leads to a reasonable algorithm. The generator for permutation sort, permutation, selects an arbitrary element and recursively permutes the rest of the list. The tester, ordered, verifies that the first two elements of the permutation are in order, then recursively checks the rest. If we view the combined recursive permutation and ordered goals as a recursive sorting process, we have the basis for insertion sort, Program 3.21. To sort a list, sort the tail of the list and insert the head of the list into its correct place in the order. The arbitrary selection of an element has been replaced by choosing the first element. Another example of the advantage of intertwining generating and testing can be seen with programs solving the N queens problem. The N queens problem requires the placement of N pieces on an Nby-N rectangular board so that no two pieces are on the same line: horizontal, vertical, or diagonal. The original formulation called for 8 queens to be placed on a chessboard, and the criterion of not being on the same line corresponds to two queens not attacking each other under the rules of chess. Hence the problem's name. 253 Nondeterministic Programming

The art of Prolog

Software fault localization, the act of identifying the locations of faults in a program, is widely recognized to be one of the most tedious, time consuming, and expensive – yet equally critical – activities in program debugging. Due to the increasing scale and complexity of software today, manually locating faults when failures occur is rapidly becoming infeasible, and consequently, there is a strong demand for techniques that can guide software developers to the locations of faults in a program with minimal human intervention. This demand in turn has fueled the proposal and development of a broad spectrum of fault localization techniques, each of which aims to streamline the fault localization process and make it more effective by attacking the problem in a unique way. In this article, we catalog and provide a comprehensive overview of such techniques and discuss key issues and concerns that are pertinent to software fault localization as a whole.

A Survey on Software Fault Localization

Constraint Handling Rules (CHR) are our proposal to allow more flexibility and application-oriented customization of constraint systems. CHR are a declarative language extension especially designed for writing user-defined constraints. CHR are essentially a committed-choice language consisting of multi-headed guarded rules that rewrite constraints into simpler ones until they are solved. In this broad survey we aim at covering all aspects of CHR as they currently present themselves. Going from theory to practice, we will define syntax and semantics for CHR, introduce an important decidable property, confluence, of CHR programs and define a tight integration of CHR with constraint logic programming languages. This survey then describes implementations of the language before we review several constraint solvers – both traditional and nonstandard ones – written in the CHR language. Finally we introduce two innovative applications that benefited from using CHR.

Theory and practice of constraint handling rules

This article presents an improved approach to assist diagnosis of failures in software (fault localisation) by ranking program statements or blocks in accordance with to how likely they are to be buggy. We present a very simple single-bug program to model the problem. By examining different possible execution paths through this model program over a number of test cases, the effectiveness of different proposed spectral ranking methods can be evaluated in idealised conditions. The results are remarkably consistent to those arrived at empirically using the Siemens test suite and Space benchmarks. The model also helps identify groups of metrics that are equivalent for ranking. Due to the simplicity of the model, an optimal ranking method can be devised. This new method out-performs previously proposed methods for the model program, the Siemens test suite and Space. It also helps provide insight into other ranking methods.

/pdf/a-model-for-spectra-based-software-diagnosis-4eia6eyyxq.pdf

A model for spectra-based software diagnosis

We investigate ways of bringing PROLOG closer to the ideals of logic programming, by improving its facilities for negation and control. The forms of negation available in conventional PROLOG systems are implemented unsoundly, and can lead to incorrect solutions. We discuss several ways in which negation as failure can be implemented soundly. The main forms of negation considered are not, not-equals, if-then-else and all solutions predicates. The specification and implementation of all solutions predicates is examined in detail. Allowing quantifiers in negated calls is an extension which is easily implemented and we stress its desirability, for all forms of negation. We propose other enhancements to current implementations, to prevent the computation aborting or looping infinitely, and also outline a new technique for implementing negation by program transformation. Finally, we suggest what forms of negation should be implemented in future PROLOG systems. The poor control facilities of conventional PROLOG lead to infinite loops and inefficiency. More flexible computation rules can often overcome these problems. We first introduce control primitives for database and recursive predicates, then show how control information can be generated automatically, using these primitives. Automatically reordering subgoals in clauses is also considered. This allows programmers to concentrate more on the logic of a problem, making programming simpler. We give examples using several different styles of programming. The implications of automatic control for the design of control primitives is also discussed. Next, we re-examine the theoretical foundations of PROLOG systems with flexible computation rules. The SLD resolution model is extended, to correct a previous over-simplification. The extension also brings to light a much greater flexibility of computation rules, which has previously been overlooked. A rule which behaves like intelligent backtracking is given as an example. Finally, we take an overview of the many approaches to control in PROLOG. Some general principles for evaluating and classifying control rules are given. These show the deficiencies of current systems more clearly. We make suggestions for future implementations of PROLOG with extra control facilities.

Negation and Control in Prolog

We present a very simple but flexible declarative debugging scheme. A Abstract-1 declarative debugger can be defined in Prolog with a single clause, and relies on the definition of just two additional predicates. With suitable definitions of these predicates, the debugger can diagnose several classes of bugs in many languages. We give examples of diagnoses of wrong answers in functional, relational, and object-oriented languages as well as missing answers in relational languages and calls that are not well defined in functional languages. By using declarative semantics of programs, the debugger is able to hide complex execution mechanisms such as unification, backtracking, coroutining, parallelism, higher-order functions, lazy evaluation, message passing, and inheritance.

A Declarative Debugging Scheme.

A model for the coroutined execution of PROLOG programs is presented, and two control primitives are described. Heuristics for the control of data-base and recursive procedures are given, which lead to algorithms for generating control information. These algorithms can be incorporated into a preprocessor for logic programs. It is argued that automatic generation should be an important consideration when designing control primitives and is a significant step towards simplifying the task of programming.

Lee Naish

Papers

A model for spectra-based software diagnosis

Negation and Control in Prolog

A Declarative Debugging Scheme.

Automating control for logic programs

Parallelizing NU-Prolog.