Compiling scala for the Java virtual machine

@inproceedings{Schinz2005CompilingSF,
  title={Compiling scala for the Java virtual machine},
  author={Michel Schinz},
  year={2005}
}
Scala is a new programming language developed at EPFL and incorporating the most important concepts of object-oriented and functional languages. It aims at integrating well with the Java and .NET platforms: their respective libraries are accessible without glue code, and the compiler can produce programs for both virtual machines. This thesis focuses on the compilation of two important concepts of Scala : mixin inheritance and run time types. The compilation techniques are presented in the… 
Programming language abstractions for mobile code
TLDR
It is claimed that the notion of lambda abstraction provides an elegant way for dealing with the dynamic rebinding of local references in a distributed execution environment.
Compiling Scala for Performance
TLDR
A formalism of a small subset of Scala with specialization is presented and it is proved that specialization preserves types, showing that specialization can make programs more than two times faster.
A typed intermediate language and algorithms for compiling scala by successive rewritings
TLDR
A typed intermediate language that generalizes some aspects of Scala and thus enables the rewriting of all programs is described, and the two rewriting phases are formally described using this intermediate language.
State Exploration of Scala Actor Programs
TLDR
This dissertation developed a general framework, called SEJAP, for exploring possible message schedules in actor systems compiled to the Java bytecode, and implemented the framework, Scala instantiation, and optimizations in Java PathFinder, a widely used model checker for Javabytecode developed by NASA.
Design and analysis of a scala benchmark suite for the Java virtual machine
TLDR
Analysis of a Scala benchmark suite shows that Scala programs exhibit not only a distinctive instruction mix but also object demographics close to those of the Scala language’s functional ancestors, which can have a marked effect on the performance of Scala programs on modern high-performance JVMs.
Implementing modular class-based reuse mechanisms on top of a single inheritance VM
TLDR
A modular meta-level runtime architecture to implement and combine different code reuse mechanisms, which supports dynamic combination of several mechanisms without affecting runtime performance in a single inheritance object-oriented VM.
Embedded Domain-Specific Languages using Libraries and Dynamic Metaprogramming
TLDR
Two metaprogramming techniques whereby compiler data on code (code lifting) and types (manifests) can be requested by embedding libraries when needed are described, which exemplify how certain embedding tasks rely on data that is available in the compiler but is then lost in statically-typed languages.
Evaluating Call Graph Construction for JVM-hosted Language Implementations
TLDR
This work presents qualitative and quantitative analysis of the soundness and precision of call graphs constructed from JVM bytecodes produced for Python, Ruby, Clojure, Groovy, Scala, and OCaml applications and shows that all unsoundness comes from rare, complex uses of reflection and proxies, and the translation of first-class features in Scala incurs a significant loss of precision.
A Study of Call Graph Construction for JVM-Hosted Languages
TLDR
Qualitative and quantitative analyses of the soundness and precision of call graphs constructed from JVM bytecodes for these languages, and also for Groovy, Clojure, Python, and Ruby, suggest that bytecode-based analysis could serve as an implementation vehicle for bug-finding, security analysis, and IDE features for these Languages.
Bridging islands of specialized code using macros and reified types
TLDR
This project builds high performance "bridges" between "islands" of specialized code, removing the requirement that full traces need to be specialized, and obtains speedups up to 30x and around 12x in average compared to generic only code.
...
...

References

SHOWING 1-10 OF 43 REFERENCES
Compatible genericity with run-time types for the Java programming language
TLDR
This paper explains how to support general type parameterization---including both non-variant and covariant subtyping---on top of the existing Java Virtual Machine at the cost of a larger code footprint and the forwarding of some method calls involving parameterized classes and methods.
Design and implementation of generics for the .NET Common language runtime
TLDR
This paper extends the Microsoft.NET Common Language Runtime with direct support for parametric polymorphism (also known as generics), describing the design through examples written in an extended version of the C# programming language, and explaining aspects of implementation by reference to a prototype extension to the runtime.
Effective and Efficient Compilation of Run-Time Generics in Java
  • Mirko Viroli
  • Computer Science
    Electron. Notes Theor. Comput. Sci.
  • 2005
Parametric polymorphism in Java: an approach to translation based on reflective features
TLDR
This paper introduces a homogeneous translation in which run-time information about instantiation of type-parameters is carried, allowing full integration of parame-terized types with Java typing.
Types and programming languages
TLDR
This text provides a comprehensive introduction both to type systems in computer science and to the basic theory of programming languages, with a variety of approaches to modeling the features of object-oriented languages.
Adding type parameterization to the Java language
TLDR
This paper proposes parameterized classes and interfaces in which the type parameter may be constrained to either implement a given interface or extend a given class, without introducing any new type relations into the language.
Classes and mixins
TLDR
A model of class-to-class functions that refers to as mixins is developed, which is an intuitive model of an essential Java subset; an extension that explains and models mixins; and type soundness theorems for these languages.
The programming language jigsaw: mixins, modularity and multiple inheritance
TLDR
This dissertation provides a framework for modularity in programming languages, known as Jigsaw, which allows a previously unobtainable spectrum of features to be combined in a cohesive manner, including multiple inheritance, mixins, encapsulation and strong typing.
Jam - A Smooth Extension of Java with Mixins
TLDR
Jam, an extension of the Java language supporting mixins, that is, parametric heir classes, is presented, with the main objective in mind to obtain, rather than a new theoretical language, a working and smooth extension of Java.
The Java Virtual Machine Specification
TLDR
This second edition specifies the newest version of the Java virtual machine and provides a fascinating view into the inner workings of theJava 2 platform.
...
...