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...

Computing systems are becoming increasingly parallel and heterogeneous, therefore new applications must be capable of exploiting parallelism in order to continue achieving high performance. However, targeting these emerging devices often requires using multiple disparate programming models making decisions that can limit forward scalability. In previous work we proposed the use domain-specific languages (DSLs) provide high-level abstractions enable transformations performance code without...

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...

In this paper we advocate that it is time for a radical rethinking of database systems design. Developers should be able to leverage high-level programming languages without having pay price in efficiency. To realize our vision abstraction regret , present LegoBase, query engine written the language Scala. The key technique regain efficiency apply generative programming: Scala code constitutes engine, despite its appearance, actually program generator emits specialized, low-level C code. We...

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

Field Programmable Gate Arrays (FPGAs) are very versatile devices, but their complicated programming model has stymied widespread usage. While modern High-Level Synthesis (HLS) tools provide better models, the interface they offer is still too low-level. In order to produce good quality hardware designs with these tools, users forced manually perform optimizations that demand detailed knowledge of both application and implementation platform. Additionally, many HLS only generate isolated...

Scala's type system unifies aspects of ML modules, object- oriented, and functional programming. The Dependent Object Types (DOT) family calculi has been proposed as a new theoretic foundation for Scala similar expressive languages. Unfortunately, soundness only established restricted subsets DOT. In fact, it shown that important features such refinement or subtyping relation with lattice structure break at least one key metatheoretic property environment narrowing invertible transitivity,...

A scalable programming language is one in which the same concepts can describe small as well large parts. Towards this goal, Scala unifies from object and module systems. An essential ingredient of unification concept objects with type members, be referenced through path-dependent types. Unfortunately, types are not well-understood, have been a roadblock grounding system on firm theory.

To leverage modern hardware platforms to their fullest, more and database systems embrace compilation of query plans native code. In the research community, there is an ongoing debate about best way architect such compilers. This perceived be a difficult task, requiring techniques fundamentally different from traditional interpreted execution.

Deep learning has seen tremendous success over the past decade in computer vision, machine translation, and gameplay. This rests crucially on gradient-descent optimization ability to “learn” parameters of a neural network by backpropagating observed errors. However, architectures are growing increasingly sophisticated diverse, which motivates an emerging quest for even more general forms differentiable programming, where arbitrary parameterized computations can be trained gradient descent....

While type soundness proofs are taught in every graduate PL class, the gap between realistic languages and what is accessible to formal large. In case of Scala, it has been shown that its model, Dependent Object Types (DOT) calculus, cannot simultaneously support key metatheoretic properties such as environment narrowing subtyping transitivity, which usually required for a proof. Moreover, Scala many other lack general substitution property.

Program generators for high performance libraries are an appealing solution to the recurring problem of porting and optimizing code with every new processor generation, but only few such exist date. This is due not difficulty design, also actual implementation, which often results in ad-hoc collection standalone programs scripts that hard extend, maintain, or reuse. In this paper we ask whether programming language concepts features needed enable a more systematic construction generators....

Recent work has explored using higher level languages to improve programmer productivity on GPUs. These often utilize high computation patterns (e.g., Map and Reduce) that encode parallel semantics enable automatic compilation GPU kernels. However, the problem of efficiently mapping hardware becomes significantly more difficult when are nested, which is common in non-trivial applications. To address this issue, we present a general analysis framework for automatically nested onto The maps...

High performance in modern computing platforms requires programs to be parallel, distributed, and run on heterogeneous hardware. However programming such architectures is extremely difficult due the need implement application using multiple models combine them together ad-hoc ways. To optimize distributed applications both for hardware programmers we a model that sufficiently expressive support variety of parallel applications, performant surpass hand-optimized sequential implementations,...

Scala unifies traditionally disparate programming-language philosophies to develop new components and component systems.

Domain-specific languages raise the level of abstraction in software development. While it is evident that programmers can more easily reason about very high-level programs, same holds for compilers only if compiler has an accurate model application domain and underlying target platform. Since mapping high-level, general-purpose to modern, heterogeneous hardware becoming increasingly difficult, DSLs are attractive way capitalize on improved performance, precisely by making a higher level....