We present GJ, a design that extends the Java programming language with generic types and methods. These are both explained implemented by translation into unextended language. The closely mimics way generics emulated programmers: it erases all type parameters, maps variables to their bounds, inserts casts where needed. Some subtleties of caused handling overriding.GJ increases expressiveness safety: code utilizing libraries is no longer buried under plethora casts, corresponding inserted...

Software engineering demands generality and abstraction, performance specialization concretization. Generative programming can provide both, but the effort required to develop high-quality program generators likely offsets their benefits, even if a multi-stage language is used.We present lightweight modular staging, library-based approach that breaks with tradition of syntactic quasi-quotation instead uses only types distinguish between binding times. Through extensive use component...

We identify three programming language abstractions for the construction of reusable components: abstract type members, explicit selftypes, and modular mixin composition.Together, these enable us to transform an arbitrary assembly static program parts with hard references between them into a system components.The transformation maintains structure original system.We demonstrate this approach in two case studies, subject/observer framework compiler front-end.

The mismatch between the operational semantics of lambda calculus and actual behavior implementations is a major obstacle for compiler writers. They cannot explain their evaluator in terms source level syntax, they easily compare distinct different lazy strategies. In this paper we derive an equational characterization call-by-need prove it correct with respect to original calculus. theory strictly smaller than Immediate applications concern correctness proofs number implementation...

We present a general framework HM(X) for type systems with constraints. The stays in the tradition of Hindley/Milner system. Its system instances are sound under standard untyped compositional semantics. can give generic inference algorithm so that, sufficient conditions on X, will always compute principal term. discuss that deal polymorphic records, equational theories, and subtypes. © 1999 John Wiley & Sons, Inc.

Developing high-performance software is a difficult task that requires the use of low-level, architecture-specific programming models (e.g., OpenMP for CMPs, CUDA GPUs, MPI clusters). It typically not possible to write single application can run efficiently in different environments, leading multiple versions and increased complexity. Domain-Specific Languages (DSLs) are promising avenue enable programmers high-level abstractions still achieve good performance on variety hardware. This...

Good software engineering practice demands generalization and abstraction, whereas high performance specialization concretization. These goals are at odds, compilers can only rarely translate expressive high-level programs to modern hardware platforms in a way that makes best use of the available resources. Generative programming is promising alternative fully automatic translation. Instead writing down target program directly, developers write generator, which produces as its output. The...

We study an extension of the Hindley/Milner system with explicit type scheme annotations and declarations. The can express polymorphic function arguments, user-defined data types abstract components, structure fields. More generally, all programs lambda calculus be encoded by a translation between typing derivations. show that reconstruction in this reduced to decidable problem first-order unification under mixed prefix.

Type classes were originally developed in Haskell as a disciplined alternative to ad-hoc polymorphism. have been shown provide type-safe solution important challenges software engineering and programming languages such as, for example, retroactive extension of programs. They are also recognized good mechanism concept-based generic and, more recently, evolved into type-level computation.

We describe a non-blocking concurrent hash trie based on shared-memory single-word compare-and-swap instructions. The supports standard mutable lock-free operations such as insertion, removal, lookup and their conditional variants. To ensure space-efficiency, removal compress the when necessary.

As heterogeneous parallel systems become dominant, application developers are being forced to turn an incompatiblemix of low level programming models (e.g. OpenMP, MPI, CUDA, OpenCL). However, these do little shield from the difficult problems parallelization, data decomposition and machine-specific details. Most programmersare having a time using effectively. To provide modelthat addresses productivity performance requirements for average programmer, we explore domainspecificapproach programming.

High level data structures are a cornerstone of modern programming and at the same time stand in way compiler optimizations. In order to reason about user- or library-defined compilers need be extensible. Common mechanisms extend fall into two categories. Frontend macros, staging partial evaluation systems can used programmatically remove abstraction specialize programs before they enter compiler. Alternatively, some allow extending internal workings by adding new transformation passes...

We describe the implementation of first-class polymorphic delimited continuations in programming language Scala. use Scala's pluggable typing architecture to implement a simple type and effect system, which discriminates expressions with control effects from those without accurately tracks answer modification incurred by effects. To tackle problem implementing under adverse conditions brought upon Java VM, we employ selective CPS transform, is driven entirely effect-annotated types leaves...

Domain-specific languages offer a solution to the performance and productivity issues in heterogeneous computing systems. The Delite compiler framework simplifies process of building embedded parallel DSLs. DSL developers can implement domain-specific operations by extending framework, which provides static optimizations code generation for hardware. runtime automatically schedules executes on

We present a calculus that captures the operational semantics of call-by-need. The call-by-need lambda is confluent, has notion standard reduction, and entails same observational equivalence relation as call-by-name calculus. system can be formulated with or without explicit let bindings, admits useful notions marking developments, straightforward interpretation.