Dmitriy Parenskiy | 3 Jul 07:38 2015

Soriento - new Scala library for OrientDb

Soriento - new Scala library for OrientDb
Hi all
I am create simple mapping library for Scala and OrientDb.
  • Serialize/deserialize case classes to/from ODocument and save case classes to OrientDb.
  • DSL for create OClasses.
  • DSL for query by SQL with exctract case classes from documents.
  • And more (in progress).
This library is still in alpha, but I use some parts of it in my production project.
Welcome to contribute!

You received this message because you are subscribed to the Google Groups "scala-announce" group.
To unsubscribe from this group and stop receiving emails from it, send an email to scala-announce+unsubscribe-/
For more options, visit
Stephen McDonald | 2 Jul 02:01 2015

CurioDB: A Distributed & Persistent Redis Clone

Hi all,

I just wanted to share a project I've been working on over the last 6 months. I've called it CurioDB [1], it's a clone of Redis [2] that I've built in under 1000 lines of Scala/Akka. It makes use of Akka's persistence and clustering to overcome some of the shortcomings of Redis [3].

It's my first real Scala project. I started building it as a learning exercise, but found the experience so enjoyable that I took it much further than I originally thought possible of myself. Hopefully someone finds it useful and sees it as a showcase for how trivial Akka makes building distributed systems.


You received this message because you are subscribed to the Google Groups "scala-announce" group.
To unsubscribe from this group and stop receiving emails from it, send an email to scala-announce+unsubscribe-/
For more options, visit
Philipp Haller | 22 Jun 18:12 2015

CFP: AGERE! <at> SPLASH 2015 - ACM SIGPLAN Workshop on Programming based on Actors, Agents, and Decentralized Control

Hi, all,

Contributions to the below workshop are especially welcome from the Scala community.


Call for Papers:
AGERE! <at> SPLASH 2015 -

5th International ACM SIGPLAN Workshop on Programming based on Actors, Agents, and Decentralized Control

Held at SPLASH Conference
Pittsburgh, Pennsylvania, USA - October 25/26, 2015

=====  Introduction  =====

The fundamental turn of software to concurrency and distribution is not only a
matter of performance, but also of design and abstraction. It calls for
programming paradigms that, compared to current mainstream paradigms, would
allow us to more naturally think about, design, develop, execute, debug, and
profile systems exhibiting different degrees of concurrency, autonomy,
decentralization of control, and physical distribution.

AGERE! is an ACM SIGPLAN workshop dedicated to focusing on and developing
research on programming systems, languages and applications based on actors,
agents and any related programming paradigm promoting a decentralized mindset
in solving problems and in developing systems to implement such solutions.

The workshop is designed to cover both the theory and the practice of design
and programming, bringing together researchers working on models, languages
and technologies, and practitioners developing real-world systems and

More info about the specific topics can be found on the AGERE! 2015 website.

===== Contributions =====

The workshop welcomes three main kinds of contributions:

(1) mature contributions, to be published in the ACM Digital Library as an
    official ACM SIGPLAN publication;

(2) position papers and work-in-progress contributions, to be discussed
    during the event and included in the informal proceedings;

(3) demos that will be presented and discussed during the event.

