Showing papers by "Simon Jones published in 2004"

Scrap more boilerplate: reflection, zips, and generalised casts

Abstract: Writing boilerplate code is a royal pain. Generic programming promises to alleviate this pain by allowing the programmer to write a generic "recipe" for boilerplate code, and use that recipe in many places. In earlier work we introduced the "Scrap your boilerplate" approach to generic programming, which exploits Haskell's existing type-class mechanism to support generic transformations and queries.This paper completes the picture. We add a few extra "introspective" or "reflective" facilities, that together support a rich variety of serialisation and de-serialisation. We also show how to perform generic "zips", which at first appear to be somewhat tricky in our framework. Lastly, we generalise the ability to over-ride a generic function with a type-specific one.All of this can be supported in Haskell with independently-useful extensions: higher-rank types and type-safe cast. The GHC implementation of Haskell readily derives the required type classes for user-defined data types.

Wobbly types: type inference for generalised algebraic data types∗

Abstract: Generalised algebraic data types (GADTs), sometimes known as “guarded recursive data types” or “first-class phantom types”, are a simple but powerful generalisation of the data types of Haskell and ML. Recent works have given compelling examples of the utility of GADTs, although type inference is known to be difficult. It is time to pluck the fruit. Can GADTs be added to Haskell, without losing type inference, or requiring unacceptably heavy type annotations? Can this be done without completely rewriting the already-complex Haskell type-inference engine, and without complex interactions with (say) type classes? We answer these questions in the affirmative, giving a type system that explains just what type annotations are required, and a prototype implementation that implements it. Our main technical innovation is wobbly types, which express in a declarative way the uncertainty caused by the incremental nature of typical type-inference algorithms.

Making a fast curry: push/enter vs. eval/apply for higher-order languages

Abstract: Higher-order languages that encourage currying are implemented using one of two basic evaluation models: push/enter or eval/apply. Implementors use their intuition and qualitative judgements to choose one model or the other.Our goal in this paper is to provide, for the first time, a more substantial basis for this choice, based on our qualitative and quantitative experience of implementing both models in a state-of-the-art compiler for Haskell.Our conclusion is simple, and contradicts our initial intuition: compiled implementations should use eval/apply.

Extending the Haskell foreign function interface with concurrency

Abstract: A Haskell system that includes both the Foreign Function Interface and the Concurrent Haskell extension must consider how Concurrent Haskell threads map to external Operating System threads for the purposes of specifying in which thread a foreign call is made.Many concurrent languages take the easy route and specify a one-to-one correspondence between the language's own threads and external OS threads. However, OS threads tend to be expensive, so this choice can limit the performance and scalability of the concurrent language.The main contribution of this paper is a language design that provides a neat solution to this problem, allowing the implementor of the language enough flexibility to provide cheap lightweight threads, while still providing the programmer with control over the mapping between internal threads and external threads where necessary.

High performance code compression architecture for the embedded ARM/THUMB processor

Abstract: The use of code compression in embedded systems based on standard RISC instruction set architectures (ISA) has been shown in the past to be of benefit in reducing overall system cost. The 16-bit THUMB ISA from ARM Ltd has a significantly higher density than the original 32-bits ARM ISA. Our proposed memory compression architecture has showed a further size reduction of 15% to 20% on the THUMB code. In this paper we propose to use a high-speed data lossless hardware decompressor to improve the timing performance of the architecture. We simulated the architecture on the SimpleScalar platform and show that for some applications, the time overheads are limited within 5% of the original application.

Champagne Prototyping: A Research Technique for Early Evaluation of Complex End-User Programming Systems

Abstract: Although a variety of evaluation techniques are available to researchers of visual and end-user programming systems, they are primarily suited to evaluation of research systems. It is important to have evaluation techniques suitable for real-world programming environments, in order to satisfy real-world product managers of the usefulness of proposed new features. To help fill this gap, we present a new evaluation technique, based in part on cognitive dimensions and attention investment, called "Champagne prototyping". The technique is an early-evaluation technique that is inexpensive to do, yet features the credibility that comes from being based on the real commercial environment of interest, and from working with real users of the environment

The Effect of the β2-Adrenoceptor Agonist Prodrug BRL-47672 on Cardiovascular Function, Skeletal Muscle Myosin Heavy Chain, and MyoD Expression in the Rat

Abstract: The intracellular mechanisms that regulate changes in postnatal myosin heavy chain (MHC) expression are not well established. The major objective of this study was to examine the acute and chronic effects of administration of BRL-47672, the prodrug of the beta2-adrenoceptor agonist clenbuterol on MHC and MyoD transcription factor expression to determine whether or not changes in MHC composition are preceded by changes in MyoD protein expression. To assess to what extent the use of BRL-47672 minimized cardiovascular effects, its hemodynamic actions were compared with those of clenbuterol. The effect of BRL-47672 on heart rate, mean arterial blood pressure, and hindquarters vascular conductance was significantly less than that of clenbuterol after a single i.p. injection (250 microg kg(-1) body mass). In the main study, 4-week old rats were given BRL-47672 (900 microg kg(-1) body mass) or an equivalent volume of saline (control) daily for 1, 28, or 56 days. Soleus muscle (SOL) was excised and MHC and MyoD expression analyzed. After 4 weeks, SOL from the BRL-47672-treated animals had significantly faster MHC composition (49 +/- 2% MHCIIA) compared with those from the control animal (39 +/- 3% MHCIIA, P <0.05). MyoD expression increased by 40% after 1 day of BRL-47672 administration (P <0.05) before a change in MHC composition. In conclusion, these data suggest that increased expression of fast-type MHCIIA expression in rat SOL induced by BRL-47672 administration is preceded by changes in the level of MyoD transcription factor expression.

