An electrical contact surface is described which combines the flexibility of a low resistance elastic interface with bonded conductive particles for penetration during compressive mating to metallic oxide layers. The processes for applying both technologies is described including the types of interfacial bonds provided. Both technologies permit high conductivity across the layers. Such technologies offer advantages for connectors requiring low normal forces, superior oxidative resistance to the environment, elastic conductors with the same resistance as bare copper, and high volume processing capabilities.

The first layer of conductive coating includes grafting an elastomeric bridge from the primary surface to the outer layer of metal particles and flakes. The secondary outer coating involves deposition of sharp, hard, conductive particles onto the grafted surface. Each coating bonds to the other forming several layers outward from the primary elastomeric substrate.

Product applications include a conductive elastic interface for interconnecting a BGA to a PCB via a socketed solution. The elastomeric interface overcomes co‐planarity issues associated with mating the BGA chip to a PCB. Compressive forces are reduced as compared to metal connectors providing lower total force for high I/O counts. Environmental constraints are reduced due to the durability of the elastomeric system.

Many types of interactive applications, including reactive systems implemented in hardware, interactive physics simulations and games, raise particular challenges when it comes to testing and debugging. Reasons include de facto lack of reproducibility and difficulties of automatically generating suitable test data. This paper demonstrates that certain variants of functional reactive programming (FRP) implemented in pure functional languages can mitigate such difficulties by offering referential transparency at the level of whole programs. This opens up for a multi-pronged approach for assisting with testing and debugging that works across platforms, including assertions based on temporal logic, recording and replaying of runs (also from deployed code), and automated random testing using QuickCheck. When combined with extensible forms of FRP that allow for constrained side effects, it allows us to not only validate software simulations but to analyse the effect of faults in reactive systems, confirm the efficacy of fault tolerance mechanisms and perform software- and hardware-in-the-loop testing. The approach has been validated on non-trivial systems implemented in several existing FRP implementations, by means of careful debugging using a tool that allows the test or simulation under scrutiny to be controlled, moving along the execution time line, and pin-pointing of violations of assertions on personal computers as well as external devices.

MultiMLton is an extension of the MLton compiler and runtime system that targets scalable, multicore architectures. It provides specific support for ACML, a derivative of Concurrent ML that allows for the construction of composable asynchronous events. To effectively manage asynchrony, we require the runtime to efficiently handle potentially large numbers of lightweight, short-lived threads, many of which are created specifically to deal with the implicit concurrency introduced by asynchronous events. Scalability demands also dictate that the runtime minimize global coordination. MultiMLton therefore implements a split-heap memory manager that allows mutators and collectors running on different cores to operate mostly independently. More significantly, MultiMLton exploits the premise that there is a surfeit of available concurrency in ACML programs to realize a new collector design that completely eliminates the need for read barriers, a source of significant overhead in other managed runtimes. These two symbiotic features - a thread design specifically tailored to support asynchronous communication, and a memory manager that exploits lightweight concurrency to greatly reduce barrier overheads - are MultiMLton's key novelties. In this article, we describe the rationale, design, and implementation of these features, and provide experimental results over a range of parallel benchmarks and different multicore architectures including an 864 core Azul Vega 3, and a 48 core non-coherent Intel SCC (Single-Cloud Computer), that justify our design decisions.

We define a weak λ-calculus, λσw, as a subsystem of the full λ-calculus with explicit substitutions λσ[uArr]. We claim that λσw could be the archetypal output language of functional compilers, just as the λ-calculus is their universal input language. Furthermore, λσ[uArr] could be the adequate theory to establish the correctness of functional compilers. Here we illustrate these claims by proving the correctness of four simplified compilers and runtime systems modelled as abstract machines. The four machines we prove are the Krivine machine, the SECD, the FAM and the CAM. Thus, we give the first formal proofs of Cardelli's FAM and of its compiler.

S. R. M. Mackenzie, Going Going, Gone: Regulating the Market in Illicit Antiquities. Pp. viii, 290. Institute of Art and Law, Leicester: 2005. ISBN: 1-903987-07-5.

“It's very rare to get something with a provenance, with an actual collection name. Usually it's entirely anonymous, especially in the London and New York trade. Just objects for sale in a shop …” (p. 32). To anyone with an interest in the antiquities market, this Melbourne dealer's view is unsurprising. More surprising, perhaps, is the dealer's willingness to even discuss the issue of provenance and the extent to which the antiquities market is awash with unprovenanced illicit antiquities. Essentially, Simon Mackenzie's work is about provenance. He sets out to answer the question, “How should we regulate the antiquities market so as most appropriately to address the issue of looted antiquities in that market?” (p. 1). The first step in answering this question is to understand how the market actually functions. And what better way than to ask market participants themselves. Mackenzie does so through interviews with dealers, collectors, auction house representatives, and museum curators; and the work is substantially based around an analysis of these interviews. The extensive use of quotes allows readers a glimpse into the secretive and exclusive world of the antiquities market and lays bare the prevailing attitude of the interviewees, providing a rich (and dare I say, even entertaining) dialogue throughout the work.

The imprimitive unitary reflection group G(m, p, n) acts on the vector space V =Cn naturally. The symmetric group Sk acts on ⊗kV by permuting the tensor product factors. We show that the algebra of all matrices on ⊗kV commuting with G(m, p, n) is generated by Sk and three other elements. This is a generalization of Jones’s results for the symmetric group case [J].

Over time, several competing approaches to parallel Haskell programming have emerged. Different approaches support parallelism at various different scales, ranging from small multicores to massively parallel high-performance computing systems. They also provide varying degrees of control, ranging from completely implicit approaches to ones providing full programmer control. Most current designs assume a shared memory model at the programmer, implementation and hardware levels. This is, however, becoming increasingly divorced from the reality at the hardware level. It also imposes significant unwanted runtime overheads in the form of garbage collection synchronisation etc. What is needed is an easy way to abstract over the implementation and hardware levels, while presenting a simple parallelism model to the programmer. The PArallEl shAred Nothing runtime system design aims to provide a portable and high-level shared-nothing implementation platform for parallel Haskell dialects. It abstracts over major issues such as work distribution and data serialisation, consolidating existing, successful designs into a single framework. It also provides an optional virtual shared-memory programming abstraction for (possibly) shared-nothing parallel machines, such as modern multicore/manycore architectures or cluster/cloud computing systems. It builds on, unifies and extends, existing well-developed support for shared-memory parallelism that is provided by the widely used GHC Haskell compiler. This paper summarises the state-of-the-art in shared-nothing parallel Haskell implementations, introduces the PArallEl shAred Nothing abstractions, shows how they can be used to implement three distinct parallel Haskell dialects, and demonstrates that good scalability can be obtained on recent parallel machines.