139 research outputs found
Uniqueness typing for a higher-order language
We investigate type-based analysis for a higher-order channel passing language with strong update, whereby messages of a different kind are communicated over the same channel. In order to reason about such programs, our type system employs the concept of uniqueness to be able to assert when it is safe to change the object type a channel. We design a type system based on this concept and prove that our type system is sound, meaning that it only accepts programs that do not produce runtime errors.peer-reviewe
Preliminary Results Towards Contract Monitorability
This paper discusses preliminary investigations on the monitorability of
contracts for web service descriptions. There are settings where servers do not
guarantee statically whether they satisfy some specified contract, which forces
the client (i.e., the entity interacting with the server) to perform dynamic
checks. This scenario may be viewed as an instance of Runtime Verification,
where a pertinent question is whether contracts can be monitored for adequately
at runtime, otherwise stated as the monitorability of contracts. We consider a
simple language of finitary contracts describing both clients and servers, and
develop a formal framework that describes server contract monitoring. We define
monitor properties that potentially contribute towards a comprehensive notion
of contract monitorability and show that our simple contract language satisfies
these properties.Comment: In Proceedings PrePost 2016, arXiv:1605.0809
Towards sound refactoring in erlang
Erlang is an actor-based programming
language used extensively for building concurrent, reactive
systems that are highly available and suff er minimum
downtime. Such systems are often mission critical, making
system correctness vital. Refactoring is code restructuring
that improves the code but does not change
behaviour. While using automated refactoring tools is
less error-prone than performing refactorings manually,
automated refactoring tools still cannot guarantee that
the refactoring is correct, i.e., program behaviour is preserved.
This leads to lack of trust in automated refactoring
tools. We rst survey solutions to this problem
proposed in the literature. Erlang refactoring tools as
commonly use approximation techniques which do not
guarantee behaviour while some other works propose the
use of formal methodologies. In this work we aim to
develop a formal methodology for refactoring Erlang
code. We study behavioural preorders, with a special focus
on the testing preorder as it seems most suited to
our purpose.peer-reviewe
Formal proofs for broadcast algorithms
Standard distributed algorithmic solutions to recurring distributed problems are commonly specified and described informally. A proper understanding of these distributed algorithms that clarifies ambiguities requires formal descriptions. However, formalisation tends to yield complex descriptions. We formally study two broadcast algorithms and present an encoding framework using a process descriptive language and formalise these algorithms and their specifications using this framework. Following these new formal encodings we discuss correctness proofs for the same algorithms.peer-reviewe
On Synchronous and Asynchronous Monitor Instrumentation for Actor-based systems
We study the impact of synchronous and asynchronous monitoring
instrumentation on runtime overheads in the context of a runtime verification
framework for actor-based systems. We show that, in such a context,
asynchronous monitoring incurs substantially lower overhead costs. We also show
how, for certain properties that require synchronous monitoring, a hybrid
approach can be used that ensures timely violation detections for the important
events while, at the same time, incurring lower overhead costs that are closer
to those of an asynchronous instrumentation.Comment: In Proceedings FOCLASA 2014, arXiv:1502.0315
Typing actors using behavioural types
The actor model of computation assists and disciplines
the development of concurrent programs by forcing
the software engineer to reason about high-level concurrency
abstractions. While this leads to a better handling
of concurrency-related issues, the model itself does not exclude
erratic program behaviours. In this paper we consider
the actor model and investigate a type-based static analysis
to identify actor systems which may behave erraticly during
runtime. We consider the notion of behavioural types
and consider issues related to the nature of the actor model
including non-determinism, multi-party communication, dynamic
actor spawning, non-finite computation and a possibly
changing communication topology, which we contrast with
existing works.peer-reviewe
Consistently-Detecting Monitors
We study a contextual definition for deterministic monitoring based on consistent detections. It is defined in terms of the observed behaviour of the monitor when instrumented over arbitrary systems. We give an alternative, coinductive definition based on controllability which does not rely on system quantifications, and show that it is fully-abstract with respect to the former definition. We then develop a symbolic counterpart to the controllability definition to facilitate an automated analysis for controllable monitors involving data
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
Unlocking Blocked Communicating Processes
We study the problem of disentangling locked processes via code refactoring.
We identify and characterise a class of processes that is not lock-free; then
we formalise an algorithm that statically detects potential locks and propose
refactoring procedures that disentangle detected locks. Our development is cast
within a simple setting of a finite linear CCS variant \^a although it suffices
to illustrate the main concepts, we also discuss how our work extends to other
language extensions.Comment: In Proceedings WWV 2015, arXiv:1508.0338
Compositional Reasoning for Explicit Resource Management in Channel-Based Concurrency
We define a pi-calculus variant with a costed semantics where channels are
treated as resources that must explicitly be allocated before they are used and
can be deallocated when no longer required. We use a substructural type system
tracking permission transfer to construct coinductive proof techniques for
comparing behaviour and resource usage efficiency of concurrent processes. We
establish full abstraction results between our coinductive definitions and a
contextual behavioural preorder describing a notion of process efficiency
w.r.t. its management of resources. We also justify these definitions and
respective proof techniques through numerous examples and a case study
comparing two concurrent implementations of an extensible buffer.Comment: 51 pages, 7 figure
- …