135,754 research outputs found
Recommended from our members
Using formal methods to support testing
Formal methods and testing are two important approaches that assist in the development of high quality software. While traditionally these approaches have been seen as rivals, in recent
years a new consensus has developed in which they are seen as complementary. This article reviews the state of the art regarding ways in which the presence of a formal specification can be used to assist testing
Reconciling a component and process view
In many cases we need to represent on the same abstraction level not only
system components but also processes within the system, and if for both
representation different frameworks are used, the system model becomes hard to
read and to understand. We suggest a solution how to cover this gap and to
reconcile component and process views on system representation: a formal
framework that gives the advantage of solving design problems for large-scale
component systems.Comment: Preprint, 7th International Workshop on Modeling in Software
Engineering (MiSE) at ICSE 201
Model-Based Testing of Safety Critical Real-Time Control Logic Software
The paper presents the experience of the authors in model based testing of
safety critical real-time control logic software. It describes specifics of the
corresponding industrial settings and discusses technical details of usage of
UniTESK model based testing technology in these settings. Finally, we discuss
possible future directions of safety critical software development processes
and a place of model based testing techniques in it.Comment: In Proceedings MBT 2012, arXiv:1202.582
A Formal Approach based on Fuzzy Logic for the Specification of Component-Based Interactive Systems
Formal methods are widely recognized as a powerful engineering method for the
specification, simulation, development, and verification of distributed
interactive systems. However, most formal methods rely on a two-valued logic,
and are therefore limited to the axioms of that logic: a specification is valid
or invalid, component behavior is realizable or not, safety properties hold or
are violated, systems are available or unavailable. Especially when the problem
domain entails uncertainty, impreciseness, and vagueness, the appliance of such
methods becomes a challenging task. In order to overcome the limitations
resulting from the strict modus operandi of formal methods, the main objective
of this work is to relax the boolean notion of formal specifications by using
fuzzy logic. The present approach is based on Focus theory, a model-based and
strictly formal method for componentbased interactive systems. The contribution
of this work is twofold: i) we introduce a specification technique based on
fuzzy logic which can be used on top of Focus to develop formal specifications
in a qualitative fashion; ii) we partially extend Focus theory to a fuzzy one
which allows the specification of fuzzy components and fuzzy interactions.
While the former provides a methodology for approximating I/O behaviors under
imprecision, the latter enables to capture a more quantitative view of
specification properties such as realizability.Comment: In Proceedings FESCA 2015, arXiv:1503.0437
A Survey of Languages for Specifying Dynamics: A Knowledge Engineering Perspective
A number of formal specification languages for knowledge-based systems has been developed. Characteristics for knowledge-based systems are a complex knowledge base and an inference engine which uses this knowledge to solve a given problem. Specification languages for knowledge-based systems have to cover both aspects. They have to provide the means to specify a complex and large amount of knowledge and they have to provide the means to specify the dynamic reasoning behavior of a knowledge-based system. We focus on the second aspect. For this purpose, we survey existing approaches for specifying dynamic behavior in related areas of research. In fact, we have taken approaches for the specification of information systems (Language for Conceptual Modeling and TROLL), approaches for the specification of database updates and logic programming (Transaction Logic and Dynamic Database Logic) and the generic specification framework of abstract state machine
Reusing Test-Cases on Different Levels of Abstraction in a Model Based Development Tool
Seamless model based development aims to use models during all phases of the
development process of a system. During the development process in a
component-based approach, components of a system are described at qualitatively
differing abstraction levels: during requirements engineering component models
are rather abstract high-level and underspecified, while during implementation
the component models are rather concrete and fully specified in order to enable
code generation. An important issue that arises is assuring that the concrete
models correspond to abstract models. In this paper, we propose a method to
assure that concrete models for system components refine more abstract models
for the same components. In particular we advocate a framework for reusing
testcases at different abstraction levels. Our approach, even if it cannot
completely prove the refinement, can be used to ensure confidence in the
development process. In particular we are targeting the refinement of
requirements which are represented as very abstract models. Besides a formal
model of our approach, we discuss our experiences with the development of an
Adaptive Cruise Control (ACC) system in a model driven development process.
This uses extensions which we implemented for our model-based development tool
and which are briefly presented in this paper.Comment: In Proceedings MBT 2012, arXiv:1202.582
Reverse Engineering from Assembler to Formal Specifications via Program Transformations
The FermaT transformation system, based on research carried out over the last
sixteen years at Durham University, De Montfort University and Software
Migrations Ltd., is an industrial-strength formal transformation engine with
many applications in program comprehension and language migration. This paper
is a case study which uses automated plus manually-directed transformations and
abstractions to convert an IBM 370 Assembler code program into a very
high-level abstract specification.Comment: 10 page
Refinement for user interface designs
Formal approaches to software development require that we correctly describe (or specify) systems in order to prove properties about our proposed solution prior to building it. We must then follow a rigorous process to transform our specification into an implementation to ensure that the properties we have proved are retained. Different transformation, or refinement, methods exist for different formal methods, but they all seek to ensure that we can guide the transformation in a way which preserves the desired properties of the system. Refinement methods also allow us to subsequently compare two systems to see if a refinement relation exists between the two. When we design and build the user interfaces of our systems we are similarly keen to ensure that they have certain properties before we build them. For example, do they satisfy the requirements of the user? Are they designed with known good design principles and usability considerations in mind? Are they correct in terms of the overall system specification? However, when we come to implement our interface designs we do not have a defined process to follow which ensures that we maintain these properties as we transform the design into code. Instead, we rely on our judgement and belief that we are doing the right thing and subsequent user testing to ensure that our final solution remains useable and satisfactory. We suggest an alternative approach, which is to define a refinement process for user interfaces which will allow us to maintain the same rigorous standards we apply to the rest of the system when we implement our user interface designs
- …