585,414 research outputs found
Requirements analysis of the VoD application using the tools in TRADE
This report contains a specification of requirements for a video-on-demand (VoD) application developed at Belgacom, used as a trial application in the 2RARE project. The specification contains three parts: an informal specification in natural language; a semiformal specification consisting of a number of diagrams intended to illustrate the informal specification; and a formal specification that makes the requiremants on the desired software system precise. The informal specification is structured in such a way that it resembles official specification documents conforming to standards such as that of IEEE or ESA. The semiformal specification uses some of the tools in from a requirements engineering toolkit called TRADE (Toolkit for Requirements And Design Engineering). The purpose of TRADE is to combine the best ideas in current structured and object-oriented analysis and design methods within a traditional systems engineering framework. In the case of the VoD system, the systems engineering framework is useful because it provides techniques for allocation and flowdown of system functions to components. TRADE consists of semiformal techniques taken from structured and object-oriented analysis as well as a formal specification langyage, which provides constructs that correspond to the semiformal constructs. The formal specification used in TRADE is LCM (Language for Conceptual Modeling), which is a syntactically sugared version of order-sorted dynamic logic with equality. The purpose of this report is to illustrate and validate the TRADE/LCM approach in the specification of distributed, communication-intensive systems
Software (Re-)Engineering with PSF III: an IDE for PSF
We describe the design of an integrated development environment (IDE) for
PSF. In the software engineering process we used process algebra in the form of
PSF for the specification of the architecture of the IDE. This specification is
refined to a PSF specification of the IDE system as a ToolBus application, by
applying vertical and horizontal implementation techniques. We implemented the
various tools as specified and connected them with a ToolBus script extracted
from the system specification
Low-Effort Specification Debugging and Analysis
Reactive synthesis deals with the automated construction of implementations
of reactive systems from their specifications. To make the approach feasible in
practice, systems engineers need effective and efficient means of debugging
these specifications.
In this paper, we provide techniques for report-based specification
debugging, wherein salient properties of a specification are analyzed, and the
result presented to the user in the form of a report. This provides a
low-effort way to debug specifications, complementing high-effort techniques
including the simulation of synthesized implementations.
We demonstrate the usefulness of our report-based specification debugging
toolkit by providing examples in the context of generalized reactivity(1)
synthesis.Comment: In Proceedings SYNT 2014, arXiv:1407.493
Software (Re-)Engineering with PSF II: from architecture to implementation
This paper presents ongoing research on the application of PSF in the field
of software engineering and reengineering. We build a new implementation for
the simulator of the PSF Toolkit starting from the specification in PSF of the
architecture of a simple simulator and extend it with features to obtain the
architecture of a full simulator. We apply refining and constraining techniques
on the specification of the architecture to obtain a specification low enough
to build an implementation from
Transforming ASN.1 Specifications into CafeOBJ to assist with Property Checking
The adoption of algebraic specification/formal method techniques by the
networks' research community is happening slowly but steadily. We work towards
a software environment that can translate a protocol's specification, from
Abstract Syntax Notation One (ASN.1 - a very popular specification language
with many applications), into the powerful algebraic specification language
CafeOBJ. The resulting code can be used to check, validate and falsify critical
properties of systems, at the pre-coding stage of development. In this paper,
we introduce some key elements of ASN.1 and CafeOBJ and sketch some first steps
towards the implementation of such a tool including a case study.Comment: 8 pages, 12 figure
A Semiparametric Approach to Estimate Engel curves using the US Micro Data
The study estimates Engel curves using cross-section data from the 2003 US consumer expenditure survey (CES). We focus on finding adequate specification for modeling the demographic characteristics using parametric, nonparametric, and semiparametric techniques. The empirical results indicate parametric Working-Leser or Piglog specification was sufficient for most budget shares except for transportation where semiparametric specification had support.Consumer/Household Economics,
Testing refinements by refining tests
One of the potential benefits of formal methods is that they offer the possibility of reducing the costs of testing. A specification acts as both the benchmark against which any implementation is tested, and also as the means by which tests are generated. There has therefore been interest in developing test generation techniques from formal specifications, and a number of different methods have been derived for state based languages such as Z, B and VDM. However, in addition to deriving tests from a formal specification, we might wish to refine the specification further before its implementation. The purpose of this paper is to explore the relationship between testing and refinement. As our model for test generation we use a DNF partition analysis for operations written in Z, which produces a number of disjoint test cases for each operation. In this paper we discuss how the partition analysis of an operation alters upon refinement, and we develop techniques that allow us to refine abstract tests in order to generate test cases for a refinement. To do so we use (and extend existing) methods for calculating the weakest data refinement of a specification
Modeling the dialogue aspects of an information system.
In this paper we investigate techniques offered by current object-oriented development methods for the specification of the user-system dialogue aspect of a software system. Current development methods do not give very extensive guidelines on how to model this aspect and the available techniques need some refinement and elaboration to fit this particular task in the software specification process. The paper first compares a number of approaches. The common elements of these approaches are summarized and further developed into one comprehensive set of techniques that addresses the needs of functional requirements analysis.
A theory of normed simulations
In existing simulation proof techniques, a single step in a lower-level
specification may be simulated by an extended execution fragment in a
higher-level one. As a result, it is cumbersome to mechanize these techniques
using general purpose theorem provers. Moreover, it is undecidable whether a
given relation is a simulation, even if tautology checking is decidable for the
underlying specification logic. This paper introduces various types of normed
simulations. In a normed simulation, each step in a lower-level specification
can be simulated by at most one step in the higher-level one, for any related
pair of states. In earlier work we demonstrated that normed simulations are
quite useful as a vehicle for the formalization of refinement proofs via
theorem provers. Here we show that normed simulations also have pleasant
theoretical properties: (1) under some reasonable assumptions, it is decidable
whether a given relation is a normed forward simulation, provided tautology
checking is decidable for the underlying logic; (2) at the semantic level,
normed forward and backward simulations together form a complete proof method
for establishing behavior inclusion, provided that the higher-level
specification has finite invisible nondeterminism.Comment: 31 pages, 10figure
- …