83,697 research outputs found
A Behavioural Theory of Recursive Algorithms
"What is an algorithm?" is a fundamental question of computer science.
Gurevich's behavioural theory of sequential algorithms (aka the sequential ASM
thesis) gives a partial answer by defining (non-deterministic) sequential
algorithms axiomatically, without referring to a particular machine model or
programming language, and showing that they are captured by (non-deterministic)
sequential Abstract State Machines (nd-seq ASMs). Moschovakis pointed out that
recursive algorithms such as mergesort are not covered by this theory. In this
article we propose an axiomatic definition of the notion of sequential
recursive algorithm which extends Gurevich's axioms for sequential algorithms
by a Recursion Postulate and allows us to prove that sequential recursive
algorithms are captured by recursive Abstract State Machines, an extension of
nd-seq ASMs by a CALL rule. Applying this recursive ASM thesis yields a
characterization of sequential recursive algorithms as finitely composed
concurrent algorithms all of whose concurrent runs are partial-order runs.Comment: 34 page
Automated Verification of Specifications with Typestates and Access Permissions
We propose an approach to formally verify Plural specifications of concurrent programs based on access permissions and typestates, by model-checking automatically generated abstract state-machines. Our approach captures all possible relevant behaviors of abstract concurrent programs implementing the specification. We describe the formal methodology employed in our technique and provide an example as proof of concept for the state-machine construction rules. We implemented the fully automated algorithm to generate and verify models as a freely available plug-in of the Plural tool, called Pulse.  We tested Pulse on the full specification of a Multi Threaded Task Server commercial application and showed that this approach scales well and is efficient in finding errors in specifications that could not be previously detected with the Data Flow Analysis (DFA) capabilities of Plural
Non-Deterministic Abstract Machines
We present a generic design of abstract machines for non-deterministic programming languages, such as process calculi or concurrent lambda calculi, that provides a simple way to implement them. Such a machine traverses a term in the search for a redex, making non-deterministic choices when several paths are possible and backtracking when it reaches a dead end, i.e., an irreducible subterm. The search is guaranteed to terminate thanks to term annotations the machine introduces along the way.
We show how to automatically derive a non-deterministic abstract machine from a zipper semantics - a form of structural operational semantics in which the decomposition process of a term into a context and a redex is made explicit. The derivation method ensures the soundness and completeness of the machines w.r.t. the zipper semantics
Abs: a high-level modeling language for cloud-aware programming
Cloud technology has become an invaluable tool to the IT business, because of its attractive economic model. Yet, from the programmers’ perspective, the development of cloud applications remains a major challenge. In this paper we introduce a programming language that allows Cloud applications to monitor and control their own deployment. Our language originates from the Abstract Behavioral Specification (ABS) language: a high-level object-oriented language for modeling concurrent systems.We extend the ABS language with Deployment Components which abstract over Virtual Machines of the Cloud and which enable any ABS application to distribute itself among multiple Cloud-machines. ABS models are executed by transforming them to distributed-object Haskell code. As a result, we obtain a Cloud-aware programming language which supports a full development cycle including modeling, resource analysis and code generation
Automated Verification of Specifications with Typestates and Access Permissions
We propose an approach to formally verify Plural specifications based on access permissions and typestates, by model-checking automatically generated abstract state-machines. Our exhaustive approach captures all the possible behaviors of abstract concurrent programs implementing the specification. We describe the formal methodology employed by our technique and provide an example as proof of concept for the state-machine construction rules. The implementation of a fully automated algorithm to generate and verify models, currently underway, provides model checking support for the Plural tool, which currently supports only program verification via data flow analysis (DFA)
AGENT-BASED NEGOTIATION PLATFORM IN COLLABORATIVE NETWORKED ENVIRONMENT
This paper proposes an agent-based platform to model and support parallel and concurrent negotiations among organizations acting in the same industrial market. The underlying complexity is to model the dynamic environment where multi-attribute and multi-participant negotiations are racing over a set of heterogeneous resources. The metaphor Interaction Abstract Machines (IAMs) is used to model the parallelism and the non-deterministic aspects of the negotiation processes that occur in Collaborative Networked Environment
- …