Database Access with Slick

Slick is Typesafe's database query and access library for Scala. It allows you to work with stored data as if you were using Scala collections while at the same time giving you full control over when a database access happens and which data is transferred.

Whereas most database libraries either require you to write SQL code or are based on an ORM (object-relational mapping) architecture, Slick bridges the gap between functional programming and declarative querying using a functional-relational mapping aproach. This talk gives you an overview of the design of Slick 2.0 and shows you how to use it.

ScalaJS and ReactJS

In this session we will build a reactive web application using Play Framework on the server side and ScalaJS together with ReactJS on the client side.

Simple, fast & agile REST with Spray.io

Spray, once a stand-alone project, now part of Akka, is a toolkit for building and consuming REST services.

In the talk we will build a simple REST service with Spray, and then consume it with a Spray-based client. No code can live without tests, so we'll take care of that as well.

You'll see that building REST services can be really simple—no containers, minimal boilerplate, fast development time!

Doing Crazy Algebra with Scala Types

What would it mean to "add" or "multiply" types like Boolean and List[Int], or to apply the quadratic formula to a type, expand its power series, then use this to count binary trees? How could you interpret differentiating a type, and what's this got to do with zippers? I'll show how doing some crazy algebraic operations on Scala types can actually throw up some interesting, surprising and useful results!

Scaling with Akka

This talk will give you an idea what scaling with Akka means. You will see by your own eyes how actor system can scale up on many processor cores and scale out on many network nodes. Prepare for cool live demo on cluster of four Raspberry Pi’s!

The Dark Side of Scala

I love Scala. I really do. That being said we will spend half an hour looking at complexities, inconsistencies and obscure behavior in the language—syntax, standard library and ecosystem. Hopefully apart from complaining we will also learn how to get the most of the platform without too much frustration.

Event sourcing with akka-persistence

Akka persistence is a new utility coming to Akka 2.x+. In the dawn of more and more event sourcing based applications being built, akka-persistence aims at simplifying event registration, replay and snapshoting. During this session we'll discover how to build reactive, event sourcing based apps using the new abstractions provided, and investigate how to implement your own journals to back these Persistent Stateful Actors.

Underscore magic

The hero of my 30 minutes talk will be the underscoere character, a kind of a joker, which can mean 'all' or 'nothing'.

_ (0x5F in ASCII) will be the starting point for the discussion of interesting scala's features.

We'll start with imports and variable declarations moving on to more advanced applications.

Usage of underscore character can improve the readability of the code, while ignorance of _ can effectively slow down the work efficiency.

Furthermore it can even completely discourage the language at first contact.

Macro-Based Type Providers in Scala

Language-integrated queries and type providers are two of the most promising applications of compile-time metaprogramming. While the former can be implemented almost trivially with macros in Scala, type providers have proven more elusive, and their implementation has become one of the most interesting challenges in Scala macro development.

In this talk we will outline two approaches to bringing type providers to Scala. The first approach delivers "public" type providers—that is, type providers that generate publicly visible classes—and requires dedicated macro flavors (either type macros or macro annotations). The second approach ("anonymous" type providers) does not require new macro flavors, but is rather built on structural types and vanilla def macros.

Which approach works best? Are these solutions mature enough to be used in everyday development? How do these two approaches compare to F#'s type providers? Join us for our talk to find out!

Scalaz—the good, the bad and the ugly

Scalaz is one of very controversial Scala libraries. Half of Scala developers love it, other half gets scared when its name is mentioned :) I'll show useful Scalaz snippets for everyday coding. I'll also show a bit of cryptic (read bad) code you can write using it.

Lambda implementation in Scala 2.11 and Java 8

Let's look under the hood and check how both Scala 2.11 and Java 8 implement lambdas on the JVM. Java 8 implements lambdas using different strategy compared to Scala and I'll explain how Scala is learning a new trick from Java. Being rather unusual event is worth highlighting on its own.

We'll check whether Java 8 lambdas are more efficient than Scala counterparts by looking at runtime representation of both.

Lastly, I'll explain what role invokedynamic instruction plays in Java 8's implementation of lambdas. To the surprise of many people, invokedynamic has nothing to do with invoking lambdas but enables evolution of lambda implementation on the JVM. We'll see how this interesting observation might affect future versions of both Java and Scala.

Although the whole topic is fairly low-level, I'll try focus more on interesting tidbits and make it fun to follow.

The Tale of the Glorious Lambdas & the Were-Clusterz (i.e. Scala + Hadoop)

At ICM UW* we perform a bleeding edge research on scholarly publishing. We have a Hadoop cluster and do fun stuff with it. We thought it'd be even funnier if we combined it with Scala to perform our analysis. So we did it. We shall tell you our story. The story of the good, the bad and the ugly in the world of the lambdas on elephants. Brace yourselves.

* Interdisciplinary Centre for Mathematical and Computational Modelling, University of Warsaw