The predominant thread-based approach to concurrent programming is bug-prone, difficult to reason about, and does not scale well to large numbers of processors. Sieves provide a simple way of adding deterministic decl...
详细信息
ISBN:
(纸本)1595936904
The predominant thread-based approach to concurrent programming is bug-prone, difficult to reason about, and does not scale well to large numbers of processors. Sieves provide a simple way of adding deterministic declarative concurrency to imperative programming languages. Sieve programs have a straightforward semantics, are not significantly more difficult to reason about than sequential imperative programs, and should scale to large numbers of processors as well as different processor architectures. Copyright 2007 ACM.
We introduce a method for proving the correctness of transformations of programs in languages like Scheme and ML. The method consists of giving the programs a denotational semantics in an operationally-based term mode...
详细信息
ISBN:
(纸本)9780897918534
We introduce a method for proving the correctness of transformations of programs in languages like Scheme and ML. The method consists of giving the programs a denotational semantics in an operationally-based term model in which interaction is the basic observable, and showing that the transformation is meaning-preserving. This allows us to consider correctness for programs that interact with their environment without terminating, and also for transformations that change the internal store behavior of the program. We illustrate the technique on one of the Meyer-Sieber examples, and we use it to prove the correctness of assignment elimination for Scheme. The latter is an important but subtle step for Scheme compilers;we believe ours is the first proof of its correctness.
Finite-state programs over real-numbered time in a guarded-command language with real-valued clocks are described. Model checking answers the question of which states of a real-time program satisfy a branching-time sp...
详细信息
ISBN:
(纸本)0818627352
Finite-state programs over real-numbered time in a guarded-command language with real-valued clocks are described. Model checking answers the question of which states of a real-time program satisfy a branching-time specification. An algorithm that computes this set of states symbolically as a fixpoint of a functional on state predicates, without constructing the state space, is given.
This research presents an evaluation of user defined domain specific functions of genetic programming using relational learning problems, generalization for this class of learning problems and learning bias. After pro...
详细信息
This research presents an evaluation of user defined domain specific functions of genetic programming using relational learning problems, generalization for this class of learning problems and learning bias. After providing a brief theoretical background, two sets of experiments are detailed: experiments and results concerning the Monk-2 problem and experiments attempting to evolve generalizing solutions to parity problems with incomplete data sets. The results suggest that using non-problem specific functions may result in greater generalization for relational problems.
A common trend in programming language specification is to generate various tools (e.g., compiler, editor, profiler, and debugger) from a grammar. In such a generative approach, it is desirable to have the definition ...
详细信息
ISBN:
(纸本)9781581139648
A common trend in programming language specification is to generate various tools (e.g., compiler, editor, profiler, and debugger) from a grammar. In such a generative approach, it is desirable to have the definition of a programming language be modularized according to specific concerns specified in the grammar. However, it is often the case that the corresponding properties of the generated tools are scattered and tangled across the language specification. In this paper, separation of concerns within a programming language specification is demonstrated by considering debugging support within a domain-specific language (DSL). The paper first describes the use of AspectJ to weave the debugging semantics into the code created by a parser generator. The paper outlines several situations when the use of AspectJ is infeasible at separating language specification properties. To accommodate such situations, a second approach is presented that weaves the debugging support directly into a grammar specification using a program transformation engine. A case study for a simple DSL is presented to highlight the benefits of weaving across language specifications defined by grammars. Copyright 2005 ACM.
A program checker verifies that a particular program execution is correct. We give simple and efficient program checkers for some basic geometric tasks. We report about our experiences with program checking in the con...
详细信息
ISBN:
(纸本)9780897918046
A program checker verifies that a particular program execution is correct. We give simple and efficient program checkers for some basic geometric tasks. We report about our experiences with program checking in the context of the LEDA system. We discuss program checking for data structures that have to rely on user-provided functions.
This paper describes a GUI testing toolset. This toolset was designed to augment the primary testing activities found in a normal GUI testing cycle. It includes an automatic test case and test automation generator, st...
详细信息
ISBN:
(纸本)9781424437702
This paper describes a GUI testing toolset. This toolset was designed to augment the primary testing activities found in a normal GUI testing cycle. It includes an automatic test case and test automation generator, static binary analysis, a GUI change tracking tool and a comprehensive reporting mechanism. An empirical study on a complex system demonstrates that the toolset could greatly reduce the effort spent on developing test automation and tracking GUI changes during a software products development cycle.
A new formal embodiment of J.-Y. Girard's (1989) geometry of interaction program is given. The geometry of interaction interpretation considered is defined, and the computational interpretation is sketched in term...
详细信息
ISBN:
(纸本)0818627352
A new formal embodiment of J.-Y. Girard's (1989) geometry of interaction program is given. The geometry of interaction interpretation considered is defined, and the computational interpretation is sketched in terms of dataflow nets. Some examples that illustrate the key ideas underlying the interpretation are given. The results, which include the semantic analogue of cut-elimination, stated in terms of a finite convergence property, are outlined.
We build a confluent, local, asynchronous reduction on λ-terms, using infinite objects (partial injections of Girard's algebra L*), which is simple (only one move), intelligible (semantic setting of the reduction...
详细信息
ISBN:
(纸本)0818631406
We build a confluent, local, asynchronous reduction on λ-terms, using infinite objects (partial injections of Girard's algebra L*), which is simple (only one move), intelligible (semantic setting of the reduction), general (based on a large-scale decomposition of β), and may be mechanized.
In single-assignment languages, modifications to data can be achieved only by explicit copying. Copy-avoidance schemes seek to avoid overhead associated with this copying and associated storage reclamation. Previous p...
详细信息
ISBN:
(纸本)0262691477
In single-assignment languages, modifications to data can be achieved only by explicit copying. Copy-avoidance schemes seek to avoid overhead associated with this copying and associated storage reclamation. Previous proposals worked only on aggregate data or required expensive reference counts and free lists. We present a scheme called local reuse that avoids the need for expensive run-time operations. We outline a static analysis technique that provides at compile time the information required by the scheme in the context of concurrent logic languages, a subset of single-assignment languages. We also describe architectural support for the scheme in terms of extensions to an abstract machine for concurrent logic programming. We report experiments using an instrumented abstract machine emulator that permit quantification of the amount of memory reused in typical programs and the cost of this reuse. These studies show that a significant proportion of memory can be reused with negligible overhead.
暂无评论