45717332
Fast Abstract Interpretation Using Sequential Algorithms
interpretation in the framework introduced by Cousot and Cousot requires finding fixpoints of continuous functions between abstract lattices [CC77]. Very often these abstract functions are expressed as typed ,~-expressions, even when the language being analysed isn't functional--for example an abstract interpretation derived from a denotational semantics in the style of Nielson [Nie82] will naturally be in this form. So implementing an abstract interpreter often requires an evaluator for ,k-expressions over lattices. Of course, evaluation must always terminate--even when the result is the bottom element of the lattice concerned. In practice this evaluation is intractable. The problem is caused by function types: lattices of functions grow more than exponentially in the size of their type. A-expressions of quite simple types therefore denote functions that are too enormous to manipulate efficiently. Attempts to find clever representations of functions (as frontiers) have really failed to solve the problem [HH92], and in practice the intractability is avoided by avoiding functions--function types may be abstracted as the one point type, discarding all information about function values, or analyses may be constructed from a more intensional semantics in which 'function' values are closures (code-environment pairs), so that true functions do not appear. Such approaches are forced to make more or less ad hoc approximations, at a cost in accuracy, and moreover cannot yield faithful implementations of the many analyses in the literature in which functions are abstracted as functions. In this paper we describe an approach which we hope will make evaluation of )~-expressions over finite lattices tractable in practice. Our basic idea is to save time by computing only part of the value of each ,kexpression. For example, to compute the value of the application el e2 it's not necessary to compute the value of el precisely. We only need to know what value el returns when applied to e2 --one point in the graph of the function, rather than the whole graph. Moreover, if el is a constant function, we may not need to compute the value of e2 at all. Or if e2 is itself a function, el may only apply it to a couple of different arguments, and so we may only need to know its value at a few points rather than its entire graph. Our intention is to lazily compute only as much as is needed of each expression, in the hope that in normal cases this will be only a tiny proportion of the whole. This idea is also at the heart of Young's pending analysis [YH86] and Launchbury's use of minimal function graphs [Lau91] to represent just the part of the graph that is needed, but these approaches are really confined to first-order functions. Our contribution is to extend the same idea smoothly to the higher-order case.
218895568
How to give a good research talk
Giving a good research talk is not easy. We try to identify some things which we have found helpful, in the hope that they may be useful to you.
14958709
Making choices lazily
We present a natural semantics that models the untyped, normal order A-calculus plus McCarthy’s amb in the context of call-by-need parameter passing. This results in a singular semantics for amb. Previous work on singular choice has concentrated on erratic choice, a less interesting nondeterministic choice operator, and only in relation to callby-value parameter passing, or call-by-name restricted to deterministic terms. The natural semantics contains rules for both convergent and divergent behaviour, allowing it to distinguish programs that differ only in their divergent behaviour. As a result, it is more discriminating than current domain-theoretic models. This, and the fact that it models singular amb, makes the natural semantics suitable for reasoning about lazy, functional languages containing McCarthy’s amb.
27745403
Type Specialisation for the lambda-Calculus; or, A New Paradigm for Partial Evaluation Based on Type Inference
14804186
Proving the correctness of reactive systems using sized types
We have designed and implemented a type-based analysis for proving some basic properties of reactive systems. The analysis manipulates rich type expressions that contain information about the sizes of recursively defined data structures. Sized types are useful for detecting deadlocks, nontermination, and other errors in embedded programs. To establish the soundness of the analysis we have developed an appropriate semantic model of sized types.
8161135
Binding-Time Analysis for Polymorphic Types
Offline partial evaluators specialise programs with annotations which distinguish specialisation-time (or static) computations from run-time ones. These annotations are generated by a binding-time analyser, via type inference in a suitable type-system. Henglein and Mossin developed a type system which allows polymorphism in binding-times, so that the same code can be specialised with different computations being static at different uses. We extend their work to permit polymorphism in types as well. This is particularly important for separately compiled libraries.Following Henglein and Mossin, binding-times are passed as parameters during specialisation, but types are not. Instead, we pass coercion functions when necessary, which makes specialisation less "interpretive" than it would otherwise be. We keep track of the coercions needed by assigning qualified types to polymorphic functions.We also consider hand-annotations to provide limited user control over the binding-time analysis, which our prototype implementation showed to be necessary.
12392598
Reflections on the use of grounded theory in interpretive information systems research
In Information Systems research there are a growing number of studies that must necessarily draw upon the contexts, experiences and narratives of practitioners. This calls for research approaches that are qualitative and may also be interpretive. These may include case studies or action research projects. For some researchers, particularly those with limited experience of interpretive qualitative research, there may be a lack of confidence when faced with the prospect of collecting and analysing the data from studies of this kind. In this paper we reflect on the lessons learned from using Grounded Theory in an interpretive case study based piece of research. The paper discusses the lessons and provides guidance for the use of the method in interpretive studies.
7280310
Skin: a constructive approach to modeling free-form shapes
We present a new particle-based surface representation with which a user can interactively sculpt free-form surfaces. The particles maintain mesh connectivity and operate under rules that lead them to form triangulations with properties that make them suitable for use in subdivision. A user interactively guides the particles, which we call skin, to grow over a given collection of polyhedral elements (or skeletons), yielding a smooth surface (through subdivision) that approximates the underlying skeletal shapes. Skin resembles blobby modeling in the constructive approach to modeling it supports, but allows a richer vocabulary of skeleton shapes, supports sharp creases where desired, and provides a convenient mechanism for adding multiresolution surface detail. CR
15620342
Autocalibration for virtual environments tracking hardware
We describe two instances in which precise mechanical calibration of virtual environments equipment has been replaced by automated algorithmic calibration through software that encapsulates the hardware design and uses a goal-based approach to adjust calibration parameters. We describe a back-projection system for adjusting the assumed locations of beacons in a head-mounted display tracking system; the calculated errors in the navigation system are used to compute adjustments to the beacon positions to reduce such errors. In a second application, a piggyback headtracking/hand-tracking system is calibrated by a similar reduction of computed errors.
13514949
Programming Languages for Compressing Graphics
Images are programs. They are usually simple instructions to a very specialized interpreter that renders them on screen. Image formats therefore correspond to different programming languages, each with distinctive properties of program size and accuracy. Image-processing languages render large images from small pieces of code. We present Evolver, a language and toolkit that perform the reverse transformation.The toolkit accepts images in conventional graphics formats like JPEG and uses genetic algorithms to grow a program in the Evolver language that generates a similar image. Because the program it produces is often significantly smaller than the input image, Evolver can be used as a compression tool.The language balances the tradeoff between having many features, which improves compression, and fewer features, which improves searching. In addition, by being programmatic descriptions, the rendered images scale much better to multiple resolutions than fixed-size images. We have implemented this system and present examples of its use.
27941486
Distributed probabilistic diagnosis of MCMs on large area substrates
This paper addresses the issue of testing MCMs on large-area substrates. The cost of testing each MCM may be as high as 40% of the total manufacturing cost. It is critical that the test process be parallelized in order that multiple MCMs may be tested for the cost of testing one MCM. With this objective in mind, we propose a distributed probabilistic diagnosis algorithm for MCMs on large-area substrates. Our algorithm performs better than the existing diagnosis algorithms and can correctly identify almost all MCMs even when the yield is very low (35%). Further it provides upto an order of magnitude reduction in test application time as opposed to serial MCM probe test.