In this paper a proof Outline logic is introduced for the partial correctness of multi-threaded object-oriented programs like in Java. the main contribution is a generalization of the Owicki & Gries proof method f...
详细信息
In this paper a proof Outline logic is introduced for the partial correctness of multi-threaded object-oriented programs like in Java. the main contribution is a generalization of the Owicki & Gries proof method for shared-variable concurrency to dynamic thread creation. this paper also provides a formal justification of this generalization in terms of soundness and completeness proofs. (C) 2008 Elsevier B.V. All rights reserved.
In this paper, we present an approach to define the semantics for object-oriented modeling languages. One important property of this semantics is to support underspecified and incomplete models. To this end, semantics...
详细信息
ISBN:
(纸本)9783642021374
In this paper, we present an approach to define the semantics for object-oriented modeling languages. One important property of this semantics is to support underspecified and incomplete models. To this end, semantics is given as predicates over elements of the semantic domain. this domain is called the system model which is a general declarative characterization of objectsystems. the system model is very detailed since it captures various relevant structural, behavioral, and interaction aspects. this allows us to re-use the system model as a. domain for various kinds of object-oriented modeling languages. As a major consequence, the integration of language semantics is straight-forward. the whole approach is supported by tools that do not constrain the semantics definition's expressiveness and flexibility while making it machine-checkable.
there is an impedance mismatch between message-passing concurrency and virtual machines, such as the JVM. VMs usually map their threads to heavyweight OS processes. Without a lightweight process abstraction, users are...
详细信息
there is an impedance mismatch between message-passing concurrency and virtual machines, such as the JVM. VMs usually map their threads to heavyweight OS processes. Without a lightweight process abstraction, users are often forced to write parts of concurrent applications in an event-driven style which obscures control flow,and increases the burden on the programmer. In this paper we show how thread-based and event-based programming can be unified under a single actor abstraction. Using advanced abstraction mechanisms of the Scala programming language, we implement our approach on unmodified JVMs. Our programming model integrates well withthe threading model of the underlying VM. (C) 2008 Elsevier B.V. All rights reserved.
Building complex component-based software systems, for instance communication systemsbased on the Click, Coyote, Appia, or Dream frameworks, call lead to subtle assemblage errors. We present a novel type system and t...
详细信息
ISBN:
(纸本)9783642021374
Building complex component-based software systems, for instance communication systemsbased on the Click, Coyote, Appia, or Dream frameworks, call lead to subtle assemblage errors. We present a novel type system and type inference algorithm that prevent interconnection and message-handling errors when assembling component-based communication systems. these errors are typically not captured by classical type systems of host programming languages such as Java or ML. have implemented our approach by extending the description language (ADL) toolset. used by the Dream framework, and used it to check Dream-based communication systems.
We suggest an amalgamation of communication-based programming (centered on sessions) and object-oriented programming, whereby sessions between concurrent threads are amalgamated withmethods. In our proposal, threads ...
详细信息
We suggest an amalgamation of communication-based programming (centered on sessions) and object-oriented programming, whereby sessions between concurrent threads are amalgamated withmethods. In our proposal, threads consist of the execution of session bodies on objects and communicate with each other by asynchronously sending/receiving objects on channels. the response to a session request is based on the name of the request and the class of the object receiving the request. the decision of how to continue a session is based on the class of the object sent/received. Sessions can be delegated to other sessions, although sessions themselves are not first class objects. We demonstrate our ideas through a core language with generic types, SAM(9), and an example. We then formalize a small calculus, FSAM(9), and prove subject reduction and progress. the latter property is notoriously difficult to achieve in concurrent calculi. (C) 2008 Elsevier B.V. All rights reserved.
distributed Algorithms are hard to prove correct. In settings with process failures, things, get worse. Among the proof methods proposed in this context, WO focus On process calculi, which offer a tight connection of ...
详细信息
ISBN:
(纸本)9783642021374
distributed Algorithms are hard to prove correct. In settings with process failures, things, get worse. Among the proof methods proposed in this context, WO focus On process calculi, which offer a tight connection of proof concepts to the actual code representing the algorithm. We use distributed Consensus as a. case study to evaluate recent developments in this field. Along the way, we find that the classical assertional style for proofs oil distributed algorithms can be used to structure bisimulation relations. For this, we propose the definition of uniform syntactic descriptions of reachable states, oil which state-based assertions call be conveniently formulated. As a result, we get, the best of both worlds: on the one hand invariant-style representation of proof knowledge;oil the other hand the bisimulation-basedformal connection to the code.
this, paper extends dynamic symbolic execution to distributed mid concurrent systems. Dynamic symbolic execution is used to systematically identify equivalence classes of input, values and has been shown to scale well...
详细信息
ISBN:
(纸本)9783642021374
this, paper extends dynamic symbolic execution to distributed mid concurrent systems. Dynamic symbolic execution is used to systematically identify equivalence classes of input, values and has been shown to scale well to large systems. Although mainly;applied to sequential programs, this scalability makes, it interesting to consider the technique, in the distributed and concurrent setting as well. In order to extend the technique to collcurrent systems: it is necessary to obtain sufficient control over the scheduling of concurrent, activities to avoid race conditions. Creol, a modeling language for distributed concurrent objects, solves this problem by abstracting from a particular scheduling policy but explicity defining scheduling points. this provides sufficient, control to apply the technique of dynamic symbolic of interleaved processes. the technique has been formalized in rewriting logic and executes in Mande.
In this work we present a type graph that models all executable construct's of the Java programming language. Such a model is useful for any, graph-based technique that, relies oil a representation of Java program...
详细信息
ISBN:
(纸本)9783642021374
In this work we present a type graph that models all executable construct's of the Java programming language. Such a model is useful for any, graph-based technique that, relies oil a representation of Java programs as graphs. the model can be regarded as a common representation to which to all Java syntax graphs must adhere. We also present the systematic approach that is being taken to generate syntax graphs front Java code. Since the type graph model is comprehensive. i.e., covers the whole language specification, the technique is guaranteed to generate a corresponding graph for any valid Java program. In particular, we want to extract such syntax graphs in order to perform static analysis and model checking of programs written ill Java. Although we focus oil Java, this same approach could be adapted for other programming languages.
Our aim is to define the kernel of a simple and uniform programming model-the reactor model-which can serve as a foundation for building and evolving internet-scale programs. Such programs are characterized by collect...
详细信息
Our aim is to define the kernel of a simple and uniform programming model-the reactor model-which can serve as a foundation for building and evolving internet-scale programs. Such programs are characterized by collections of loosely-coupled distributed components that are assembled on the fly to produce a composite application. A reactor consists of two principal components: mutable state, in the form of a fixed collection of relations, and code, in the form of a fixed collection of rules in the style of Datalog. A reactor's code is executed in response to an external stimulus, which takes the form of an attempted update to the reactor's state. As in classical process calculi, the reactor model accommodates collections of distributed, concurrently executing processes. However, unlike classical process calculi, our observable behaviors are sequences of states, rather than sequences of messages. Similarly, the interface to a reactor is simply its state, rather than a collection of message channels, ports, or methods. One novel feature of our model is the ability to compose behaviors both synchronously and asynchronously. Also, our use of Datalog-style rules allows aspect-like composition of separately-specified functional concerns in a natural way. (C) 2008 Elsevier B.V. All rights reserved.
暂无评论