Sequence-based Specification Research Articles

An Algorithm for Forward Reduction in Sequence-Based Software Specification

Sequence-based software specification is a rigorous method for deriving a formal system model based on informal requirements, through a systematic process called sequence enumeration. Under this process, stimulus (input) sequences are considered in a breadth-first manner, with the expected system response to each sequence given. Not every sequence needs to be further extended by the enumeration rules. The completed specification encodes a Mealy machine and forms a basis for other activities including code development and testing. This paper presents a forward reduction algorithm for sequence-based specification. The need for such an algorithm has been identified by field applications. We used the state machine as an intermediate tool to comprehend and analyze all change impacts resulted from a forward reduction, and used an axiom system for its development. We present the algorithm both mathematically in functional form and procedurally in pseudocode, illustrate it with a symbolic example, and report a larger case study from the published literature in which the algorithm is applied. The algorithm will prove useful and effective in deriving a system-level specification as well as in merging and combining partial work products towards a formal system model in field applications.

Applying string-rewriting to sequence-based specification

Sequence-based specification is a constructive method designed to convert ordinary functional requirements (that are often imprecisely and informally composed) into precise specifications. The method prompts a human requirements analyst to make the many decisions necessary to resolve the ambiguities, omissions, inconsistencies, and errors inherent in the original requirements document, and construct a complete, consistent, and traceably correct specification. We find that string-rewriting theory can be applied to make a number of these decisions automatically. In this paper we develop a method of applying string-rewriting to sequence enumeration. We give prescriptions on how prefix rewrite rules and general string rewrite rules can be declared, and used later in the process to automatically make new equivalences thereby prompting the human for fewer decisions. Based on the results we present an enhanced enumeration process, in which one develops working enumerations and working reduction systems concurrently, applying string-rewriting to deduce new reductions as needed, until a complete enumeration is obtained. We present data from four published applications that shows the feasibility and applicability of applying string-rewriting. In addition to effort reduction we have observed the benefit of eliminating rework achieved by consistent decisions, as well as an additional opportunity string-rewriting provides for validation of specification decisions to requirements.

An axiom system for sequence-based specification

This paper establishes an axiomatic foundation and a representation theorem for the rigorous, constructive process, called sequence-based specification, of deriving precise specifications from ordinary (informal) statements of functional requirements. The representation theorem targets a special class of Mealy state machines, and algorithms are presented for converting from the set of sequences that define the specification to the equivalent Mealy machine, and vice versa. Since its inception, sequence-based specification has been effectively used in a variety of real applications, with gains reported in quality and productivity. This paper establishes the mathematical foundation independently of the process itself.

Pushing requirements changes through to changes in specifications

Requirements changes can occur both during and after a phase of development for a variety of reasons, including error correction and feature changes. It is difficult and intensive work to integrate requirements changes made after specification is completed. Sequence-based specification was developed to convert ordinary functional software requirements into complete, consistent, and traceably correct specifications through a constructive process. Algorithms for managing requirements changes meet a very great need in field application of the sequence-based specification method. In this paper we propose to capture requirements changes as a series of atomic changes in specifications, and present polynomial-time algorithms for managing these changes. The algorithms are built into the tool support with which users are able to push requirements changes through to changes in specifications, maintain old specifications over time and evolve them into new specifications with the least amount of human interaction and rework. All our change algorithms are supported by rigorous mathematical formulation and proof of correctness. The application example is a safe controller.

Precision software

Most branches of engineering routinely apply mathematics to their specification and design. Modelling a design is cheaper than building a prototype and testing it. The one exception is software engineering. In the main, mathematical techniques are not routinely applied to software specification or design. Instead, reliance is placed on informal inspection-based methods and testing. Consequently, defects injected early in the lifecycle during specification and design activities are frequently not detected and removed until after implementation is substantially complete and integration testing begins. This is the most expensive time to correct defects. An alternative is to use an approach that combines the practical application of software engineering mathematics and modelling with specification methods that avoid difficult mathematical notations. Our method, analytical software design (ASD), uses the sequence-based specification method to specify functional performance requirements and designs as black box functions. The article describes how the use of these methods in the design of a control system for Philips resulted in software with fewer defects without increasing the cost of development.