Having a cake and eating it too. Introduction to Typeclasses.

Being in a Scala community, you've probably heard about type classes. Very basic concept that both commonly used among many Scala libraries and at the same time very fundamental to understand any theoretical concepts behind Functional Programming. This short talk is all about explaining what Type classes are, how to use them and how to create them, with strong emphasis on answering the question "why should I even care?". We will focus on both on prons and cons, however speaker will probably be a bit biased towards the former.

We will follow story of couple of developers, struggling with conceptual design problem. As many before them, they will eventually reinvent the wheel. The solution they will end up with, is what we call a Type class.

This is a "from zero to hero" talk. Preferable audience are people who want to:

1. understand any shapeless/scalaz/cats presentation out there (this presentation will give you ability to survive first 10 minutes of mentioned talks)

2. be enlightened that "monads are just type classes with some laws" (this is not a monad tutorial though)

3. get the "aha!" moment, realising that they've been using Type classes from time to time, without knowing it

Swave - a fresh Reactive Streams Implementation

One of the most exciting developments of the last two years has been the advent of "Reactive Streams", a powerful new abstraction for defining and scaling pipelined processing logic in a fully asynchronous, non-blocking and generally *reactive* fashion.

In this talk I'll introduce you to a new, fully-featured Reactive Streams infrastructure toolkit for Scala, called "Swave", which has been built from scratch with a special focus on maximum performance, a simple and powerful API as well as minimal dependencies.

We'll look into the general design approach, feature set and core implementation choices as well as basic benchmark and performance figures.

We'll also contrast with other Reactive Streams implementations and highlight pros and cons from a user's perspective.

So the next time you are reaching for a Reactive Streams toolkit you'll have one more choice to pick from.

The Eff monad, one monad to rule them all

Monad transformers are a neat way to compose effectul computations: pass some configuration, read/write from disk, track errors...

However they can be a bit cumbersome to deal with, especially if you want to use different stacks sharing some common effects: for example a stack to interact with AWS and another one for Hadoop computations.

This talk will shortly introduce monad transformers in Scala and their drawbacks then present the Eff monad.

The Eff monad has some really interesting properties:

• effects can be developed completely independently from each other
• effects can be interpreted in different ways and the interpreters can be composed together
• it is based on an efficient "Free monad" (avoiding the issue of quadratic flatMaps)
• with the Eff monad you will never have to re-implement the Monad operations (point / flatMap) again!

Incremental compiler: taming scalac

In the wild, Scalac is an enormous beast. When run freely compilation takes ages even for simple changes in your project. Luckily, in the end of stone age of scala tooling first incremental compilers emerged and time spent on scala compilation’s become less and less noticeable...

In this talk I want to explain what incremental compiler is and how it works in sbt world. Further down the road I will show how name hashing reduces amount of compiled files. In the end we will ask ourselves if we can do any better (and by what cost).

akka-cluster-etcd

Modern container-based cluster computing frameworks like Mesos, Kubernetes, or EC2 Container Service usually execute services on nodes not known beforehand. This creates a problem for Akka Cluster deployments, where seed nodes need to be established.

In this talk we present a zero-configuration deployment scenario for Akka Cluster using etc.d as a distributed configuration store.

Lift framework in 30 minutes

In 30 minutes I want to build a full blown web app based on Lift framework.

Shapeless ? Easy !

Shapeless is known for being difficult to grasp, even for experienced Scala developers. In this talk, I will do my best to show you that this difficulty is somehow overrated.

Of course we'll only scratch the surface there. But hopefully, you'll take home enough hints to begin your own exploration of what this powerful tool enables.

IOT, timeseries and prediction with Android, Cassandra and Spark

IOT has a massive potential and its impact in our daily life is important. Here is an exemple of using a connected object and analysing its data: we'll see how to collect data using the accelerometer sensor of your smartphone. Then, we'll store it in Cassandra as a Timeseries model. Finally, we'll analyse those data and predict the activity with Spark. We will see a live demo on stage to show this solution working in realtime.

Making sense of initialization order in Scala

In this talk we will discuss in detail the current object initialization order scheme in Scala.

Though a fundamental and seemingly basic feature, the order in which class fields are initialized is often a source of bugs and frustration for users. We will demonstrate how apparently-innocent changes can lead to surprising behavior at runtime.

Workarounds already exist in Scala—early initializers and lazy vals—and alternative compiler implementations could enhance the the safety guarantees provided at compile-time. We will look at some of these possibilities and will briefly discuss potential changes to initialization order in Dotty.

Cool toolz in the Scalaz and Cats toolboxes

In this talk we intend to show that the two libraries: Scalaz and Cats widely held to be cryptic, hermetic and full of scary Mooonads in reality contain lots of easy to use components ready to be embeded in your code to make it shorter, clearer and easier to maintain. We will look at certain constructs from pragmatic point of view as just "Design Patterns" that happen to match ideally functional programming style.

Contract First, Session Types Later!

This talk's about how actors should communicate with the outside world as expressed in Joe Armstrongs proposed Erlang implementation of "UBF", the "Universal Binary Format" specification, a paper that let to the concept of Session Types. What are Session Types? What kind of a safety do they provide? We'll demo how "Session Types" can be unified with real world RESTFul applications, in an almost typesafe way.

Scala SWAT: Tackling 1 Billion Member Social Network

Enabling blazing fast search on a 1 billion member social network demands special weapons and tactics. Let me take you on a journey around the edges of existing technologies. I'll tell you how we took advantage of the Scala ecosystem and modern tools to realize persistence and processing of such a data set.

About this conversation:

Case study focused on the client requirements and tools we have made use of to meet them. Thoughts, injuries and ideas about real life fast & big data challenge brought to you directly from the trenches.