1,467 research outputs found
Improving Runtime Overheads for detectEr
We design monitor optimisations for detectEr, a runtime-verification tool
synthesising systems of concurrent monitors from correctness properties for
Erlang programs. We implement these optimisations as part of the existing tool
and show that they yield considerably lower runtime overheads when compared to
the unoptimised monitor synthesis.Comment: In Proceedings FESCA 2015, arXiv:1503.0437
Combining Voting Rules Together
We propose a simple method for combining together voting rules that performs
a run-off between the different winners of each voting rule. We prove that this
combinator has several good properties. For instance, even if just one of the
base voting rules has a desirable property like Condorcet consistency, the
combination inherits this property. In addition, we prove that combining voting
rules together in this way can make finding a manipulation more computationally
difficult. Finally, we study the impact of this combinator on approximation
methods that find close to optimal manipulations
Assigning Satisfaction Values to Constraints: An Algorithm to Solve Dynamic Meta-Constraints
The model of Dynamic Meta-Constraints has special activity constraints which
can activate other constraints. It also has meta-constraints which range over
other constraints. An algorithm is presented in which constraints can be
assigned one of five different satisfaction values, which leads to the
assignment of domain values to the variables in the CSP. An outline of the
model and the algorithm is presented, followed by some initial results for two
problems: a simple classic CSP and the Car Configuration Problem. The algorithm
is shown to perform few backtracks per solution, but to have overheads in the
form of historical records required for the implementation of state.Comment: 11 pages. Proceedings ERCIM WG on Constraints (Prague, June 2001
Regular Combinators for String Transformations
We focus on (partial) functions that map input strings to a monoid such as
the set of integers with addition and the set of output strings with
concatenation. The notion of regularity for such functions has been defined
using two-way finite-state transducers, (one-way) cost register automata, and
MSO-definable graph transformations. In this paper, we give an algebraic and
machine-independent characterization of this class analogous to the definition
of regular languages by regular expressions. When the monoid is commutative, we
prove that every regular function can be constructed from constant functions
using the combinators of choice, split sum, and iterated sum, that are analogs
of union, concatenation, and Kleene-*, respectively, but enforce unique (or
unambiguous) parsing. Our main result is for the general case of
non-commutative monoids, which is of particular interest for capturing regular
string-to-string transformations for document processing. We prove that the
following additional combinators suffice for constructing all regular
functions: (1) the left-additive versions of split sum and iterated sum, which
allow transformations such as string reversal; (2) sum of functions, which
allows transformations such as copying of strings; and (3) function
composition, or alternatively, a new concept of chained sum, which allows
output values from adjacent blocks to mix.Comment: This is the full version, with omitted proofs and constructions, of
the conference paper currently in submissio
A Graphical Language for Proof Strategies
Complex automated proof strategies are often difficult to extract, visualise,
modify, and debug. Traditional tactic languages, often based on stack-based
goal propagation, make it easy to write proofs that obscure the flow of goals
between tactics and are fragile to minor changes in input, proof structure or
changes to tactics themselves. Here, we address this by introducing a graphical
language called PSGraph for writing proof strategies. Strategies are
constructed visually by "wiring together" collections of tactics and evaluated
by propagating goal nodes through the diagram via graph rewriting. Tactic nodes
can have many output wires, and use a filtering procedure based on goal-types
(predicates describing the features of a goal) to decide where best to send
newly-generated sub-goals.
In addition to making the flow of goal information explicit, the graphical
language can fulfil the role of many tacticals using visual idioms like
branching, merging, and feedback loops. We argue that this language enables
development of more robust proof strategies and provide several examples, along
with a prototype implementation in Isabelle
JooFlux: Hijacking Java 7 InvokeDynamic To Support Live Code Modifications
Changing functional and non-functional software implementation at runtime is
useful and even sometimes critical both in development and production
environments. JooFlux is a JVM agent that allows both the dynamic replacement
of method implementations and the application of aspect advices. It works by
doing bytecode transformation to take advantage of the new invokedynamic
instruction added in Java SE 7 to help implementing dynamic languages for the
JVM. JooFlux can be managed using a JMX agent so as to operate dynamic
modifications at runtime, without resorting to a dedicated domain-specific
language. We compared JooFlux with existing AOP platforms and dynamic
languages. Results demonstrate that JooFlux performances are close to the Java
ones --- with most of the time a marginal overhead, and sometimes a gain ---
where AOP platforms and dynamic languages present significant overheads. This
paves the way for interesting future evolutions and applications of JooFlux
- …