18,782 research outputs found
Detecting and correcting errors in parallel object oriented systems
Our research concerns the development of an operational formalism for the in-source specification of parallel, object oriented systems. These specifications are used to enunciate the behavioural semantics of objects, as a means of enhancing their reliability. A review of object oriented languages concludes that the advance in language sophistication heralded by the object oriented paradigm has, so far, failed to produce a commensurate increase in software reliability. The lack of support in modern object oriented languages for the notion of 'valid object behaviour', as distinct from state and operations, undermines the potential power of the abstraction. Furthermore, it weakens the ability of such languages to detect behavioural problems, manifest at run-time. As a result, in-language facilities for the signalling and handling of undesirable program behaviours or states (for example, assertions) are still in their infancy. This is especially true of parallel systems, where the scope for subtle error is greater. The first goal of this work was to construct an operational model of a general purpose, parallel, object oriented system in order to ascertain the fundamental set of event classes that constitute its observable behaviour. Our model is built on the CSP process calculus and uses a subset of the Z notation to express some aspects of state. This alphabet was then used to construct a formalism designed to augment each object type description with the operational specification of an object's behaviour: Event Pattern Specifications (EPS). EPSs are a labeled list of acceptable object behaviours which form part of the definition of every type. The thesis includes a description of the design and implementation of EPSs as part of an exception handling mechanism for the parallel, object oriented language Solve. Using this implementation, we have established that the run-time checking of EPS specifications is feasible, albeit it with considerable overhead. Issues arising from this implementation are discussed and we describe the visualization of EPSs and their use in semantic browsing
Modal logics for reasoning about object-based component composition
Component-oriented development of software supports the adaptability and maintainability of large systems, in particular if requirements change over time and parts of a system have to be modified or replaced. The software architecture in such systems can be described by components
and their composition. In order to describe larger architectures, the composition concept becomes crucial. We will present a formal framework for component composition for object-based software development. The deployment of modal logics for defining components and component composition will allow us to reason about and prove properties of components and compositions
PLACES'10: The 3rd Workshop on Programmng Language Approaches to concurrency and Communication-Centric Software
Paphos, Cyprus. March 201
Expression-based aliasing for OO-languages
Alias analysis has been an interesting research topic in verification and
optimization of programs. The undecidability of determining whether two
expressions in a program may reference to the same object is the main source of
the challenges raised in alias analysis. In this paper we propose an extension
of a previously introduced alias calculus based on program expressions, to the
setting of unbounded program executions s.a. infinite loops and recursive
calls. Moreover, we devise a corresponding executable specification in the
K-framework. An important property of our extension is that, in a
non-concurrent setting, the corresponding alias expressions can be
over-approximated in terms of a notion of regular expressions. This further
enables us to show that the associated K-machinery implements an algorithm that
always stops and provides a sound over-approximation of the "may aliasing"
information, where soundness stands for the lack of false negatives. As a case
study, we analyze the integration and further applications of the alias
calculus in SCOOP. The latter is an object-oriented programming model for
concurrency, recently formalized in Maude; K-definitions can be compiled into
Maude for execution
Combining behavioural types with security analysis
Today's software systems are highly distributed and interconnected, and they
increasingly rely on communication to achieve their goals; due to their
societal importance, security and trustworthiness are crucial aspects for the
correctness of these systems. Behavioural types, which extend data types by
describing also the structured behaviour of programs, are a widely studied
approach to the enforcement of correctness properties in communicating systems.
This paper offers a unified overview of proposals based on behavioural types
which are aimed at the analysis of security properties
- …