5417799
Slicing XML Documents
Program slicing is a well-known technique to extract the program statements that (potentially) affect the values computed at some point of interest. In this work, we introduce a novel slicing method for XML documents. Essentially, given an XML document (which is valid w.r.t. some DTD), we produce a new XML document (a slice) that contains the relevant information in the original XML document according to some criterion. Furthermore, we also output a new DTD such that the computed slice is valid w.r.t. this DTD. A prototype implementation of the XML slicer has been undertaken.
7548183
A Comparative Study of Algorithmic Debugging Strategies
Algorithmic debugging is a debugging technique that has been extended to practically all programming paradigms. It is based on the answers of the programmer to a series of questions generated automatically by the algorithmic debugger. Therefore, the performance of the technique is strongly dependent on the number and the complexity of these questions. In this work we overview and compare current strategies for algorithmic debugging and we introduce some new strategies and discuss their advantages over previous approaches.
2088546
Combining algorithmic debugging and program slicing
Currently, program slicing and algorithmic debugging are two of the most relevant debugging techniques for declarative languages. They help programmers to find bugs in a semiautomatic manner. On the one hand, program slicing is a technique to extract those program fragments that (potentially) affect the values computed at some point of interest. On the other hand, algorithmic debugging is able to locate a bug by automatically generating a series of questions and processing the programmer's answers. In this work, we show for functional languages how the combination of both techniques produces a more powerful debugging schema that reduces the number of questions that programmers must answer to locate a bug
206855912
An algorithm to compare OO-conceptual schemas
In this paper, an algorithmic study of how to compare object-oriented conceptual schemas in a data migration context is carried out. An algorithm is presented based on the tree-comparison technique that compares conceptual schemas. The algorithm uses semantic information in order to optimize efficiency. A template of the equivalences and differences between two schemas is generated in an automatic way. The template shows the results in terms of insertions, updates and deletions. This work is the first phase in a tool which performs the automatic migration of databases starting from the differences detected.
753246
Static Slicing of Rewrite Systems
Program slicing is a method for decomposing programs by analyzing their data and control flow. Slicing-based techniques have many applications in the field of software engineering (like program debugging, testing, code reuse, maintenance, etc). Slicing has been widely studied within the imperative programming paradigm, where it is often based on the so called program dependence graph, a data structure that makes explicit both the data and control dependences for each operation in a program. Unfortunately, the notion of ''dependence'' cannot be easily adapted to a functional context. In this work, we define a novel approach to static slicing (i.e., independent of a particular input data) for first-order functional programs which are represented by means of rewrite systems. For this purpose, we introduce an appropriate notion of dependence that can be used for computing program slices. Also, since the notion of static slice is generally undecidable, we introduce a complete approximation for computing static slices which is based on the construction of a term dependence graph, the counterpart of program dependence graphs.
10924515
Run-Time Profiling of Functional Logic Programs
In this work, we introduce a profiling scheme for modern functional logic languages covering notions like laziness, sharing, and non-determinism. Firstly, we instrument a natural (big-step) semantics in order to associate a symbolic cost to each basic operation (e.g., variable updates, function unfoldings, case evaluations). While this cost semantics provides a formal basis to analyze the cost of a computation, the implementation of a cost-augmented interpreter based on it would introduce a huge overhead. Therefore, we also introduce a sound transformation that instruments a program such that its execution—under the standard semantics—yields not only the corresponding results but also the associated costs. Finally, we describe a prototype implementation of a profiler based on the developments in this paper.
14212270
Practical issues in the use of ABFT and a new failure model
We study the behavior of algorithm based fault tolerance (ABFT) techniques under faults injected according to a quite general fault model. Besides the problem of roundoff error in floating point arithmetic we identify two further weakpoints, namely lack of protection of data during input and output, and incorrect execution of the correctness checks. We propose the robust ABFT technique to handle those weakpoints. We then generalize it to programs that use assertions, where similar problems arise, leading to the technique of robust assertions, whose effectiveness is shown by fault injection experiments on a realistic control application. With this technique a system follows a new failure model, that we call fail-bounded, where with high probability all results produced are either correct or, if wrong, they are within a certain bound of the correct value, whose exact value depends on the output assertions used. We claim that this failure model is very useful to describe the behavior of many low redundancy systems.
37612228
An approach to testability improvement of mixed-signal boards
The increasing complexity of mixed-signal boards makes an integrated analogue/digital testability approach an attractive proposition. This paper investigates one such approach based on the use of mixed-signal test support ICs together with standard board level test infrastructures. The architecture of a test support IC and preliminary experimental results are also presented.<<ETX>>
42287277
A Divide-and-Conquer Approach to Acquire Syntactic Categories
In this paper we propose an unsupervised strategy for learning syntactic information that proceeds in several steps. First, we identify, cluster, and classify function words from unannotated corpora. Then, the acquired information is used in two different learning processes. On the one hand, it is used to learn morpho-syntactic categories of nouns and, on the other, it turns out to be useful to also induce syntactic/semantic relationships between content words. Experiments performed on Portuguese and English corpora are reported.
44523536
Implementing MPI-2 Extended Collective Operations
This paper describes a first approach to implement MPI-2's Extended Collective Operations. We aimed to ascertain the feasibility and effectiveness of such a project based on existing algorithms. The focus is on the intercommunicator operations, as these represent the main extension of the MPI-2 standard on the MPI-1 collective operations. We expose the algorithms, key features and some performance results. The implementation was done on top of WMPI and honors the MPICH layering, therefore the algorithms can be easily incorporated into other MPICH based MPI implementations.
15739638
Identification of Document Language is Not yet a Completely Solved Problem
Existing Language Identification (LID) approaches do reach 100% precision, in most common situations, when dealing with documents written in just one language, and when those documents are large enough. However, LID approaches do not provide a reliable solution for some situations: when there is need to discriminate the correct variant of the language used in a text, for example, European or Brazilian variants of Portuguese, UK or USA English variants, or any other language variants. Another hard context occur with small touristic advertisements on the web, addressing foreigners but using local language to name most local entities. In this paper, we present a fully statistics- based LID approach which learns the most discriminant information according to each context, and identifies the correct language or language variant a text is written in. This methodology is shown to be correct for normal texts and maintains its robustness in hard LID contexts.