Info about the format and the page limits can be found on the AGERE! 2015
website (

===== Special Issue =====

A special issue on a reference journal [*] will be organized with the extended
and revised versions of the best papers accepted and presented at the workshop.
This special issue follows a previous one published in Science of Computer
Programming (best papers from AGERE! 2011 and 2012) and a twin special issue
published in Computer Languages, Systems and Structures and in Concurrency and
Computation: Practice and Experience (best papers from AGERE! 2013 and 2014).

[*] Contacts are ongoing: targets include "Computer Languages, Systems and
Structures" (Elsevier), "Concurrency and Computation: Practice and Experience"
(Wiley), "Software: Practice and Experience" (Wiley), "Journal of Software and
Systems" (Elsevier), and "Science of Computer Programming" (Elsevier).

=====  Important dates =====

- Full-paper abstract deadline:      August 1, 2015
- Full-paper deadline:               August 7, 2015
- Full-paper notification:           September 7, 2015
- Position/work-in-progress papers:  September 7, 2015
- Demos/posters:                     September 7, 2015

Papers can be submitted at:

in PDF format. Submissions should use the ACM SIGPLAN format, following the
guidelines at

===== Organization and Committees

Organizers and PC chairs:

Elisa Gonzalez Boix, Vrije Universiteit Brussel, Belgium
Philipp Haller, KTH Royal Institute of Technology, Sweden
Alessandro Ricci, University of Bologna, Italy
Carlos Varela, Rensselaer Polytechnic Institute, USA

Steering Committee

Gul Agha, University of Illinois at Urbana-Champaign, USA
Rafael Bordini, FACIN-PUCRS, Brazil
Alessandro Ricci, University of Bologna, Italy
Assaf Marron, Weizmann Institute of Science, Israel

===== AGERE! <at> SPLASH 2015

You received this message because you are subscribed to the Google Groups "scala-announce" group.
To unsubscribe from this group and stop receiving emails from it, send an email to scala-announce+unsubscribe-/
For more options, visit
David Barri | 20 Jun 08:56 2015

[ANN] Released: ScalaCSS 0.3.0 & scalajs-react 0.9.1


ScalaCSS 0.3.0 released.

scalajs-react 0.9.1 released.


You received this message because you are subscribed to the Google Groups "scala-announce" group.
To unsubscribe from this group and stop receiving emails from it, send an email to scala-announce+unsubscribe-/
For more options, visit
tbrown | 19 Jun 21:36 2015

FinagleCon 2015

Hi all,

I'm pleased to announce that registration and the call for participation for the first annual FinagleCon are now open:

The event will be held on Thursday, August 13, 2015, and will be co-located with Scala by the Bay, which begins on the 14th. FinagleCon will be a full-day event, and will include talks by Finagle developers, contributors, and adopters, as well as workshops and tutorial sessions.

All Scala by the Bay attendees will receive a discount code that will allow them to register for FinagleCon for free, and Scala by the Bay registration is available at the regular price through June 16. Once you're registered for Scala by the Bay, please stay tuned for details about how to register for FinagleCon with the discount code.

It's also possible to register for FinagleCon independently if you are not attending Scala by the Bay. These tickets do not include access to other Scala by the Bay events.

If you're interested in submitting a talk proposal, you'll need to create a Linux Foundation account (they're helping us host the event) and select "FinagleCon 2015" when filling out the Call for Participation form. The CFP will be open until June 30, and the program will be announced on July 13.

We're also inviting organizations that are using Finagle to join the program as sponsors. If you're interested in sponsoring FinagleCon, please see our prospectus and get in touch at

This is our first time holding this event, so if you have questions please let us know. We're on Twitter at <at> finaglecon, and you can also reach us by email at

P.S. We're also hosting a (free) Finch / Finatra hack night at Twitter HQ next Tuesday (June 23) from 5-8 PM—if anyone's around SF and interested in spending an evening playing with Finatra v2, Shapeless, etc., there are a few tickets left.

Travis Brown

<at> travisbrown
Open source advocate at Twitter, Inc.

You received this message because you are subscribed to the Google Groups "scala-announce" group.
To unsubscribe from this group and stop receiving emails from it, send an email to scala-announce+unsubscribe-/
For more options, visit
Faruk Caglar | 26 May 17:01 2015

Deadline Approaching - CFP: ACM SIGPLAN GPCE 2015

[Apologies if you receive multiple copies of this email]

 Call for Papers: Computer Languages, Systems and Structures
 COMLAN Special Issue on the 14th International Conference on
  Generative Programming: Concepts & Experiences (GPCE'15)

Papers will be selected among top ranked papers from GPCE'15:

                    ACM SIGPLAN GPCE 2015
              14th International Conference on
        Generative Programming: Concepts & Experiences

             Oct 26-27, 2015, Pittsburgh, PA, USA

GPCE keynote speaker: Prof. Priya Narasimhan (CMU, USA)

GPCE is co-located with:
ACM SIGPLAN conference on Systems, Programming, Languages and
Applications: Software for Humanity (SPLASH 2015)
ACM SIGPLAN 8th International Conference on Software Language
Engineering (SLE) 2015


  GPCE abstract submission  : June 8, 2015
  GPCE full paper submission: June 15, 2015
  GPCE authors notification : July 24, 2015
  GPCE camera-ready         : Aug 7, 2015
  GPCE conference           : Oct 26-27, 2015

  Special issue submission  : January 1, 2016
  Special issue notification: May 1, 2016
  Special issue publication : July 1, 2016

  Note that GPCE workshops are handled by SPLASH

All dates are Anywhere on Earth


GPCE is a venue for researchers and practitioners interested in techniques
that use program generation, domain-specific languages, and component
deployment to increase programmer productivity, improve software quality,
and shorten the time-to-market of software products. In addition to
exploring cutting-edge techniques of generative software, our goal is to
foster further cross-fertilization between the software engineering and the
programming languages research communities.


GPCE seeks contributions on all topics related to generative software and
its properties. Topics of interest include, but are not limited to:

Generative software
* Domain-specific languages (language extension, language embedding,
  language design, language theory, language workbenches, interpreters,
* Product lines (domain engineering, feature-oriented and
  aspect-oriented programming, pre-processors, feature interactions)
* Metaprogramming (reflection, staging, partial evaluation), Type
  systems, Program synthesis
* Implementation techniques and tool support (components, plug-ins,
  libraries, metaprogramming, macros, templates, generic programming,
  run-time code generation, model-driven development, composition tools,
  code-completion and code-recommendation systems)

Practical Applications and Empirical evaluations
* Empirical evaluations of all topics above (user studies, substantial case
  studies, controlled experiments, surveys, rigorous measurements) 
* Application areas and engineering practice (Cloud Computing, Internet of
  Things, Cyber Physical Systems, Mobile Computing, Software Defined
  Networking, High Performance Computing, Patterns and Middleware,
  Development methods)

Properties of generative software
* Correctness of generators and generated code (analysis, testing, formal
  methods, domain-specific error messages, safety, security)  
* Reuse and evolution
* Modularity, separation of concerns, understandability, and
* Performance engineering, nonfunctional properties (program optimization
  and parallelization, GPGPUs, multicore, footprint, metrics)

We particularly welcome papers that address some of the key challenges in
the field, such as,
* synthesizing code from declarative specifications
* supporting extensible languages and language embedding
* ensuring correctness and other nonfunctional properties of generated code
* proving generators correct
* improving error reporting with domain-specific error messages
* reasoning about generators
* handling variability-induced complexity in product lines
* providing efficient interpreters and execution languages
* human factors in developing and maintaining generators

GPCE encourages submissions about empirical evaluations and applications of
generative software, and such papers will be given special consideration
during reviewing.


Research papers: 10 pages maximum (ACM SIGPLAN style)

Research papers should report on original and unpublished results of
theoretical, empirical, conceptual, or experimental research that
contribute to scientific knowledge in the areas listed above (the PC chair
can advise on appropriateness)

Tool demos and short papers: 4 pages maximum (ACM SIGPLAN style).

The goal of short papers is to promote current work on research and
practice. Short papers represent an early communication of research and do
not always require complete results as in the case of a full paper. In this
way, authors can introduce new ideas to the community, discuss ideas and
get early feedback. Please note that short papers are not intended to be
position statements. Short papers are included in the proceedings and will
be presented with a shorter time slot at the conference.

Tool demonstrations should present tools that implement generative
techniques, and are available for use. Any of the GPCE topics of interest
are appropriate areas for tool demonstrations, although purely commercial
tool demonstrations will not be accepted. Submissions must provide a tool
description of 4 pages in SIGPLAN proceedings style (see above) and a
demonstration outline including screenshots of up to 4 pages. Tool
demonstrations must have the words "Tool Demo" or "Tool Demonstration" in
the title, possibly appended in parenthesis. The 4-page tool description
will, if the demonstration is accepted, be published in the proceedings.


The special issue will publish GPCE'15 papers by invitation from the
guest editors, is closed to papers outside the conference, and will
only include top-ranked papers from GPCE'15 (based on the GPCE'15
review, see scope and topics of interest, above).  The special issue
will be published by Elsevier in Computer Languages, Systems and
Structures (COMLAN):



  Christian Kastner, Carnegie Mellon University, Pittsburgh, PA, USA


  Aniruddha Gokhale, Vanderbilt University, Nashville, TN, USA


  Faruk Caglar, Vanderbilt University, Nashville, TN, USA
  Tomofumi Yuki, INRIA Rhone-Alpes, France

  Ulrik Pagh Schultz, University of Southern Denmark, Denmark
  Kenichi Asai, Ochanomizu University, Japan
  Aniruddha Gokhale, Vanderbilt University, Nashville, TN, USA


  Kenichi Asai, Ochanomizu Univ, Japan
  Emilie Balland, INRIA Bordeaux, France
  Don Batory, Univ of Texas, USA
  Walter Binder, Univ of Lugano, Switzerland
  Jan Bosch, Chalmers Univ, Sweden
  Akshay Dabholkar, Oracle, USA
  Ewen Denney, NASA Ames, USA
  Katrina Falkner, Univ of Adelaide, Australia
  Bernd Fischer, Stellenbosch Univ, South Africa
  Matthew Flatt, Univ of Utah, USA
  Jeff Gray, Univ of Alabama, USA
  Michael Haupt, Oracle Labs, Germany
  James Hill, Indiana Univ Purdue Univ at Indianapolis, USA
  Young-Woo Kwon, Utah State Univ, USA
  Raffaela Mirandola, Politechnico di Milano, Italy
  Hridesh Rajan, Iowa State Univ, USA
  Laurent Reveillere, LaBRI, Univ of Bordeaux, France
  Marcio Ribeiro, Federal Univ of Alagoas, Brazil
  Tiark Rompf, Purdue Univ, USA
  Klaus Schmid, Stiftung Universitat Hildesheim, Germany
  Norbert Siegmund, Univ of Passau, Germany
  Yannis Smaragdakis, Univ of Athens, Greece
  Sumant Tambe, RTI Inc, USA
  Petr Tuma, Charles Univ, Czech Republic
  Nalini Venkatasubramanian, Univ of California, Irvine, USA
  Jules White, Vanderbilt Univ, USA
  Eric Wohlstadter, Univ of British Columbia, Canada

You received this message because you are subscribed to the Google Groups "scala-announce" group.
To unsubscribe from this group and stop receiving emails from it, send an email to scala-announce+unsubscribe-/
For more options, visit
Justin Johansson | 25 May 06:07 2015

New XPath / XQuery 3 engine being developed in Scala

Hi all,

I have been following the development of the W3C XML standards for XPath, XSLT & XQuery since around 2001. XPath 3 is a very mature specification compared with XPath 1.0 and is underpinned by a very interesting data model and type system. XPath is used in a whole host of different contexts, such as XQuery, XSLT and XForms, but has suffered from there not being many implementations available.

Accordingly, I have had this desire to implement an XPath engine for quite some time. Problem is that XPath & XQuery are very complex specifications and aspiring implementors have been daunted by the prospect of throwing years upon years of development effort at the task. Added to the difficulty is that XPath is a lazily evaluated dynamic language.

So now, having prototyped XPath engines in all manner of programming languages (e.g. C++, Java, Scala, Clojure, OCAML etc.) to find out which language might best facilitate such undertaking, I have, after several years of trial & tribulation, decided upon & settled on Scala.

While it still remains a significant undertaking on my part, it nevertheless represents a strong vote of confidence to pursue the Scala route in all earnest.

Time permitting, I would like to formally blog about the progress of my "XPath in Scala" project. In the meantime, I am talking about it on Twitter <at> MartianOdyssey

All encouraging support welcome.


Justin Johansson
scala dot xquery <at> letter-after-f mail dot com

You received this message because you are subscribed to the Google Groups "scala-announce" group.
To unsubscribe from this group and stop receiving emails from it, send an email to scala-announce+unsubscribe-/
For more options, visit
Aleksandar Prokopec | 23 May 05:18 2015

Mecha 0.2 Released

Hi all,

I wanted to share an SBT plugin that I had in the backlog for a while now.
The plugin strikes a nice balance between being lightweight and offering some powerful workflow automation features.
I dogfooding it heavily on my own projects for some time now.
I finally caught some time to document the thing properly, so I thought it's a good time to share it more broadly.
Hope some people find it helpful!


Mecha -- SBT Plugin That Automates Development Workflow

Mecha is an SBT plugin that aggregates all specified repositories into one big project, which you can then compile as if they were one project. You can branch/merge/commit changes in all the repositories simultaneously, pull/push to their respective origins with a single SBT command, or automatically maintain any number of downstream mirrors. Mecha puts repositories into subdirectories of the super-repository. You can choose which subdirectories to track while you work, or instead depend on them through pre-published Maven artifacts.

  • supports super-repositories that contain multiple subprojects
  • bulk pull, branch, merge, push, and mirroring for subprojects
  • optional tracking for subprojects
  • automatic source/library dependency configuration in subprojects
  • automatic configuration file generation
  • automated remote deployments over SSH
  • automated documentation deployments to remote Git repositories (ideal for GH pages!)
  • automated benchmark deployments in case you're using ScalaMeter
Mecha is available on GitHub under the BSD-3 license:

The Mecha 0.2 release is available at Maven - adding the

     "com.storm-enroute" % "mecha" % "0.2"

Detailed usage instructions are available here:

You received this message because you are subscribed to the Google Groups "scala-announce" group.
To unsubscribe from this group and stop receiving emails from it, send an email to scala-announce+unsubscribe-/
For more options, visit
Sebastian Erdweg | 27 Apr 11:23 2015

Final CFP: Workshop on Generic Programming 2015 - Deadline May 15

                       CALL FOR PAPERS

                           WGP 2015

        11th ACM SIGPLAN Workshop on Generic Programming
                      Vancouver, Canada
                    Sunday, August 30, 2015


                      Co-located with the
International Conference on Functional Programming (ICFP 2015)

Goals of the workshop

Generic programming is about making programs more adaptable by making
them more general. Generic programs often embody non-traditional kinds
of polymorphism; ordinary programs are obtained from them by suitably
instantiating their parameters. In contrast with normal programs, the
parameters of a generic program are often quite rich in structure; for
example they may be other programs, types or type constructors, class
hierarchies, or even programming paradigms.

Generic programming techniques have always been of interest, both to
practitioners and to theoreticians, and, for at least 20 years,
generic programming techniques have been a specific focus of research
in the functional and object-oriented programming communities. Generic
programming has gradually spread to more and more mainstream
languages, and today is widely used in industry. This workshop brings
together leading researchers and practitioners in generic programming
from around the world, and features papers capturing the state of the
art in this important area.

We welcome contributions on all aspects, theoretical as well as
practical, of

* generic programming,
* programming with (C++) concepts,
* meta-programming,
* programming with type classes,
* programming with modules,
* programming with dependent types,
* type systems for generic programming,
* polytypic programming,
* adaptive object-oriented programming,
* component-based programming,
* strategic programming,
* aspect-oriented programming,
* family polymorphism,
* object-oriented generic programming,
* implementation of generic programming languages,
* static and dynamic analyses of generic programs,
* and so on.

Program Committee

* Patrick Bahr (co-chair), University of Copenhagen
* Sebastian Erdweg (co-chair), Technical University of Darmstadt
* Edwin Brady, University of St Andrews
* Edsko de Vries, Well-Typed LLP
* Mauro Jaskelioff, National University of Rosario
* Johan Jeuring, Utrecht University
* Pieter Koopman, Radboud University Nijmegen
* Bruno C. d. S. Oliveira, University of Hong Kong
* Nicolas Pouillard, IT University of Copenhagen
* Sukyoung Ryu, Korea Advanced Institute of Science and Technology
* Sibylle Schupp, Hamburg University of Technology
* Sam Tobin-Hochstadt, Indiana University

Proceedings and Copyright

We plan to have formal proceedings, published by the ACM. Accepted
papers will be included in the ACM Digital Library. Authors must grant
ACM publication rights upon acceptance
(, but may retain copyright if they
wish. Authors are encouraged to publish auxiliary material with their
paper (source code, test data, and so forth). The proceedings will be
freely available for download from the ACM Digital Library from one
week before the start of the conference until two weeks after the

Submission details

* Submission deadline:  Fri, 15th May 2015
* Author notification:  Fri, 26th June 2015
* Final version due:    Sun, 19th July 2015
* Workshop:             Sun, 30th August 2015

Submitted papers should fall into one of two categories:

* Regular research papers (12 pages)
* Short papers: case studies, tool demos, generic pearls (6 pages)

Regular research papers are expected to present novel and interesting
research results. Short papers need not present novel or fully polished
results. Good candidates for short papers are those that report on 
interesting case studies of generic programming in open source or 
industry, present demos of generic programming tools or libraries, 
or discuss elegant and illustrative uses of generic programming ('pearls').

All submissions should be in portable document format (PDF), formatted
using the ACM SIGPLAN style guidelines (two-column, 9pt). Regular 
research papers must not exceed 12 pages. Short papers must not exceed 
6 pages. If applicable, papers should be marked with one of the labels
'case study, 'tool demo' or 'generic pearl' in the title at the time 
of submission.

Papers should be submitted via HotCRP at

Travel Support

Student attendees with accepted papers can apply for a SIGPLAN PAC grant
to help cover travel expenses. PAC also offers other support, such as
for child-care expenses during the meeting or for travel costs for
companions of SIGPLAN members with physical disabilities, as well as for
travel from locations outside of North America and Europe. For details
on the PAC program, see its web page (

History of the Workshop on Generic Programming

Earlier Workshops on Generic Programming have been held in

* Gothenburg, Sweden 2014 (affiliated with ICFP),
* Boston, Massachusetts, US 2013 (affiliated with ICFP),
* Copenhagen, Denmark 2012 (affiliated with ICFP),
* Tokyo, Japan 2011 (affiliated with ICFP),
* Baltimore, Maryland, US 2010 (affiliated with ICFP),
* Edinburgh, UK 2009 (affiliated with ICFP),
* Victoria, BC, Canada 2008 (affiliated with ICFP),
* Portland 2006 (affiliated with ICFP),
* Ponte de Lima 2000 (affiliated with MPC),
* Marstrand 1998 (affiliated with MPC).

Furthermore, there were a few informal workshops

* Utrecht 2005 (informal workshop),
* Dagstuhl 2002 (IFIP WG2.1 Working Conference),
* Nottingham 2001 (informal workshop).

There were also (closely related) DGP workshops in Oxford (June
3-4 2004), and a Spring School on DGP in Nottingham (April 24-27
2006, which had a half-day workshop attached).

WGP Steering Committee

* Andres Löh
* Ronald Garcia
* Jacques Carette
* Jeremiah Willcock
* José Pedro Magalhães
* Tiark Rompf
* Tarmo Uustalo
* Stephanie Weirich
* Fritz Henglein


You received this message because you are subscribed to the Google Groups "scala-announce" group.
To unsubscribe from this group and stop receiving emails from it, send an email to scala-announce+unsubscribe@...
For more options, visit

Lucas Satabin | 30 Apr 08:47 2015

Diffson 1.0.0 released

Hi all,

I am glad to announce the new release of the Diffson library.

Diffson is a Scala library to create and apply diffs and patches on json 
It is an implementation of RFCs 6901 [0] and 6902 [1].

This new major version includes several changes:

  - switch to spray-json [2] as underlying json library instead of 
lift-json [3],
  - fallback to another LCS algorithm when patience algorithm is not 
able to produce good diffs
  - test against the compliance tests [4].

Diffson 1.0.0 is released for scala 2.10 and 2.11 and jars have been 
uploaded on sonatype maven repository. They should be available on 
central repository within a few hours.

You can find the project on its website:

Comments and feedback are welcome!




You received this message because you are subscribed to the Google Groups "scala-announce" group.
To unsubscribe from this group and stop receiving emails from it, send an email to scala-announce+unsubscribe@...
For more options, visit

David Barri | 15 Apr 09:03 2015

ScalaCSS 0.2.0 released!

ScalaCSS v0.2.0 has been released with lots of yummy changes.


Project page:

ScalaCSS is a standalone library for Scala and Scala.JS, that aims to bring type-safety and clarity to:
  • creating CSS
  • using CSS
  • maintaining CSS
  • correctness of CSS
You can create standalone stylesheets like SCSS/LESS, and you can create inline styles to be applied to directly to HTML. It currently has modules for integration with scalajs-react and Scalatags.

Happy Coding!

You received this message because you are subscribed to the Google Groups "scala-announce" group.
To unsubscribe from this group and stop receiving emails from it, send an email to scala-announce+unsubscribe-/
For more options, visit