6,093 research outputs found
On Coordinating Collaborative Objects
A collaborative object represents a data type (such as a text document)
designed to be shared by a group of dispersed users. The Operational
Transformation (OT) is a coordination approach used for supporting optimistic
replication for these objects. It allows the users to concurrently update the
shared data and exchange their updates in any order since the convergence of
all replicas, i.e. the fact that all users view the same data, is ensured in
all cases. However, designing algorithms for achieving convergence with the OT
approach is a critical and challenging issue. In this paper, we propose a
formal compositional method for specifying complex collaborative objects. The
most important feature of our method is that designing an OT algorithm for the
composed collaborative object can be done by reusing the OT algorithms of
component collaborative objects. By using our method, we can start from correct
small collaborative objects which are relatively easy to handle and
incrementally combine them to build more complex collaborative objects.Comment: In Proceedings FOCLASA 2010, arXiv:1007.499
The Dafny Integrated Development Environment
In recent years, program verifiers and interactive theorem provers have
become more powerful and more suitable for verifying large programs or proofs.
This has demonstrated the need for improving the user experience of these tools
to increase productivity and to make them more accessible to non-experts. This
paper presents an integrated development environment for Dafny-a programming
language, verifier, and proof assistant-that addresses issues present in most
state-of-the-art verifiers: low responsiveness and lack of support for
understanding non-obvious verification failures. The paper demonstrates several
new features that move the state-of-the-art closer towards a verification
environment that can provide verification feedback as the user types and can
present more helpful information about the program or failed verifications in a
demand-driven and unobtrusive way.Comment: In Proceedings F-IDE 2014, arXiv:1404.578
Literal Perceptual Inference
In this paper, I argue that theories of perception that appeal to Helmholtzâs idea of unconscious inference (âHelmholtzianâ theories) should be taken literally, i.e. that the inferences appealed to in such theories are inferences in the full sense of the term, as employed elsewhere in philosophy and in ordinary discourse.
In the course of the argument, I consider constraints on inference based on the idea that inference is a deliberate acton, and on the idea that inferences depend on the syntactic structure of representations. I argue that inference is a personal-level but sometimes unconscious process that cannot in general be distinguished from association on the basis of the structures of the representations over which itâs defined. I also critique arguments against representationalist interpretations of Helmholtzian theories, and argue against the view that perceptual inference is encapsulated in a module
Programming Not Only by Example
In recent years, there has been tremendous progress in automated synthesis
techniques that are able to automatically generate code based on some intent
expressed by the programmer. A major challenge for the adoption of synthesis
remains in having the programmer communicate their intent. When the expressed
intent is coarse-grained (for example, restriction on the expected type of an
expression), the synthesizer often produces a long list of results for the
programmer to choose from, shifting the heavy-lifting to the user. An
alternative approach, successfully used in end-user synthesis is programming by
example (PBE), where the user leverages examples to interactively and
iteratively refine the intent. However, using only examples is not expressive
enough for programmers, who can observe the generated program and refine the
intent by directly relating to parts of the generated program.
We present a novel approach to interacting with a synthesizer using a
granular interaction model. Our approach employs a rich interaction model where
(i) the synthesizer decorates a candidate program with debug information that
assists in understanding the program and identifying good or bad parts, and
(ii) the user is allowed to provide feedback not only on the expected output of
a program, but also on the underlying program itself. That is, when the user
identifies a program as (partially) correct or incorrect, they can also
explicitly indicate the good or bad parts, to allow the synthesizer to accept
or discard parts of the program instead of discarding the program as a whole.
We show the value of our approach in a controlled user study. Our study shows
that participants have strong preference to using granular feedback instead of
examples, and are able to provide granular feedback much faster
IST Austria Thesis
Motivated by the analysis of highly dynamic message-passing systems, i.e. unbounded thread creation, mobility, etc. we present a framework for the analysis of depth-bounded systems. Depth-bounded systems are one of the most expressive known fragment of the Ï-calculus for which interesting verification problems are still decidable. Even though they are infinite state systems depth-bounded systems are well-structured, thus can be analyzed algorithmically. We give an interpretation of depth-bounded systems as graph-rewriting systems. This gives more flexibility and ease of use to apply depth-bounded systems to other type of systems like shared memory concurrency.
First, we develop an adequate domain of limits for depth-bounded systems, a prerequisite for the effective representation of downward-closed sets. Downward-closed sets are needed by forward saturation-based algorithms to represent potentially infinite sets of states. Then, we present an abstract interpretation framework to compute the covering set of well-structured transition systems. Because, in general, the covering set is not computable, our abstraction over-approximates the actual covering set. Our abstraction captures the essence of acceleration based-algorithms while giving up enough precision to ensure convergence. We have implemented the analysis in the PICASSO tool and show that it is accurate in practice. Finally, we build some further analyses like termination using the covering set as starting point
- âŠ