4 research outputs found
On the Specification of Components - the JavaBeans Example
Rapport interne.We specify the JavaBean component model and concrete beans using a combination of UML class diagrams, an extension of Object-Z, and life sequence charts. We extend Object-Z by keywords that allow one to concisely describe the interface of a bean by an Object-Z class specification. The component model specification provides specification templates consisting of class diagrams, Object-Z fragments, and life sequence charts that precisely capture the functional behavior of beans in general, including the interaction of beans that cooperate in a system. The new keywords used for specifying concrete beans translate to instances of the component model specification templates, showing that our extension of Object-Z is syntactical sugar only
Compositional Verification for Object-Z
This paper presents a framework for compositional verification of Object-Z specifications. Its key feature is a proof rule based on decomposition of hierarchical Object-Z models. For each component in the hierarchy local properties are proven in a single proof step. However, we do not consider components in isolation. Instead, components are envisaged in the context of the referencing super-component and proof steps involve assumptions on properties of the sub-components. The framework is defined for linear temporal logic (LTL)
Encoding Object-Z in Isabelle-HOL
In this paper, we present a formalisation of the reference semantics of Object-Z in the higher-order logic (HOL) instantiation of the generic theorem prover Isabelle, Isabelle/HOL. This formalisation has the effect of both clarifying the semantics and providing the basis for a theorem prover for Object-Z. The work builds on an earlier encoding of a value semantics for object-oriented Z in Isabelle/HOL and a denotational semantics of Object-Z based on separating the internal and external effects of class methods
Towards the formalisation of use case maps
Formal specification of software systems has been very promising. Critics against the end
results of formal methods, that is, producing quality software products, is certainly rare. Instead,
reasons have been formulated to justify why the adoption of the technique in industry
remains limited. Some of the reasons are:
• Steap learning curve; formal techniques are said to be hard to use.
• Lack of a step-by-step construction mechanism and poor guidance.
• Difficulty to integrate the technique into the existing software processes.
Z is, arguably, one of the successful formal specification techniques that was extended to
Object-Z to accommodate object-orientation. The Z notation is based on first-order logic
and a strongly typed fragment of Zermelo-Fraenkel set theory. Some attempts have been
made to couple Z with semi-formal notations such as UML. However, the case of coupling
Object-Z (and also Z) and the Use Case Maps (UCMs) notation is still to be explored.
A Use Case Map (UCM) is a scenario-based visual notation facilitating the requirements
definition of complex systems. A UCM may be generated either from a set of informal
requirements, or from use cases normally expressed in natural language. UCMs have the
potential to bring more clarity into the functional description of a system. It may furthermore
eliminate possible errors in the user requirements. But UCMs are not suitable to reason
formally about system behaviour.
In this dissertation, we aim to demonstrate that a UCM can be transformed into Z and
Object-Z, by providing a transformation framework. Through a case study, the impact of
using UCM as an intermediate step in the process of producing a Z and Object-Z specification
is explored. The aim is to improve on the constructivity of Z and Object-Z, provide more
guidance, and address the issue of integrating them into the existing Software Requirements
engineering process.Computer ScienceM. Sc. (Computer Science)D. Phil. (Computer Science