Specifications are (preferably) executable

@article{Fuchs1992SpecificationsA,
  title={Specifications are (preferably) executable},
  author={Norbert E. Fuchs},
  journal={Softw. Eng. J.},
  year={1992},
  volume={7},
  pages={323-334}
}
The validation of specifications with respect to user requirements is extremely difficult. To ease the validation task and to give users immediate feedback on the behaviour of the future software, it was suggested that specifications should be made executable. However, Hayes and Jones [1] argue that executable specifications should be avoided because executability can restrict the expressiveness of specification langugages, and can adversely affect implementations. We argue for executable… 
Executing formal specifications need not be harmful
TLDR
There are circumstances when executable specifications can be of high value but that execution must be used together with, and as a supplement to, other methods of validating specifications such as inspection and proof.
Heterogeneous Security Policy Validation: From Formal to Executable Specifications
TLDR
Through accurate examples, it is shown how executables specifications can be used in conjunction with formal specification in the frame of the security policy engineering process.
A Generic and Executable Model for the Specification and Validation of Distributed Behaviors
TLDR
An executable model based approach to validate distributed behavior specifications is presented and a Scheme programming environment is shown to be a valuable option to support the implementation, in particular for dynamic debugging purposes.
Executing Formal Specifications with Concurrent Constraint Programming
TLDR
This work has implemented a technique for execution of formal, model-based specifications based on translating specifications to the concurrent constraint programming language AKL that is amenable to any formal specification language based on a finite number of intrinsic types and pre- and postcondition assertions.
Towards Expressive Specification and Efficient Model Checking
  • J. Dong, Jun Sun
  • Computer Science
    2009 Third IEEE International Symposium on Theoretical Aspects of Software Engineering
  • 2009
TLDR
This tutorial introduces a process analysis toolkit (PAT) which is a self-contained framework for system specification, simulation and verification and supports a modeling language named CSP# (short for communicating sequential programs).
Engineering formal requirements: An analysis and testing method for Z documents
TLDR
Two techniques for analyzing and testing Z specification documents are described, which make it possible to build directly from the requirements specification document a distributed prototype which can be executed and tested over a network of workstations.
Executable specifications and CASE
TLDR
The paper considers executability within CASE, with a focus on executable specifications, and an experimental executable specification tool is presented.
High-Integrity System Specification and Design
TLDR
Different semantic abstraction functions make it possible to describe multiple views of the same equivalence class of systems, or similarly, impose different kinds of constraints on these systems.
From Executable Specifications to Java
TLDR
A pair of constructs in a forma l specification language that can be directly translated into relatively efficient code are lgebraic types and (an extended concept of logical) quantification.
Computer-Aided Validation of Formal Conceptual Models
TLDR
This thesis presents a systematic approach and workbench environment to support the construction and validation through animation of TROLL specifications, an iterative requirements definition process consisting of the formal specification of requirements, the automatic transformation of the specification into an executable form, and the interactive animation of the executable version to validate user requirements.
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 48 REFERENCES
Specifications are not (necessarily) executable
TLDR
This paper presents a number of arguments against the idea that specifications might be executed, and warns of the dangers of limiting specification languages to the point where all of their constructs can be executed.
An overview and bibliography of ENCOMPASS: an environment for incremental software development using executable, logic-based specification
It has also been suggested that methods combining stepwise refinment with formal proof can help solve the verification problem. In these methods, components are first specified using using a
Specifications: Formal and informal—a case study
  • N. Gehani
  • Computer Science
    Softw. Pract. Exp.
  • 1982
TLDR
A comparison of the two specifications shows that although informal specifications are easier to read, the formal specifications are clearer and specify operation domains precisely, define the interaction between the operations, and show the incompleteness of the informal specifications.
Specifications of distributed systems in prolog
  • H. Ural
  • Computer Science
    J. Syst. Softw.
  • 1990
The relation between logic programming and logic specification
  • R. Kowalski
  • Computer Science
    Philosophical Transactions of the Royal Society of London. Series A, Mathematical and Physical Sciences
  • 1984
TLDR
This paper shall investigate the relation that holds when both programs and program specifications are expressed in formal logic, when all relations defined by complete specifications are executable.
Hoare Logic, Executable Specifications and Logic Programs
TLDR
This work discusses two methods to construct logic programs from logic specifications, and derives more efficient programs by structural induction.
An Operational Approach to Requirements Specification for Embedded Systems
  • P. Zave
  • Computer Science
    IEEE Transactions on Software Engineering
  • 1982
The approach to requirements specification for embedded systems described in this paper is called "operational" because a requirements specification is an executable model of the proposed system
The Synthesis of Logic Programs from Inductive Proofs
TLDR
To make the technique work it is necessary to synthesise pure logic programs, without the closed world assumption, and then compile these into Prolog programs.
Making Prolog more Expressive
...
1
2
3
4
5
...