Implementation and Application of Functional Languages

@inproceedings{Andy2011ImplementationAA,
  title={Implementation and Application of Functional Languages},
  author={Andy and Gill and Juniaan and Hage},
  booktitle={Lecture Notes in Computer Science},
  year={2011}
}
  • AndyGill Hage
  • Published in
    Lecture Notes in Computer…
     2011
  • Computer Science
Within the context of the FITTEST project, one of our tasks was to instrument ActionScript bytecode, so that aspects of the execution of the running application are logged. Although the decision what to log and when requires manual intervention, the code itself can be weaved into the system automatically by means of aspect-oriented programming (AOP). In this paper we describe Asil, an AOP EDSL for instrumenting ActionScript bytecode, that is firmly based on well-known functional programming… 
View on Springer
link.springer.com
59 Citations
Highly Influential Citations
3
Background Citations
9
Methods Citations
7

59 Citations

Scaling contracts to realistic languages

This dissertation presents the design and implementation of contract systems that cover the invariants of mutable data structures and protecting first-class components, which are used in the construction of large-scale software projects.

Ensuring Correct-by-Construction Resource Usage by using Full-Spectrum Dependent Types

This paper shows that correct-by-construction software development can also handle the equally important class of extra-functional properties, namely the correct usage of resources, using a novel embedded domain-specific language approach that exploits the capabilities of full-spectrum dependent types.

A Scheme Foreign Function Interface to JavaScript Based on an Infix Extension

The paper goes over the design and implementation of the JavaScript Foreign Function Interface for a Scheme implementation hosted on JavaScript and supporting threads, and takes advantage of JavaScript’s dynamic nature and its support for asynchronous functions.

A compiler architecture for domain-specific type error diagnosis

This paper engineer domain-specific error diagnosis in such a way that the compiler can also reuse the techniques for improving general error diagnosis.

Improving Refactoring Speed by 10X

R3 builds a main-memory, non-persistent database to encode Java entity declarations, their containment relationships, and language features such as inheritance and modifiers, and improves the success rate of retrofitting design patterns by 25% up to 50%.

Type-Directed Elaboration of Quasiquotations: A High-Level Syntax for Low-Level Reflection

A variation of quasiquotation that uses the language's compiler to translate high-level programs with holes into their corresponding reflected representation, both in pattern-matching and expression contexts is described.

Functional Programming with C++ Template Metaprograms

A pure functional style programming interface for C++ template metaprograms in the form of embedded Haskell code which is transformed to standard compliant C++ source is suggested.

Modeling Algorithms in SystemC and ACL2

The formal language MASC is described, based on a subset of SystemC and intended for modeling algorithms to be implemented in hardware, by means of a special-purpose parser, which generates a SystemC variant that is suitable as input to a high-level synthesis tool.

Property-Based Testing: Climbing the Stairway to Verification

It is demonstrated how PBT can be used in conjunction with formal verification to incrementally gain greater assurance in code correctness by integrating PBT into the verification framework of Cogent---a programming language equipped with a certifying compiler for developing high-assurance systems components.

Auto in Agda - Programming Proof Search Using Reflection

This paper shows how to implement a Prolog-style resolution procedure in the dependently typed programming language Agda that provides a first-class proof search tactic for first-order Agda terms.
...

References

SHOWING 1-10 OF 32 REFERENCES

A debugging environment for lazy functional languages

A new approach for debugging lazy functional languages is described, based on the fact that a functional program is the transformation of an expression, by investigating the syntactic form of the expression and by stopping the reduction process at given points.

A lightweight interactive debugger for haskell

The debugger is based on the traditional stop-examine-continue model of online debugging, which is simple and intuitive, but has traditionally been shunned in the context of Haskell because it exposes the lazy evaluation order.

Tracing Lazy Functional Computations Using Redex Trails

The basis of the tracing method is a program transformation carried out by the compiler: transformed programs compute the same values as the original, but embedded in functional data structures that also include redex trails showing how the values were obtained.

The nofib Benchmark Suite of Haskell Programs

The need for, make-up of, and “rules of the game” for a benchmark suite of Haskell programs are described, which will encourage sound, quantitative assessment of lazy functional programming systems.

Algorithmic debugging for lazy functional languages

An algorithmic debugger for a lazy functional language based on strictification and some experience in using it is presented and some techniques for overcoming these problems, at least partially, are suggested.

Compiler test case generation methods: a survey and assessment

Declarative Debugging of Lazy Functional Programs

A declarative debugger for logic programs which relies on three primitives that determine if an atom is valid in the intended interpretation, return the successful clause instance used by a call and return single atoms from a conjunction of atoms to locate errors in strict and non-strict functional programs is presented.

foetus - Termination Checker for Simple Functional Programs

A simple functional language foetus (lambda calculus with tuples, constructors and pattern matching) supplied with a termination checker that tries to find a well-founded structural order on the parameters on the given function to prove termination.

Lazy debugging of lazy functional programs

  • R. Snyder
  • Computer Science
    New Generation Computing
  • 2009
A method to compile functional programs to combinator code such that a source-like representation of any part of a computation graph can be efficiently reconstructed at run-time shows promise as a programmer tool to debug programs and to informally reason about the time and space behavior of fully lazy functional programs.

Testing an Optimising Compiler by Generating Random Lambda Terms

  • P. H
  • Computer Science
  • 2012
This thesis proposes using two variants of differential testing, which allows for detecting bugs even when a very limited partial specification of the tested compiler is available, and is evaluated practically by performing effective testing of a real compiler.