COMPLEX: an object-oriented logic programming system

The design and a prototypical implementation of COMPLEX, which is a logic-based system extended with concepts from the object-oriented paradigm and is intended as a tool for the development of knowledge-based applications, are described. The system supports a logic language, called Complex-Datalog (C-Datalog), enhanced by semantic constructs to provide facility for data abstraction. Its implementation is based on a bottom-up computational model that guarantees a fully declarative style of programming. However, the user is also given the possibility of running a query using a top-down model of computation. Efficiency of execution is the result of the integration of different novel technologies for the compilation and the execution of queries     

A proof outline logic for object-oriented programming

This paper describes a proof outline logic that covers most typical object-oriented language constructs in the presence of inheritance and subtyping. The logic is based on a weakest precondition calculus for assignments and object allocation which takes field shadowing into account. Dynamically bound method calls are tackled with a variant of Hoare's rule of adaptation that deals with the dynamic allocation of objects in object-oriented programs. The logic is based on an assertion language that is closely tailored to the abstraction level of the programming language.     

Bridging the gap between biometrics and cryptography

Commenting on the terrorist attacks on the US in September, Lutz Martiny, chairman of Eurosmart, told CTT that the smart card industry might be required to come up with secure ID documents and technologies “using biometric and encrytion/decryption procedures.” Richard Aufreiter of Utimaco Safeware, who provides our Chip Talk column this month, believes that the technology enabling the smart card to fill the gap between biometrics and cryptography is now in place.     

Bridging the gap between feature- and grid-based SLAM

One important design decision for the development of autonomously navigating mobile robots is the choice of the representation of the environment. This includes the question of which type of features should be used, or whether a dense representation such as occupancy grid maps is more appropriate. In this paper, we present an approach which performs SLAM using multiple representations of the environment simultaneously. It uses reinforcement to learn when to switch to an alternative representation method depending on the current observation. This allows the robot to update its pose and map estimate based on the representation that models the surrounding of the robot in the best way. The approach has been implemented on a real robot and evaluated in scenarios, in which a robot has to navigate in- and outdoors and therefore switches between a landmark-based representation and a dense grid map. In practical experiments, we demonstrate that our approach allows a robot to robustly map environments which cannot be adequately modeled by either of the individual representations.     

The Structure and Semantics of an Object-Oriented Logic Programming Language: SCKE

The development of the object-oriented paradigm has suffered from the lack of any generally accepted formal foundations for its semantic definition.To address this issue,we propose the development of the logic-based semantics of the object-oriented paradigm.By combining the logic-with the object-oriented paradigm of computing first,this paper discusses formally the semantics of a quite purely object-oriented logic paradigm in terms of proof theory,model theory and fixpoint theory from the viewpoint of logic.The operational and declarative semantics is given.And then the correspondence between soundness and completeness has been discussed formally.     

Bridging the gap between OWL and relational databases

Despite similarities between the Web Ontology Language (OWL) and schema languages traditionally used in relational databases, systems based on these languages exhibit quite different behavior in practice. The schema statements in relational databases are usually interpreted as integrity constraints and are used to check whether the data is structured according to the schema. OWL allows for axioms that resemble integrity constraints; however, these axioms are interpreted under the standard first-order semantics and not as checks. This often leads to confusion and is inappropriate in certain data-centric applications. To explain the source of this confusion, in this paper we compare OWL and relational databases w.r.t. their schema languages and basic computational problems. Based on this comparison, we extend OWL with integrity constraints that capture the intuition behind similar statements in relational databases. We show that, if the integrity constraints are satisfied, they need not be considered while answering a broad range of positive queries. Finally, we discuss several algorithms for checking integrity constraint satisfaction, each of which is suitable to different types of OWL knowledge bases.     

Bridging the gap between geometric and algebraic multi-grid methods

In this paper, a multi-grid solver for the discretisation of partial differential equations on complicated domains will be developed. The algorithm requires as input only the given discretisation instead of a hierarchy of discretisations on coarser grids. Such auxiliary grids and discretisations will be generated in a black-box fashion and will be employed to define purely algebraic intergrid transfer operators. The geometric interpretation of the algorithm allows one to use the framework of geometric multigrid methods to prove its convergence. The focus of this paper is on the formulation of the algorithm and the demonstration of its efficiency by numerical experiments while the analysis is carried out for some model problems.     

Bridging the gap between business models and system models

