There are (at least) two ways to solve the problem, which are quite popular: free monads and the tagless final encoding. Both are equivalent in expressive power, but are radically different when it comes to code.

In this live-coding talk, you will learn how to transform a simple application which relies on Futures into more generic forms, using either the free monad or tagless final. You will discover how these two representations compare in terms of boilerplate, readability, composability and stack-safety. You will also explore which approach might be a better fit for selected use-ca

Akka is a toolkit for building highly concurrent and distributed applications on the JVM using the actor model. Given the prevalence of frameworks over toolkits and models in the industry, it is easy to forget that the former will not prevent you from using them in any way you please – including ways that are possibly suboptimal or perhaps even harmful.

In this talk you'll learn about a few of the most common anti-patterns related to Akka usage. You'll also discover alternative and more appropriate solutions to use for each one of those anti-patterns. It should be noted that these suboptimal uses of Akka are not merely theoretical ponderings but real and recurring observations that the speaker made during a range.

Do you throw away static types and go dynamic? Of course not! You have to change the level of abstraction in our code. In this session you will explore this process, working through a real-life example of switching from domain-specific static types to a composable data description language. How do you keep your code boilerplate-free? How do you maintain correctness? And how do you write expressions that operate on data for which you don't have simple static types? Come along for answers to these questions and more.

In this talk, you will explore a real world use case combining typeclasses, literal types, shapeless and scala.meta to program the type-system to understand and validate simple SQL queries.The resulting solution will ensure they match a given schema without requiring a database connection!!

The code examples are based on Troy, an open-source Cassandra driver which allows developers to paste raw queries within Scala code in a way such that they get compile time schema validation and derivation of case-class marshallers for free.

The talk targets established Scala developers who would like to know more about advanced Scala features and libraries. You will learn how to program the type system, use HLists, and augment all of that using a pinch of scala.meta on the top!

Have a sneak peek at the code examples here.

During this talk, you will explore the general principles of Category Theory in a pragmatic, non-mathematical way. You will discover practical examples of how this theory has managed to simplify and solve common challenges that we encounter in our code daily, such as nullable values, error handling, parallel and sequential operations and data validation. Also, you will learn how to apply them to create our own category theory library from scratch with scalacheck as the only dependency.

Functional programming in a statically typed language provides a great substrate for evolution of compositional domain models. The typesystem allows you to define your domain model as an algebra comprising of domain entities as algebraic data types, domain behaviors as functions and domain rules as the laws of the abstractions. You will learn how to approach domain API design through the algebra of types that not only make the APIs statically verifiable but also employ techniques to encode quite a bit of domain logic as part of the API itself.

You will discover Scala as the implementation language, though the techniques discussed will be equally applicable for any functional language with a powerful type system.

During this talk, you will explore the various dimensions of the model evolution starting from inception of the APIs, going through the lifecycles of composition and refinement of the APIs and finally making them resilient through exception handling and effect tracking. Here are some of the design techniques that you will discover:

1. Domain API evolution through the algebra of types

2. API refinement using techniques like phantom types

3. API composition through algebraic structures like monoid and monad

4. Domain error handling through types

5. Effect handling through types

6. Modularization using techniques like free monads and tagless final

However, this has come at the cost of sometimes excessive compile times, is complicated by seemingly intractable issues relating to the relative priority of type class instances, and is dependent on macros and compiler internals which are unlikely to be portable to Scala compilers other the Lightbend compiler or the very closely related Typelevel Scala compiler. As Dotty and other alternative Scala compilers mature this last issue is becoming increasingly urgent.

In this talk I will give a preview of work that I have been doing recently with Lightbend's support to address these issues: a combination of new Scala language features, compiler performance improvements and new derivation implementation techniques. What you will take away is a sense of how much is possible when we don't restrict ourselves to working within current Scala but also look to changing Scala to better support the way we want to work with it.

In Functional Programming in general and in Scala in particular, we have many data types that model those general programming aspects. In DDD terms, you could say that they model the ubiquitous language of simple computations.

In this talk, you will explore and analyze a few well-known data types in Scala (Option, Either, Cats Validated, etc) and try to understand them from a Domain-Drive Design perspective. You will also discover some code samples to illustrate how they can be abused and how you can refactor them by creating new data types.

In this talk, you will discover the problems with existing approaches and how you might improve upon them. Practically you will learn how you might make some major or minor changes to your codebase to make it easier to maintain through greater clarity and composability.

You will be exploring the tools and options available to you when tackling this issue, while weighing up the pros and cons of each. In particular taking a deep dive into:

• Appropriate usage of Either and EitherT

• The Error handling implications of Futures and Tasks

• When ADTs are your friends.

Freestyle is a library that empowers stack-safe purely functional applications and libraries that support parallel and sequential computations where declaration is decoupled from interpretation.

Freestyle encourages programs built atop Free algebras that are interpreted at the edge of your application ensuring effects are localized and performed in a controlled environment.

Applications built with Freestyle can be interpreted to any runtime semantics supported by the interpreter target type.

During this talk you will discover the so-called optic algebras, namely APIs that distill the algebraic essence of optics, and allows you to describe the data layer of your system in such a way that it can later be interpreted into particular data infrastructures -including, but not restricted to, immutable data structures.

