A Multipurpose Backtracking Algorithm

Priestley, H. A.; Ward, Martin

doi:10.1006/jsco.1994.1035

Cited by 27 publications

(19 citation statements)

References 18 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…exit(n) causes immediate termination of the n enclosing levels of nested floops. See [PrW94,War04] for more detailed discussion of these constructs and associated transformations.…”

Section: The Wsl Languagementioning

confidence: 99%

See 1 more Smart Citation

Provably correct derivation of algorithms using FermaT

Ward

Zedan

2014

Form. Asp. Comput.

View full text Add to dashboard Cite

The transformational programming method of algorithm derivation starts with a formal specification of the result to be achieved, plus some informal ideas as to what techniques will be used in the implementation. The formal specification is then transformed into an implementation, by means of correctness-preserving refinement and transformation steps, guided by the informal ideas. The transformation process will typically include the following stages:(1) Formal specification (2) Elaboration of the specification, (3) Divide and conquer to handle the general case (4) Recursion introduction, (5) Recursion removal, if an iterative solution is desired, (6) Optimisation, if required. At any stage in the process, sub-specifications can be extracted and transformed separately. The main difference between this approach and the invariant based programming approach (and similar stepwise refinement methods) is that loops can be introduced and manipulated while maintaining program correctness and with no need to derive loop invariants. Another difference is that at every stage in the process we are working with a correct program: there is never any need for a separate "verification" step. These factors help to ensure that the method is capable of scaling up to the development of large and complex software systems. The method is applied to the derivation of a complex linked list algorithm and produces code which is over twice as fast as the code written by Donald Knuth to solve the same problem.

show abstract

“…exit(n) causes immediate termination of the n enclosing levels of nested floops. See [PrW94,War04] for more detailed discussion of these constructs and associated transformations.…”

Section: The Wsl Languagementioning

confidence: 99%

“…There may be a special action Z (with no body): call Z results in the immediate termination of the whole action system with execution continuing with the next statement after the action system (if any). See [PrW94,War04] for more detailed discussion of action systems and associated transformations.…”

Section: The Wsl Languagementioning

confidence: 99%

Provably correct derivation of algorithms using FermaT

Ward

Zedan

2014

Form. Asp. Comput.

View full text Add to dashboard Cite

show abstract

“…We can simplify the if statement by using an iteration over a sequence (see [41] for the formal definition):…”

Section: Change Data Representationmentioning

confidence: 99%

“…closer to a programming language implementation), and transforming a recursive procedure into a different form. The transformation is also used in the algorithm derivations of [3,9] and [41].…”

Section: Introducing Recursionmentioning

confidence: 99%

Recursion Removal/Introduction by Formal Transformation: An Aid to Program Development and Program Comprehension

Ward¹,

Bennett²

1999

The Computer Journal

View full text Add to dashboard Cite

The transformation of a recursive program to an iterative equivalent is a fundamental operation in Computer Science. In the reverse direction, the task of reverse engineering (analysing a given program in order to determine its specification) can be greatly ameliorated if the program can be re-expressed in a suitable recursive form. But the existing recursion removal transformations, such as the techniques discussed by Knuth [1] and Bird [2], can only be applied in the reverse direction if the source program happens to match the structure produced by a particular recursion removal operation. In this paper we describe a much more powerful recursion removal and introduction operation which describes its source and target in the form of an action system (a collection of labels and calls to labels). A simple, mechanical, restructuring operation can be applied to a great many iterative programs which will put them in a suitable form for recursion introduction. Our transformation generates strictly more iterative versions than the standard methods, including those of Knuth and Bird [1,2]. With the aid of this theorem we prove a (somewhat counterintuitive) result for programs that contain sequences of two or more recursive calls: under a reasonable commutativity condition, "depth-first" execution is more general than "breadth-first" execution. In "depth-first" execution, the execution of each recursive call is completed, including all sub-calls, before execution of the next call is started. In "breadth-first" execution, each recursive call in the sequence is partially executed but any sub-calls are temporarily postponed. This result means that any breadth-first program can be reimplemented as a corresponding depth-first program, but the converse does not hold. We also treat the case of "random-first" execution, where the execution order is implementation dependent. For the more restricted domain of tree searching we show that breadth first search is the most general form. We also give two examples of recursion introduction as an aid to formal reverse engineering.

show abstract

“…FermaT is a program transformation system based on the theory of program refinement and equivalence developed in [35,37] and applied to software development in [28,39] and to reverse engineering in [38,40]. The transformation system is intended as a practical tool for software maintenance, program comprehension, reverse engineering and program development.…”

Section: Fermat: a Case Studymentioning

confidence: 99%

Language-Oriented Programming

Ward¹

Foundations of F#

View full text Add to dashboard Cite

This paper describes the concept of language oriented programming which is a novel way of organising the development of a large software system, leading to a different structure for the finished product. The approach starts by developing a formally specified, domain-oriented, very high-level language which is designed to be well-suited to developing "this kind of program". The development process then splits into two independent stages: (1) Implement the system using this "middle level" language, and (2) Implement a compiler or translator or interpreter for the language, using existing technology. The approach is claimed to have advantages for domain analysis, rapid prototyping, maintenance, portability, user-enhanceable systems, reuse of development work, while also providing high development productivity. We give an example where the method has been used very successfully (in conjunction with rapid prototyping) in the development of a large software system: the FermaT reverse engineering tool. A major benefit of this approach to software development, as compared to the usual sequential "waterfall model" is the speed with which products can be brought to market. This is due to "concurrent engineering": the effective overlap of development stages. Finally, the "middle out" development style is compared and contrasted with the more usual "top down", "bottom up" and "outside in" development methods.

show abstract

A Multipurpose Backtracking Algorithm

Cited by 27 publications

References 18 publications

Provably correct derivation of algorithms using FermaT

Provably correct derivation of algorithms using FermaT

Recursion Removal/Introduction by Formal Transformation: An Aid to Program Development and Program Comprehension

Language-Oriented Programming

Contact Info

Product

Resources

About