This paper discusses links that may be made between process models and Unified Modelling Language (UML) software specification techniques, working from an argument that the whole complexity of organisational activity cannot be captured by UML alone. The approach taken is to develop a set of use cases, which would be capable of providing information support to a pre-defined organisational process. The nature of the thinking, which is necessary to derive the use cases, is outlined using the pre-defined process as a case study. The grouping of transactions and state changes into Use Cases is shown to require design choices, which may vary between particular organisational contexts. Conclusions are drawn about the direction of further investigation of links between process modelling and UML.     

Bridging the gap between software development and information security

Traditionally, software development efforts in large corporations have been about as far removed from information security as they were from human resources or any other business function. Software development has also had the tendency to be highly distributed among business units and thus not even practiced in a cohesive, coherent manner. In the worst cases, busy business unit executives trade roving bands of developers like Pokemon cards in a fifth-grade classroom (in an attempt to get ahead). Suffice it to say, none of this is good. The disconnect between security and development has ultimately produced software development efforts that lack any sort of contemporary understanding of technical security risks. Today's complex and highly connected computing environments trigger myriad security concerns, so by blowing off the idea of security entirely, software builders virtually guarantee that their creations have way too many security weaknesses that could - and should - have been avoided. This article presents some recommendations for solving this problem. Our approach is born out of experience in two diverse fields: software security and information security. Central among our recommendations is the notion of using the knowledge inherent in information security organizations to enhance secure software development efforts.     

Bridging the model-to-code abstraction gap with fuzzy logic in model-based regression test selection

Regression test selection (RTS) approaches reduce the cost of regression testing of evolving software systems. Existing RTS approaches based on UML models use behavioral diagrams or a combination of structural and behavioral diagrams. However, in practice, behavioral diagrams are incomplete or not used. In previous work, we proposed a fuzzy logic based RTS approach called FLiRTS that uses UML sequence and activity diagrams. In this work, we introduce FLiRTS 2, which drops the need for behavioral diagrams and relies on system models that only use UML class diagrams, which are the most widely used UML diagrams in practice. FLiRTS 2 addresses the unavailability of behavioral diagrams by classifying test cases using fuzzy logic after analyzing the information commonly provided in class diagrams. We evaluated FLiRTS 2 on UML class diagrams extracted from 3331 revisions of 13 open-source software systems, and compared the results with those of code-based dynamic (Ekstazi) and static (STARTS) RTS approaches. The average test suite reduction using FLiRTS 2 was 82.06%. The average safety violations of FLiRTS 2 with respect to Ekstazi and STARTS were 18.88% and 16.53%, respectively. FLiRTS 2 selected on average about 82% of the test cases that were selected by Ekstazi and STARTS. The average precision violations of FLiRTS 2 with respect to Ekstazi and STARTS were 13.27% and 9.01%, respectively. The average mutation score of the full test suites was 18.90%; the standard deviation of the reduced test suites from the average deviation of the mutation score for each subject was 1.78% for FLiRTS 2, 1.11% for Ekstazi, and 1.43% for STARTS. Our experiment demonstrated that the performance of FLiRTS 2 is close to the state-of-art tools for code-based RTS but requires less information and performs the selection in less time.

     

Bridging the generation gap between text planning and linguistic realization

Text planning is traditionally done as a separate process, independent of linguistic realization. However, I show in this paper that it is essential for a text planner to know the linguistic consequences of its actions. The choice of how to realize an element affects how much information is conveyed (e.g., “Floyd arrived safely in Boston” vs. “Floyd landed safely at Logan”) and what other information can be added (e.g., “Peter was deciding for an hour” vs. *“Peter made a decision for an hour”). The choice of realization also affects how the relative salience of the elements being expressed will be perceived (e.g., “The green car is in the garage” vs. “The car in the garage is green”). I have defined an intermediate level of representation for text planning, called the Text Structure. It is an abstract linguistic level that reflects germane linguistic constraints while abstracting away from syntactic detail. This representation allows the text planner to have greater control over the decisions, so that it can take advantage of the expressiveness of language to convey subtleties of meaning. More importantly, the Text Structure allows the generation process overall to be incremental, since it ensures that the text plan being composed will always be expressible in the language. La planification de textes est habituellement réalisée séparément, sans tenir compte de la réalisation linguistique. Cependant, ľauteur demontre dans cet article qu'il est essentiel à un planificateur de textes de connai̊tre les conséquences linguistiques de ses actions. Le choix de la méhode de réalisation ?un élément influe sur la quantité?informations qui est transmise (par ex.: 〈〈 Floyd est arrivé sain et sauf à Boston 〉〉 et 〈〈 Floyd a atterri sain et sauf àľaéroport Logan 〉〉) et sur quelle autre information peut ětre ajoutée. Le choix de la méthode de réalisation influe également sur la façon dont les caractères saillants des ééments qui sont exprimés seront perçus (par ex.: 〈〈 la voiture verte est dans le garage 〉〉 et 〈〈 la voiture dans le garage est verte 〉〉). L'auteur a défini un niveau intérmediaire de représentation pour la planification de textes qu'il a appelé structure de texte. Il; s'agit ?'un niveau linguistique abstrait qui refléte les contraintes linguistiques appropriées tout en s'éloignant du détail syntaxique. Cette représentation permet au planificateur de textes ?avoir un meilleur contrǒle des décisions, et done de tirer profit de la force ?expression du langage afin de tenir compte des subtiliés de sens. Plus important encore, la structure de texte permet au processus de génération ?ětre incrémentiel, car elle s'assure que le plan de texte en voie de composition soit toujours exprimable dans le langage.     

