This is the list of full papers accepted to the First Scala Workshop (in random order):
- Data Parallel Programming in Scala (link)
To more fully utilize the potential offered by multi-core processors, programming languages must have features for expressing parallelism. Data parallel programming features allow high-level collection-oriented operations to be easily expressed by the programmer, and then implemented by the runtime system in a parallel fashion for improved performance. This paper describes a data parallel class library, for the Scala language. This data parallel library includes a new type of data structure called a Parallel Vector, and fifteen basic operations on this data structure. The library and its implementation in Scala have several novel aspects including Where-Masks for conditional execution and vertical integration of data parallel operations in the runtime library implementation.
- Automatic refactorings for Scala programs (link)
Ilya Sergey, Dave Clarke and Alexander Podkhalyuzin
Scala is a programming language that combines the object-oriented and functional programming paradigms. Dependent types, higher-order functions and implicit conversions bring new ideas and challenges when implementing code refactoring. In this paper, we give an overview of the automatic refactorings for Scala programs offered by the IntelliJ IDEA programming environment. We consider the main differences between well-known automatic refactorings implemented for Scala with their Java analogues, and give short descriptions of the underlying pitfalls and techniques. Finally, we provide a short survey of refactorings that are not implemented yet but might be useful for practical software development in Scala.
- CCSTM: A Library-Based STM for Scala (link)
Nathan Bronson, Hassan Chafi and Kunle Olukotun
We introduce CCSTM, a library-only software transactional memory (STM) for Scala, and give an overview of its design and implementation. Our design philosophy is that CCSTM should be a useful tool for the parallel programmer, rather than a parallelization mechanism for arbitrary sequential code. This frees us from the semantic tar pits that surround privatization, strong isolation, and irrevocable system calls. It also allows us to express the STM using Scala classes and methods, a design choice that has far-reaching consequences. Transactional accesses in CCSTM are performed through instances that implement a trait Ref. These transactional references may be long-lived, or may be transient accessors to bulk transactional data such as an array. The syntax for dereferencing Ref instances is a pain point for the library-based approach, but the reference-based interface also provides benefits. Ref serves as a first-class representation of a transactionally-managed memory location, providing a natural way to express additional STM features such as conditional waiting, non-transactional compare-and-swap, manually-validated reads, and deferrable transformation using pure functions.
In an additional departure from typical STM designs, CCSTM passes the current transactional context through an implicit parameter, rather than dynamically binding the transaction to the current thread. This static transaction scoping allows CCSTM to compete in performance with an STM that performs bytecode rewriting, but it hinders composability. We sketch a potential solution to this problem that combines static scoping for barriers and dynamic scoping for nested transactions.
- A Case Study in DSL Development: An Experiment with Python and Scala (link)
Klaus Havelund, Michel Ingham and David Wagner
This paper describes an experiment performed with developing a Domain Specific Language (DSL) for monitoring and control of the launch platform for future Constellation rockets at NASA's Kennedy Space Center in Florida, USA. The Constellation project has been conceived as NASA's replacement of the current aging space shuttle program, with the extended objective of sending humans back to the moon, and subsequently to Mars. The DSL effort was specifically performed for the NASA Constellation Launch Control System (LCS) project. The main experiment was performed using simulators of the existing space shuttle launch platform, and included designing and implementing a prototype in the Python programming language, chosen for its succinct notation. A later study was carried out where part of the DSL was implemented in Scala, and compared to the Python implementation from a linguistic DSL elegance point of view.
- Type-safe SQL embedded in Scala (link)
In contrast to the industry's need of relational databases the interaction between programs and databases using the Structured Query Language is often inconvenient and error-prone. This paper offers an approach for embedded SQL statements in Scala with validation against the corresponding database schema and result type inference based on re-writing to plain JDBC code. It describes ideas of design and implementation.
- Developing the Scala Bindings to the Fly Object Space (link)
Channing Walton, Nigel Warren and Simon Kent
Fly is a lightweight Object Space that can distribute and coordi-nate information on clusters of computers in the form of Objects. It follows the form of Tuple Spaces in Linda and Java Spaces in Jini. Fly is language independent and hence can be bound into various programming languages via the development of specific language stubs that expose the interface to the Space to client programs. In this paper we contrast and compare the interface of the Java Bindings with the development and design of the Scala bindings and interfaces, with particular reference to the introduction of Scala language specific features such as the use of Options and the Scala Actors model.
- Lightweight language support for type-based, concurrent event processing (link)
Many concurrent applications are structured around type-based event handling. Scala provides a library for event-based actors, which allows common idioms to be expressed in a concise and intuitive way. However, innocent-looking programs can exhibit catastrophic performance under certain conditions. In this paper, we introduce translucent functions, a type-based refinement of Scala's pattern-matching functions. Translucent functions additionally provide the run-time types of classes that identify disjoint cases in a pattern. We show how this additional type information can be used to optimize actors as well as a form of join-style synchronization.
- Running Scala in the Browser (link)
- Building a Kermeta Compiler using Scala: an Experience Report (link)
François Fouquet, Olivier Barais and Jean-Marc Jezequel
This paper presents an experience report of building a Kermeta compiler using Scala as a target language. Kermeta is a domain specific language inspired by language such Eiffel and OCL and designed for specifying the operational semantics of meta-models. This engineering work, initially motivated by performance issues of our Kermeta interpreter is an excuse to study and discuss some paradigm that mismatches between Scala and Kermeta. This paper mainly discusses how we can manage open classes, multiple inheritance, design by contracts, model type paradigms, etc. using Scala.
In addition to the presentation of the above papers, Scala Days will include many other technical presentations, experience reports, and tool demonstrations: we will be able to offer you 15 to 20 further talks and topics to choose from!