7 research outputs found

    USTOPIA REQUIREMENTS THOUGHTS ON A USER-FRIENDLY SYSTEM FOR TRANSFORMATION OF PROGRAMS IN ABSTRACTO

    Get PDF
    Transformational programming is a program development method which is usually applied using 'pen and paper'. Since this requires a lot of clerical work (copying expressions, con- sistent substitution) which is tiresome and prone to error, some form of machine support is desirable. In this paper a number of systems are described that have already been built to this aim. Some of their shortcomings and limitations are identified. Based on experience with program transformation and transformation systems, a long list of features is given that would be useful in an 'utopian' transformation system. This list is presented using an orthogonal division of the problem area. A number of problems with the realisation of some aspects of our 'utopian' system are identified, and some areas for further research are indicated

    Using rewriting techniques to produce code generators and proving them correct

    Get PDF
    AbstractA major problem in deriving a compiler from a formal definition is the production of correct and efficient object code. In this context, we propose a solution to the problem of code-generator generation.Our approach is based on a target machine description where the basic concepts used (storage classes, access modes, access classes and instructions) are hierarchically described by tree patterns. These tree patterns are terms of an abstract data type. The program intermediate representation (input to the code generator) is a term of the same abstract data type.The code generation process is based on access modes and instruction template-driven rewritings. The result is that each program instruction is reduced to a sequence of elementary machine instructions, each of them representing an instance of an instruction template.The axioms of the abstract data type are used to prove that the rewritings preserve the semantics of the intermediate representation

    Verification in ASL and related specification languages

    Get PDF

    A precise semantics for ultraloose specifications

    Get PDF
    All formal specifiers face the danger of overspecification: accidentally writing an overly restrictive specification. This problem is particularly acute for axiomatic specifications because it is so easy to write axioms which hold for some of the intended implementations but not for all of them (or, rather, it is so hard not to write overly strong axioms). One of the best developed ways of recovering some of those implementations which do not literally satisfy the specification is to apply a "behavioural abstraction operator" to a specification: adding in those implementations which have the same "behaviour" as an implementation which does satisfy the specification. In two recent papers Wirsing and Broy propose an alternative (and apparently simpler) approach which they call "ultraloose specification." This approach is based on a particular style of writing axioms which avoids certain forms of overspecification. An important, unanswered question is "How does the ultraloose approach re-late to the other solutions?" The major achievement of this thesis is a proof that the ultraloose approach is semantically equivalent to the use of the "behavioural abstraction operator." This result is rather surprising in the light of a result by Schoett which seems to say that such a result is impossible
    corecore