Bridging the gap between tracking and detecting changes in XML

There are two main approaches to manage changes in XML documents, change‐tracking and diff. Change‐tracking tools, which record edit actions while they are performed on the source document, are able to capture the exact editing process. That is much more difficult for diff algorithms, which have to reconstruct it by comparing two different versions. Interestingly, these algorithms process both text‐centric and data‐centric XML documents the same way. In this paper, we show that more accurate, clear, and human‐readable results can be achieved on text‐centric resources, by employing specific models and algorithms. We describe and discuss a specialized diff algorithm for such a class of documents. We also compare a Java implementation of the algorithm, named JNDiff, with other general‐purpose or data‐oriented diff tools, focusing on the quality of their output. Copyright © 2014 Copyright © 2014 John Wiley & Sons, Ltd.     

Bridging the reality gap between the Webots simulator and e-puck robots

This work presents a set of techniques to improve the cross-compatibility between the Webots simulator and the educational e-puck mobile robot. The work is motivated by the need of a realistic simulation environment, especially designed to consider the unique challenges associated to multi-robot systems (MRS), such as the robot–robot interaction (RRI). This article starts by proposing a new Webots programming architecture that provides full control of the e-puck’s firmware. By doing so, one can easily improve the already existing e-puck’s functionalities on Webots, as well as adding new functionalities required by most MRS applications. Among the range of new possible functionalities, this article describes the successful implementation of the microphone, the speaker, and the Bluetooth for robot–robot communication. Due to the limitations of the e-puck’s Bluetooth modules, this work goes even further by bringing some insights about the Gumstix Overo COM turret and how robot–robot communication may be achieved using WiFi technology. The outcomes provided by the experiments conducted using both virtual and real e-pucks under the Webots framework open new doors for low-cost multi-robot applications.     

A bridge between constructive logic and computer programming

Some logic notions have their analogies among programming concepts and vice versa. But people often try to understand these analogies in too straightforward a manner. A collection of analogies arising between constructive logics and programming is summarized and illustrated here. Some examples of complexities usually not taken into account are shown.     

ECAL: Bridging the gap between CAL and intelligent tutoring systems

In the traditional CAL system the author generates material to be presented by computer, and the computer simply follows the explicit instructions of the author in interacting with a student. Intelligent tutoring systems rely on abstracting the implicit knowledge of a CAL system into explicit separable representations. There is a large gap between these two approaches which ECAL attempts to bridge by incorporating simple versions of ideas from artificial intelligence as extensions to a traditional CAL tool. It can be regarded as an experiment in minimalism in intelligent tutoring but it is also a practical educational tool. This paper introduces some of the authoring issues raised by ECAL, followed by a general view of the architecture of the system, and a discussion of the educational model which is implicit in ECAL. The final sections discuss the ECAL presentation system and the authoring environment.     

Bridging logic and kernel machines

We propose a general framework to incorporate first-order logic (FOL) clauses, that are thought of as an abstract and partial representation of the environment, into kernel machines that learn within a semi-supervised scheme. We rely on a multi-task learning scheme where each task is associated with a unary predicate defined on the feature space, while higher level abstract representations consist of FOL clauses made of those predicates. We re-use the kernel machine mathematical apparatus to solve the problem as primal optimization of a function composed of the loss on the supervised examples, the regularization term, and a penalty term deriving from forcing real-valued constraints deriving from the predicates. Unlike for classic kernel machines, however, depending on the logic clauses, the overall function to be optimized is not convex anymore. An important contribution is to show that while tackling the optimization by classic numerical schemes is likely to be hopeless, a stage-based learning scheme, in which we start learning the supervised examples until convergence is reached, and then continue by forcing the logic clauses is a viable direction to attack the problem. Some promising experimental results are given on artificial learning tasks and on the automatic tagging of bibtex entries to emphasize the comparison with plain kernel machines.