46,532 research outputs found
On Program Synthesis in Intelligent Calculators Through Current Autoprogramming Techniques
Recent technology has placed powerful computing devices within the grasp of the average layman. The calculator is the most widely utilized such device end its power now compares to that of the first computers. While the users of these calculators are familiar with strict sequential operations, few are familiar with programming techniques. Much work has been done on program and machine inference from example input and output traces. An evaluation and assimilation of current machine synthesis studies and auto programming techniques has been described. An intelligent calculator capable of automatically constructing or inferring suitable programs from example computations executed by the user, keeping the additional required knowledge of the user at a minimum, has been proposed
Algorithmic Debugging of Real-World Haskell Programs: Deriving Dependencies from the Cost Centre Stack
Existing algorithmic debuggers for Haskell require a transformation of all modules in a program, even libraries that the user does not want to debug and which may use language features not supported by the debugger. This is a pity, because a promising ap- proach to debugging is therefore not applicable to many real-world programs. We use the cost centre stack from the Glasgow Haskell Compiler profiling environment together with runtime value observations as provided by the Haskell Object Observation Debugger (HOOD) to collect enough information for algorithmic debugging. Program annotations are in suspected modules only. With this technique algorithmic debugging is applicable to a much larger set of Haskell programs. This demonstrates that for functional languages in general a simple stack trace extension is useful to support tasks such as profiling and debugging
Recommended from our members
The use of sequencing information in software specification for verification
Software requirements specifications, virtual machine definitions, and algorithmic design all place constraints on the sequence of operations that are permissible during a program's execution. This paper discusses how these constraints can be captured and used to aid in the program verification process. The sequencing constraints can be expressed as a grammar over the alphabet of program operations. Several techniques can be used in support of testing or verification based on these specifications. Dynamic aalysis and static analysis are considered here. The automatic generation of some of these aids is feasible; the means of doing so is described
Finite Computational Structures and Implementations
What is computable with limited resources? How can we verify the correctness
of computations? How to measure computational power with precision? Despite the
immense scientific and engineering progress in computing, we still have only
partial answers to these questions. In order to make these problems more
precise, we describe an abstract algebraic definition of classical computation,
generalizing traditional models to semigroups. The mathematical abstraction
also allows the investigation of different computing paradigms (e.g. cellular
automata, reversible computing) in the same framework. Here we summarize the
main questions and recent results of the research of finite computation.Comment: 12 pages, 3 figures, will be presented at CANDAR'16 and final version
published by IEEE Computer Societ
Transforming specifications of observable behaviour into programs
A methodology for deriving programs from specifications of observable
behaviour is described. The class of processes to which this methodology
is applicable includes those whose state changes are fully definable by labelled
transition systems, for example communicating processes without
internal state changes. A logic program representation of such labelled
transition systems is proposed, interpreters based on path searching techniques
are defined, and the use of partial evaluation techniques to derive
the executable programs is described
Inference of termination conditions for numerical loops in Prolog
We present a new approach to termination analysis of numerical computations
in logic programs. Traditional approaches fail to analyse them due to non
well-foundedness of the integers. We present a technique that allows overcoming
these difficulties. Our approach is based on transforming a program in a way
that allows integrating and extending techniques originally developed for
analysis of numerical computations in the framework of query-mapping pairs with
the well-known framework of acceptability. Such an integration not only
contributes to the understanding of termination behaviour of numerical
computations, but also allows us to perform a correct analysis of such
computations automatically, by extending previous work on a constraint-based
approach to termination. Finally, we discuss possible extensions of the
technique, including incorporating general term orderings.Comment: To appear in Theory and Practice of Logic Programming. To appear in
Theory and Practice of Logic Programmin
- …