Philip W. Dart

Phonetic string matching: lessons from information retrieval

Phonetic matching is used in applications such as name retrieval, where the spelling of a name is used to identify other strings that are likely to be of similar pronunciation. In this paper we explain the parallels between information retrieval and phonetic matching, and describe our new phonetic matching techniques. Our experimental comparison with existing techniques such as Soundex and edit distances, which is based on recall and precision, demonstrates that the new techniques are superior. In addition, reasoning from the similarity of phonetic matching and information retrieval, we have applied combination of evidence to phonetic matching. Our experiments with combining demonstrate that it leads to substantial improvements in effectiveness.

Finding approximate matches in large lexicons

Approximate string matching is used for spelling correction and personal name matching. In this paper we show how to use string matching techniques in conjunction with lexicon indexes to find approximate matches in a large lexicon. We test several lexicon indexing techniques, including n‐grams and permuted lexicons, and several string matching techniques, including string similarity measures and phonetic coding. We propose methods for combining these techniques, and show experimentally that these combinations yield good retrieval effectiveness while keeping index size and retrieval time low. Our experiments also suggest that, in contrast to previous claims, phonetic codings are markedly inferior to string distance measures, which are demonstrated to be suitable for both spelling correction and personal name matching.

On derived dependencies and connected databases

Abstract This paper introduces a new class of deductive databases ( connected databases ) for which SLDNF-resolution never flounders and always computes ground answers. The class of connected databases properly includes that of allowed databases. Moreover the definition of connected databases enables evaluable predicates to be included in a uniform way. An algorithm is described which, for each predicate defined in a normal database, derives a propositional formula ( groundness formula ) describing dependencies between the arguments of that predicate. Groundness formulae are used to determine whether a database is connected. They are also used to identify goals for which SLDNF-resolution will never flounder and will always compute ground answers on a connected database.

Disincentives for communicating risk: a risk paradox

Abstract Problems with the risk management in medium to large software projects have been well documented. For major software projects to be completed successfully, an open and cooperative attitude towards risk must be maintained. Despite this significant incentive, project stakeholders frequently conceal risks. This article identifies reasons in three key areas for such behaviour, and suggests approaches that reduce the motivation for this behaviour thereby providing a basis for effective risk management. Examples drawn from a study, undertaken by the authors, of a medium-sized industry project are used to illustrate many of these issues.

Combining logical agents with rapid prototyping for engineering distributed applications

The realization of new distributed and heterogeneous software applications is a challenge that software engineers have to face. Logic programming and multi-agent systems can play a very effective role in the rapid prototyping of new software products. This paper proposes a general approach to the prototyping of complex and distributed applications modelled as multi-agent systems and outlines the autonomous research experiences of different research groups from which the approach originates. All the experiences have logic programming as the common foundation and deal with different aspects of the problem: integration of heterogeneous data and reasoning systems, animation of formal specifications and the development of agent-based software. The final goal is joining these diverse experiences into a unique open framework.

Verifying model oriented specifications through animation

In this paper we demonstrate how light weight tools can be used to increase the level of confidence in Z specifications. In particular we outline the Pipedream approach to exploring Z specifications through animation, and illustrate the range of analyses that can be performed. We argue that, while a light weight approach does not give the same levels of assurance that an automated reasoning system would, it does give levels of assurance which are adequate for most projects and with significantly less overhead. We illustrate how animation can be used to perform verification using the example of a simple dependency management system.

VERIFYING REQUIREMENTS THROUGH MATHEMATICAL MODELLING AND ANIMATION

Achieving confidence in the correctness, completeness and consistency of requirements specifications can be problematic and the consequences of incorrect requirements can be costly. In this paper we argue that specification and animation can provide reasonably high levels of assurance in the requirements without the overheads of using general purpose theorem proving tools. We propose a framework based on mode analysis and the operational semantics of logic programs for animating specifications. The framework allows us to combine prototyping and limited forms of automated deduction to increase our levels of confidence in specifications. Finally, we show how such a framework can be used to increase the level of confidence in the correctness of a simple dependency management system specification written in Z.

Developing an accredited software engineering program

In 1996, the Institution of Engineers, Australia, granted full accreditation to the University of Melbournes undergraduate program in software engineering. The authors, from the Universitys Department of Computer Science, describe their experiences developing the program and undergoing the accreditation process.

Efficient run-time type checking of typed logic programs

Abstract This paper presents a new approach to the problem of guaranteeing that definite logic programs are free of type errors. Previously, two approaches to this problem have been considered. The first approach is static type checking, in which predicate types are inferred from the program and checked for self-consistency and for consistency with declared types. Static type checking, however, is in general incomplete, as it can neither only reject programs with type errors nor only accept programs which are type-error free. The second approach is dynamic type checking, in which types are checked against type declarations at run-time. Dynamic type checking, however, is prohibitively expensive. Our approach combines static and dynamic type checking so that, not only is completeness attained but the overhead of run-time type checking is substantially reduced. This is achieved by taking advantage of any redundancy between type declarations and types enforced by the program itself. Type checks are added to a clause only where redundancy cannot be shown to exist. In particular, only local variables ever need be type checked, and type checks on some variables may be shown redundant by use of type inference and analysis of type dependencies; to implement such analysis, we have developed new algorithms for intersecting and comparing types and for unifying types and terms. Hence, programs with declared types may be transformed into programs with a small number of explicit type checks. We argue that the overhead of the remaining type checks is generally small and is justified by the benefits of having effective type checking for logic programs.

Analysis of software system requirements models

This paper presents an analysis of models used for software system requirements. A range of models have been chosen to demonstrate the diversity of notation, application and intention and they have been considered separately from the methods used for their creation. A set of criteria is established as a basis for comparison of the chosen models. The criteria are intended to cover aspects of a requirements model which allows for assessment of its suitability for a particular application. Various classes of models have been distinguished and a comparative overview of those classes is given. The paper provides information for a reader who is looking for a suitable model for a particular domain. Information is presented that will be of use to researchers and practitioners who are interested in the provision of tool support for requirements engineering. It also serves as an introduction to the research area of software system requirements models.