This is the list of full papers accepted to the Third Scala Workshop, part of Scala Days 2012:
 

• SubScript: Extending Scala with the Algebra of Communicating Processes (link)
  André Van Delft
  Most programming languages offer relatively little or no support for parallelism and non-determinism. Support would in particular be very useful for specifying event handling and background processing in applications with graphical user interfaces, and for specifying grammars of input data. To improve the situation, programming languages may be extended with constructs adopted from the theory named Algebra of Communicating Processes. This has been done in SubScript, which is a extension to Scala. Examples show how SubScript is useful for programming GUI controllers in the MVC paradigm.
  ACP-like constructs and some syntactic sugar suddenly enable process descriptions with an expressive power like in parser generators, logic and Unix pipes. This applied math allows for modeling the behavior of GUI controllers very clearly and concisely. We claim that this will lead to higher reliability against less cost, but foremost: more fun.
  Currently SubScript is implemented as a DSL, in about 2000 lines of Scala code. This maintains a call graph, that grows and shrinks as a SubScript program runs. The semantics of the language is mainly determined in terms of the rules for this graph manipulation. SubScript implementations have some freedom in these rules, so that they can specialize, e.g. for real time constraints, probabilities, timed simulations and parallel processing.
   
• Lightweight Polytypic Staging: a new approach to Nested Data Parallelism in Scala (link)
  Alexander Slesarenko
  This paper describes polytypic staging – an approach to staging of a domain-specific language (DSL) that is designed and implemented by means of polytypic (datatype generic) programming techniques. We base our implementation on Lightweight Modular Staging (LMS) framework by extending and making it polytypic. We show how to apply it to a particular domain. The domain is nested data parallelism where data parallel programs are expressed in the DSL embedded in Scala. The paper is organized around a specific DSL, but our implementation strategy should be applicable to any polytypic DSL in general.
   
• Habanero-Scala: Async-Finish Programming in Scala (link)
  Shams Imam and Vivek Sarkar
  With the advent of the multicore era, it is clear that improvements in application performance will require parallelism. Programming models that utilize multiple cores offer promising directions for the future where core counts are expected to increase. There is, hence, a renewed interest in programming models that simplify the reasoning and writing of efficient parallel programs. In this paper, we present Habanero-Scala (HS) which implements a generic task parallel programming model that can be used to parallelize both regular and irregular applications. HS is a library extension of Scala and supports a hybrid programming model combining the previously developed Async/Finish Model (AFM) and Actor Model (AM). HS extends Scala's actor-based concurrency model with creation of lightweight tasks embodied in async, future, and foreach constructs; termination detection using the finish construct; locality in the form of places; weak isolation using isolated blocks; and task coordination patterns using phasers, data-driven futures. HS offers a simpler parallel programming model compared to writing programs using threads and adds to the tools available for the programmer to aid in productivity and performance while developing parallel software.
   
• ActorDroid - A distributed computing framework for mobile devices based on Scala actors (link)
  Pierre-André Mudry and Romain Cherix
  With the processing power available on modern mobile devices, it becomes increasingly interesting to harvest this power for distributed computations. In this context, we developed a programming framework based on Scala actors that runs on the Android operating system. This framework enables the distribution of an application consisting of communicating actors among multiple devices such as mobile phones or tablet PCs. Through two different experiments, we demonstrate that the flexibility of Scala actors is a major advantage in terms of development of the framework but also in its usage thanks to various Scala constructs such as functional programming and pattern matching.
   
• Research Hospital Data ETL with DataExpress (link)
  Aaron Masino, Michael Italia, and Lemar Davidson
  Data ETL operations are a common requirement for many of the research projects conducted at the Children’s Hospital of Philadelphia. As described in this paper, these ETL pro- cedures are complicated by a variety of issues that make the development of a new ETL tool necessary. We have devel- oped, as described here, a Scala domain specific language called DataExpress that supports ETL operations between a variety of data store types including multiple database imple- mentations, Excel files, and value delimited text files. ETL procedures can be developed and executed as simple script files in a manner similar to Perl scripts. DataExpress will be made available for free as an open source project.
   
• Asymmetric Lenses in Scala (link)
  Tony Morris
  Lenses are bidirectional transformations between pairs of connected structures. Asymmetric lenses — where one of those two connected structures is taken to be primary — have been extensively studied. We begin by exploring the existing utilities available for bidirectional transformations in the Scala programming language. We discuss the associated problems with these utilities using examples and propose a solution using asymmetric lenses. We present the canonical representation of an asymmetric lens and an alternative representation which is particularly suited to the specific properties of the Scala programming language and which has desirable properties for users. We explore a small set of interesting user libraries that arise as a consequence of integrating asymmetric lenses into Scala, chosen for the purpose of demonstrating utility. Finally, we briefly examine existing requirements, solutions and proposals for integrating lenses into the Scala programming language.
   
• Stackless Scala With Free Monads (link)
  Rúnar Bjarnason
  Tail call elimination (TCE) in the Scala compiler is limited to self-recursive methods, but tail calls are otherwise not eliminated. This makes functions composed of many smaller functions prone to stack overflows. Having a general TCE mechanism would be a great benefit in Scala, particularly for functional programming. Trampolining is a popular technique, which can be used for TCE in languages that don't support it natively. This paper gives an introduction to trampolines in Scala and expands on this solution to gain elimination of any method call whatsoever, even calls that are not in tail position at all. This obviates altogether the use of the call stack in Scala programs.
   
• Generic Numeric Programming Through Specialized Type Classes (link)
  Erik Osheim
  We describe an ongoing effort to build a system of type classes that support fast, accurate, flexible and generic numeric programming in Scala. This work combines Scala's support for user-directed type specialization with previous work on numeric type classes. In principle these allow one to create generic numeric algorithms without sacrificing the speed of a direct implementation. In practice, these performance gains make very specific demands of both the language and the user.
  This paper is a case study: we will explain the problems faced, discuss our strategies, and provide benchmarking results. We will also discuss ways in which Scala could be improved to more easily accommodate this kind of work. Finally, we will present a simple compiler plugin that can be used to increase performance in many cases.