• Corpus ID: 336736

An Overview of the Scala Programming Language Second Edition

@inproceedings{Odersky2006AnOO,
  title={An Overview of the Scala Programming Language Second Edition},
  author={Martin Odersky and Philippe Altherr and Vincent Cremet and Burak Emir and Sean McDirmid and St{\'e}phane Micheloud and Nikolay L Mihaylov and Michel Schinz and Erik Stenman and Matthias Zenger},
  year={2006}
}
Scala fuses object-oriented and functional programming in a statically typed programming language. It is aimed at the construction of components and component systems. This paper gives an overview of the Scala language for readers who are familar with programming methods and programming language design. 

Figures from this paper

Scala for generic programmers
TLDR
It is argued that the functional object-oriented language Scala is in many ways a better setting for datatype-generic programming, because it provides equivalents of all the necessary functional programming features and also provides the most useful features of object- oriented languages.
Combining functional and imperative programming for multicore software: An empirical study evaluating Scala and Java
TLDR
This paper is the first to provide thorough empirical results by using Scala and Java as a vehicle in a controlled comparative study on multicore software development and confirms with statistical significance Scala's claim that Scala code is more compact than Java code, but clearly refute other claims of Scala on lower programming effort and lower debugging effort.
Constrained types for object-oriented languages
TLDR
The design and implementation of constrained types are presented, a natural, simple, clean, and expressive extension to object-oriented programming that supports extension with new constraint systems using compiler plugins.
On the Benefits of Combining Functional and Imperative Programming for Multicore Software An Empirical Study Comparing Scala and Java
TLDR
This paper is the first to provide thorough empirical results by using Scala and Java as a vehicle in a controlled comparative study on multicore software development, and confirms with statistical significance Scala’s claim that Scala code is more compact than Java code, but clearly refute other claims of Scala on lower programming effort and lower debugging effort.
Thorn: robust, concurrent, extensible scripting on the JVM
TLDR
The principal contributions are a careful selection of features that support the evolution of scripts into industrial grade programs - e.g., an expressive module system, an optional type annotation facility for declarations, and support for concurrency based on message passing between lightweight, isolated processes.
MORTAL - Multiparadigm Optimizing Retargetable Transdisciplinary Abstraction Language
TLDR
MORTAL aims to bridge the knowledge gap between computer scientists and scientists by offering a multiparadigm programming environment that allows connecting the mathematical formulae written by scientist to algorithms implemented by the software engineer in a natural way, and understood by both.
Habanero-Scala: A Hybrid Programming model integrating Fork/Join and Actor models
TLDR
Habanero-Scala: A Hybrid Programming model integrating Fork/Join and Actor models integrating Fork-Join-Actor models.
Code generation from specifications in higher-order logic
TLDR
This thesis is to present a code generator framework for the interactive proof assistant Isabelle/HOL, an implementation of higher-order logic that comes with two substantial novelties: a general but lightweight concept for datatype abstraction and support for Isabelle type classes in the manner of Haskell type classes.
Open and efficient type switch for C++
TLDR
This work implements a type switch construct as an ISO C++11 library, called Mach7, which provides concise notation and outperforms the visitor design pattern, commonly used for case analysis on types in object-oriented programming.
Metaprogramming with Traits
TLDR
A lightweight mechanism for specifying and reusing member-level structure in Java programs by introducing a hybrid structural/nominal type system that extends Java's type system.
...
...

References

SHOWING 1-10 OF 60 REFERENCES
Manifest types, modules, and separate compilation
This paper presents a variant of the SML module system that introduces a strict distinction between abstract types and manifest types (types whose definitions are part of the module specification),
An Extension of System F with Subtyping
TLDR
The main focus of the paper is the equational theory of F<:, which is related to PER models and the notion of parametricity, and some categorical properties of the theory when restricted to closed terms, including interesting categorical isomorphisms.
Type-Safe Prototype-Based Component Evolution
TLDR
This paper proposes a simple prototype-based model for first-class components on top of a class-based object-oriented language, and presents a type system for the calculus that ensures type-safe component definition, composition, and evolution.
The essence of functional programming
TLDR
This paper explores the use monads to structure functional programs and describes the relation between monads and the continuation-passing style in a compiler for Haskell that is written in Haskell.
A second look at overloading
TLDR
A minimal extension of the Hindley/Milner system that supports overloading and polymorphic records is studied, showing that the type system is sound with respect to a standard untyped compositional semantics and every typable term has a principal type.
Pizza into Java: translating theory into practice
Pizza is a strict superset of Java that incorporates three ideas from the academic community: parametric polymorphism, higher-order functions, and algebraic data types. Pizza is defined by
Essential language support for generic programming
TLDR
This paper presents the design of a type system and semantics for concepts that is suitable for non-type-inferencing languages and shares much in common with the type classes of Haskell, though the primary influence is from best practices in the C++ community.
A Statically Safe Alternative to Virtual Types
TLDR
This paper suggests a variant of virtual types which has similar expressiveness, but supports safe static type checking, which results in a language in which both parametric types and virtual types are well-integrated, and which is statically type-safe.
Scalable extensibility via nested inheritance
TLDR
This work describes nested inheritance, a mechanism that addresses some of the limitations of ordinary inheritance and other code reuse mechanisms, and shows how nested inheritance can be used to construct highly extensible software frameworks.
The design of a class mechanism for Moby
TLDR
This paper relies on a rich ML-style module system to provide features such as visibility control and parameterization, while providing a minimal class mechanism that includes only those features needed to support inheritance.
...
...