• PEGEX: a PEG-based pattern matching library EXtended by back reference with regex-like notation in Scala
  Kota Mizushima
  
  I would like to talk about PEGEX, which I have been developping and is a pattern matching library based on parsing expression grammars (PEGs) extended by back reference with regex-like "light-weight" notation. Scala's PEG parser combinator library is very expressive and extensible. However, its syntax is too "heavy-weight" for pattern matching to strings. In such cases, we can use scala.util.matching.Regex class instead of PEG parser combinator library because Regex's syntax is "light-weight". But Regex cannot handle strings that have recursive structure easily. PEGEX is the combination of power of PEG and "light-weight" notation of Regex. Additionally, PEGEX have "back reference", which I borrowed from Regex for the cases such as correspondence of tag names of XML. I will talk about design, implementation, and usage of PEGEX. Currently PEGEX is being developed internally and not released yet. I'm planning to release PEGEX after a few months.
   
• Scala Parallel Collections
  Aleksandar Prokopec
  
  Modern multiprocessor architectures offer computing resources that are not always straightforward to use. To leverage this computing power one has to adapt existing algorithms and programming approaches. Support in the software stack is necessary to easily write parallel programs.
  One such support comes in the form of parallel collections. Ordinary collections perform bulk operations sequentially and use only a single processor while parallel collections deploy their work on multiple processors to increase their performance. Scala parallel collections that will be introduced in 2.8 reimplement standard collection operations while keeping compatibility with existing Scala collection framework. They also introduce new operations characteristic for parallel algorithms, and a few contracts the programmer should be aware of.
  Parallel programs often require specialised data structures to be efficient. Parallel collection framework contains several novel data structures that have been recently developed. These data structures are designed to fit particularly well in the divide and conquer approach to designing parallel algorithms, while keeping good cache locality and avoiding concurrent memory writes. Another important concern is the issue of immutability - generally the notion of immutable data structures found in functional languages fits well to parallel paradigm and can provide efficient operations on data.
   
• Automated Refactoring for Scala
  Mirko Stocker
  
  Refactoring is a widely adopted practice among software engineers, but doing it by hand is tedious. Scala currently lacks a comprehensive tool that automates refactoring. This paper presents a candidate to fill this void, it is not tied to a specific integrated development environment but can be integrated easily – an integration for the Eclipse Scala plug-in is being provided. Another goal is to make the development of new refactorings as simple as possible. This is achieved by extending the existing Scala compiler infrastructure with the necessary facilities to develop refactorings.
  The first implemented refactoring is Extract Method; it will be presented along with ideas for variations of the well-known refactoring that are possible with Scala.
   

Due to space constraints, this session is limited to max 50-60 people.