You will then learn how optic algebras are implemented as natural transformations, which become essential to enable composability, analogously to the composition benefits that emerge with van laarhoven or profunctor representations at the in-memory level.

Finally, you will explore the architecture of Stateless, a Scala library that collects optic algebras and utilities to deal with them.

During this talk, you will learn how a very simple idea of how to test with minimal effort if your Akka application is resilient in case of persistence failures. Chaos testing is very broad and complex topic. If you would like to test your application against one specific point of failure, it may be too expensive to use standard chaos testing techniques. In case of persistence failures you will discover how to use "ChaosJournal" - journal that randomly fails.

You will explore a simple case study, practical advices, ideas and pitfalls. The talk will be about testing, not how to prevent loosing messages itself. Similar techniques may be used for testing against eg. remoting failures.

Apache PredictionIO also provides various engine templates and you can choose an engine template that matches your use case the best. In this talk Takako will show you how to start by using the official templates.

The tool aims to ease the life of developers by making installation of their favourite tools a seamless process. No more hacking of PATH and HOME environment variables! We support most versions of Scala, SBT and Activator at this time.

Marco's team believes in eating their own dogfood, and SDKMAN itself is backed by Scala, with all it's API microservices written in your favourite weapon of choice!

Phantom Types have been used in functional programming for many years, but the recent addition to Dotty realises this feature in a novel way through the introduction of dedicated universes. Phantom Types enable data to be modelled with invariants that might otherwise be difficult to capture and do so without incurring any run-time overhead.

In this talk you will learn what a Phantom Type is, what it can be used for (through a real-world example), and how the support for Phantom Types differs between Scala and Dotty.

Joey would also like to to credit his colleague, Gianlorenzo Fagiolo, for his contribution in this talk.

During this short session, you will learn how you can start creating custom tasks and end up with publishing community plugins. This will be based on Krzysztof's personal experience with creating the plugin sbt-flaky.

Although GitBucket is built on Scala frameworks such as Scalatra, Twirl and Slick, it's based on existing Java technologies as well. Being able to use them is a big advantage of Scala.

In this talk, you will discover GitBucket and how it's supported by Java technologies.

coursier is a CLI application and an sbt plugin aiming at making it easier to manage / fetch dependencies from Maven and Ivy repositories. In this talk, Alexandre will discuss how it can be put to profit to manage and launch CLI applications, as easily as one publishes and fetches libraries.

Using it, applications can be published to Maven Central or bintray repositories with the exact same workflow as libraries. Launching or creating launchers for these applications is then one coursier command away for your users, like for example coursier launch com.lihaoyi:ammonite2.12.2:1.0.0, to launch Ammonite, or coursier bootstrap com.geirsson:scalafmt-cli2.11:1.1.0 -o scalafmt to generate a scalafmt launcher.

Alexandre will also discuss coursier's nascent support for scala-native, allowing you to generate native applications on-the-fly from generic scala-native artifacts, as easily as it handles JVM applications.

It’s not uncommon for a project to experience compilation times of a handful of minutes, if not worse. On top of that, compilation times are unpredictable, depending on a combination of language features, external libraries, and type annotations. A single line change may increase compilation times ten fold.

Don’t bow to the compiler and accept long compilation times! Rather, join this talk to learn how the compiler works and optimize your usage of Scala to compile faster!

In this talk, you will explore in which ways cognitive biases have negative impact on your work and the code you write. In particular, you will discover how you can use functional programming to guide your everyday choices. How can you apply knowledge from psychology to your daily work as programmers, and how can this knowledge help you enhance your code? How can you gain more self-awareness about error-inducing biases, and turn them into advantages for you and your teams? This talk will answer these questions. And you’ll leave with practical knowledge about using cognitive psychology to become a better programmer – and a better human.

In this 15 minute talk, you will learn how to take your java-like exception handling and give it some scala functional twists. So try, catch, and finally, just come and listen.

In essence parts of this talk could be considered “why spark is built the way it is, why its not perfect, and how to work around our mistakes." It’s not all doom and gloom though, we will explore the new APIs and the exciting new things we can do with them with a brief detour into how to work around some of the trade-offs in the new APIs – but mostly focused on the new exciting shiny things we can play with.

A basic background with Apache Spark will probably make the talk more exciting, or depressing depending on your point of view, but for those new to Apache Spark just enough to understand whats going will be covered at the start. The presenter would of course encourage you to buy and read her books on the topic (“Learning Spark” & “High Performance Spark”), because which presenter doesn’t do that.

Even if distributed systems aren't your jam, there will be pictures of cats, gnomes, and maybe even a panda to keep things exciting. Also learning how systems like Spark have been designed and evolved can be useful to avoid our mistakes (or make you feel better about your own mistakes).

Your applications frequently consist of business logic, communication, persistence, caches & logging. You always want to keep them apart and reason about each of them individually. However, this is very difficult to achieve in practice.