Constructed product result analysis for Haskell

Abstract: Compilers for ML and Haskell typically go to a good deal of trouble to arrange that multiple arguments can be passed efficiently to a procedure. For some reason, less effort seems to be invested in ensuring that multiple results can also be returned efficiently. In the context of the lazy functional language Haskell, we describe an analysis, Constructed Product Result (CPR) analysis, that determines when a function can profitably return multiple results in registers. The analysis is based only on a function's definition, and not on its uses (so separate compilation is easily supported) and the results of the analysis can be expressed by a transformation of the function definition alone. We discuss a variety of design issues that were addressed in our implementation, and give measurements of the effectiveness of our approach across a substantial benchmark set. Overall, the pricesperformance ratio is good: the benefits are modest in general (though occasionally dramatic), but the costs in both complexity and compile time, are low.

Ring opening reactions of N-alkyl oxazolidinones with organolithium reagents

Abstract: Addition of primary, secondary and aryl organolithium reagents to N-methyl and N-benzyl oxazolidin-2-ones give N-acyl amino alcohols in 30-93% yields. Application to the synthesis of an imidazoyl oxazoline is demonstrated.

How to make a fast curry: push/enter vs eval/apply

Abstract: Higher-order languages that encourage currying are typically implemented using one of two basic evaluation models: push/enter or eval/apply. Implementors use their intuition and qualitative judgements to choose one model or the other. Our goal in this paper is to provide, for the first time, a more substantial basis for this choice, based on our qualitative and quantitative experience of implementing both models in a state-of-the-art compiler for Haskell. Our conclusion is simple, and contradicts our initial intuition: compiled implementations should use eval/apply. Conference version (2004) Slides of talk

The Diels–Alder adduct of p-benzo­quinone and anthracene: 9,10-tetra­hydro-9,10[1′,2′]­benzeno­anthracene-1′,4′(2′H,3′H)-dione

Abstract: The structure of the title compound, C20H14O2, has a rigid bicyclic backbone, and the six-membered diketone ring is in a shallow boat conformation. Both carbonyl groups are orientated away from the underlying benzene rings. The structure is compared to other similar anthracene Diels–Alder adducts.

Information technology in organisations

Abstract: No organisation can survive in today's world without the support of information technology, and the demand for IT-qualified professionals in organisations of all kinds continues to remain strong. To be an effective professional in the information systems field requires a foundation of business and management knowledge, coupled with an understanding of both theory and principles in areas such as application development, databases and systems analysis and design. This book provides students with a working knowledge of a broad range of information technologies, as well as hands-on experience in applying these technical skills to problems in actual organisations.

Ring Opening Reactions of N‐Alkyl Oxazolidinones with Organolithium Reagents.

Abstract: Addition of primary, secondary and aryl organolithium reagents to N-methyl and N-benzyl oxazolidin-2-ones give N-acyl amino alcohols in 30-93% yields. Application to the synthesis of an imidazoyl oxazoline is demonstrated.

N‐Phosphoryl Oxazolidinones as Effective Phosphorylating Agents.

Abstract: A number of N-phosphoryl oxazolidinones have been prepared and evaluated, the best being 5,5-diphenyl oxazolidinones, the utility of which was demonstrated in the phosphorylation of a number of representative primary, secondary, tertiary, and phenolic alcohols.

The C—compiler infrastructure

Abstract: C-is a new kind of compiler infrastructure: one whose primary goal is to help you build a quality implementation of the language of your choice on the machine of your choice. Many compiler infrastructures support multiple machines, but only C-is designed from the beginning to support multiple front ends for multiple programming languages. The key insight driving C-is that to support such language features as garbage collection, exception dispatch, and concurrency, it is not enough for an infrastructure just to translate programs into target-machine code—the infrastructure must also support the runtime system. C-provides this support through a unique run-time interface, which reveals to the run-time system the important decisions made in the compiler’s back end. C-also provides a compile-time interface. For ease of use with multiple clients, this interface is not an API but a language with an ASCII syntax. Using an ASCII syntax makes the interface independent of the programming language used to implement the client, but making the C-compile-time interface a language also provides other benefits: it is much easier to debug a program than to debug a sequence of API calls, and we have better formal tools for specifying the proper use and semantics of a language than for specifying the use and semantics of an API. A client of our system emits code in the C-language, which our compiler then translates to native machine code. This native machine code runs together with the client’s run-time system, which makes calls into the C-run-time interface. Using C--, a client can divide work between compiler and run-time system much as it would if using a custom code generator. For example, a client that implements garbage collection might generate C-code to test for heap exhaustion, to advance an allocation pointer, and to initialize the fields of a newly allocated object. But that same client would probably put the garbage collector in its run-time system, where it would use the C-run-time interface to walk each activation on the stack and to get access to the values of local C-variables. The C-interfaces hide many details of the target machine, including the number and kinds of machine registers and the names and capabilities of machine instructions. The interfaces also hide many compiler algorithms, which can then be reused by multiple clients. These algorithms are well understood but difficult to implement; they include register allocation, instruction scheduling, peephole optimization, and many scalar and loop optimizations. Despite this hiding, the C-interfaces are resolutely low-level: