2,884 research outputs found
Executable formal specifications of complex distributed systems with CoreASM
Formal specifications play a crucial role in the design of reliable complex software systems. Executable formal specifications allow the designer to attain early validation and verification of design using static analysis techniques and accurate simulation of the runtime behavior of the system-to-be. With increasing complexity of software-intensive computer-based systems and the challenges of validation and verification of abstract software models prior to coding, the need for interactive software tools supporting executable formal specifications is even more evident. In this paper, we discuss how CoreASM, an environment for writing and running executable specifications according to the ASM method, provides flexibility and manages the complexity by using an innovative extensible language architecture
VAMP: semantic validation for MPEG-7 profile descriptions
MPEG-7 can be used to create complex and comprehensive metadata descriptions of multimedia content. Since MPEG-7 is defined in terms of an XML schema, the semantics of its elements has no formal grounding. In addition, certain features can be described in multiple ways. MPEG-7 profiles are subsets of the standard that apply to specific application areas and that aim to reduce this syntactic variability, but they still lack formal semantics. We propose an approach for expressing the semantics explicitly
Formal Specification and Verification for Automated Production Systems
Complex industrial control software often drives safety- and mission-critical
systems, like automated production plants or control units embedded into devices in automotive systems. Such controllers have in common that they are reactive systems, i.e., that they periodically read sensor stimuli and cyclically execute the same program to produce actuator signals.
The correctness of software for automated production is rarely verified using
formal techniques. Although, due to the Industrial Revolution 4.0 (IR4.0), the
impact and importance of software have become an important role in industrial automation.
What is used instead in industrial practice today is testing and simulation,
where individual test cases are used to validate an automated production system.
Three reasons why formal methods are not popular are: (a) It is difficult to
adequately formulate the desired temporal properties. (b) There is a lack of
specification languages for reactive systems that are both sufficiently
expressive and comprehensible for practitioners. (c) Due to the lack of an
environment model the obtained results are imprecise. Nonetheless, formal
methods for automated production systems are well studied academically---mainly on the verification of safety properties via model checking.
In this doctoral thesis we present the concept of (1) generalized test tables
(GTTs), a new specification language for functional properties, and their
extension (2) relational test tables (RTTs) for relational properties. The
concept includes the syntactical notion, designed for the intuition of
engineers, and the semantics, which are based on game theory. We use RTTs for a novel confidential property on reactive systems, the provably forgetting of information. Moreover, for regression verification, an important relational
property, we are able to achieve performance improvements by (3) creating
a decomposing rule which splits large proofs into small sub-task. We implemented the verification procedures and evaluated them against realistic case studies, e.g., the Pick-and-Place-Unit from the Technical University of Munich.
The presented contribution follows the idea of lowering the obstacle of
verifying the dependability of reactive systems in general, and automated
production systems in particular for the engineer either by introducing a new
specification language (GTTs), by exploiting existing programs for the
specification (RTTs, regression verification), or by improving the verification
performance
Deploying ontologies in software design
In this thesis we will be concerned with the relation between ontologies and software
design. Ontologies are studied in the artificial intelligence community as a means to
explicitly represent standardised domain knowledge in order to enable knowledge shar¬
ing and reuse. We deploy ontologies in software design with emphasis on a traditional
software engineering theme: error detection. In particular, we identify a type of error
that is often difficult to detect: conceptual errors. These are related to the description
of the domain whom which the system will operate. They require subjective knowledge
about correct forms of domain description to detect them. Ontologies provide these
forms of domain description and we are interested in applying them and verify their
correctness(chapter 1). After presenting an in depth analysis of the field of ontologies
and software testing as conceived and implemented by the software engineering and
artificial intelligence communities(chapter 2), we discuss an approach which enabled
us to deploy ontologies in the early phases of software development (i.e., specifications)
in order to detect conceptual errors (chapter 3). This is based on the provision of ontological axioms which are used to verify conformance of specification constructs to
the underpinning ontology. To facilitate the integration of ontology with applications
that adopt it we developed an architecture and built tools to implement this form of
conceptual error check(chapter 4). We apply and evaluate the architecture in a variety
of contexts to identify potential uses (chapter 5). An implication of this method for de¬
ploying ontologies to reason about the correctness of applications is to raise our trust
in the given ontologies. However, when the ontologies themselves are erroneous we
might fail to reveal pernicious discrepancies. To cope with this problem we extended
the architecture to a multi-layer form(chapter 4) which gives us the ability to check the
ontologies themselves for correctness. We apply this multi-layer architecture to cap¬
ture errors found in a complex ontologies lattice(chapter 6). We further elaborate on
the weaknesses in ontology evaluation methods and employ a technique stemming from
software engineering, that of experience management, to facilitate ontology testing and
deployment(chapter 7). The work presented in this thesis aims to improve practice in
ontology use and identify areas to which ontologies could be of benefits other than the
advocated ones of knowledge sharing and reuse(chapter 8)
- …