Enter free monad. It lets you decouple those concerns by dividing our program into algebras and interpreters. During this talk, you will discover an application built on top of free monad in Scala & Cats. You will learn how to create pure & declarative DSLs, side-effecting interpreters and how to use them together. Then you will explore Freestyle library and show how it makes the code more concise. At the end, you will compare the free monad approach to another technique used to decouple concerns: tagless final.

In this talk, you will discover if it is worth to use serverless in our applications, what are the advantages and disadvantages of this approach. Secondly, you will explore the various use cases that were done considering serverless and what was the result. And finally, you will learn how Scala fits into this. This talk should be interesting if you are considering using serverless or just heard this word somewhere and would like to learn more. The talk is a little bit more focused on AWS but the understanding of the concepts covered should be beneficial even if you prefer a different service provider.

Taking a step back, as vigilant observers of type safety, you try to leverage the type system to ensure the correctness of your code. But when the domain constraints become too involved, constructing the appropriate types might become cumbersome.

In this talk, after introducing some basic Prolog phrased in the language of implicits, you will discover how this newfound power can free you from the burden of type construction by letting the compiler do most of the grunt work for you.

This talk uses the power of recursion schemes to predict survival on the Titanic. Zainab will show that recursion schemes can be used to grow a decision tree and make predictions from it. Furthermore, they give us far more benefits than the basic folds or unfolds we would otherwise use.

You will make use of many folds, unfolds and even refolds. Be prepared to exercise your skills in origami!

During this talk, you will explore the following:

• Thread per request vs asynchronous services

• What back pressure is and how to do it all the way down to the network layer

• How to achieve all of this with Akka HTTP and Akka Streams

• How it compares to other tools for asynchronous programming e.g. CompletableFutures, Observables

Time permitting, you will also discover a demo on a networked application sending back pressure through the application layer, through TCP and into the client application.

By Church encoding our program, you can retain the simple semantics that characterises FP code, while achieving performance that may seem out of reach in a pure FP system.

A list of concurrency related features has been added to IntelliJ IDEA. It includes the asynchronous debugger that is applicable to any concurrent framework. It includes a number of inspections for scala.concurrent library and Akka framemork. The feature we're most proud of is messages analysis that gives you an opportunity to figure out where a message has been sent from or where it can be received. All those features and usage scenarios will be shown during a live coding session.

Given that, building a good concurrent application is going to be less painful. Especially if using Akka framework.

In this talk, you will learn how to test our software better by writing integration tests using sbt configurations, Scalatest async utilities and Docker.

In this talk, you will explore the comparison between the current biggest players of the serialization world: Protocol Buffers (Protobuf), Avro, Thrift and Kryo, and also might rant a bit about Java Serialization and JSON. You will discover how integration in the Scala and sbt ecosystem works, what schema evolution is and how we deal with it and only a brief bit about performance. Bonus points are awarded for portability to other platforms, maturity and community activity. Afterwards you’ll have a solid base to decide which serialization framework is the right one for you. Expect lots of code samples!

Having its roots in the Clojure community Datomic might be perceived as something foreign from a Scala developers point of view. You will discover that the contrary is the case and there are sizeable benefits in using an immutable database of facts. There are, in fact, a couple of Scala libraries around that make Datomic a viable choice.

Expect an experience report from the battlefield of the day-to-day. During this talk, you will learn from mistakes made, benefits reaped and explore how Peter and team extended on the existing libraries to integrate Datomic better into their Play and Akka application.

You will also explore where "Polymorphic record types in a lifted embedding" dropped off, at the AST of a Slick query, and follow the compilation all the way to the SQL code generator. You will learn how the compiler works and how to work on it, for example creating test cases and enabling and understanding the debugging output you can get for them. After an introduction of the basic concepts (trees, types, symbols, etc.) we cover some interesting compiler phases and implementation details.

You will explore the similarities between writing and coding, and uses writers’ advice to identify different kinds of avoidable bad naming in code. Some class, method, and variable names are so bad that they’re funny, but you’ve still seen them in production code. The second part of the session explores practical techniques for working on better naming, including renaming things. Renaming is even harder because it includes naming things plus other hard things. The final section goes back to writing. The next step after finding better names in code is to write better comments in code, which is almost as hard as naming is.

The surprising thing about naming things well in code is not that it’s hard, but how easy it is to accept bad names. This is a hard problem that’s worth working on, because although you can’t make the naming problem go away, you can learn to write much better code regardless of which technologies you use.

What if you could extend this and have types that provide even stronger guarantees, for example: a String that is never empty, an Int that is always known to be positive? Refinement types allow exactly this. You refine a base type, like a String with a predicate, such as minimum length must be 5 and wherever you have a value of this refined type in your code, you can rest assured that it conforms.

In this session, you will explore the refined library and learn how to use it in practice with some popular libraries/frameworks. Together you will discover a Play/Slick example application that's strongly typed, using refinement types.

Embedded Domain Specific Languages or eDSLs allow us to build a data structure that represents the expressions of the target language. In this talk, you will discover the tagless final approach for building DSLs. You will also compare other styles of DSLs like ADTs and Free Monads and have a look at the respective trade-offs. Finally, you will build the purely functional DSL for WebGL using Scala.js and create a small, but awesome 3d app in the browser.