Functional programming is on the rise; monads are everywhere. But how to choose the right wrapper for the values which we manipulate (i.e. monad)? Quite often, the answer is far from obvious, and it’s useful to delay the decision as much as possible. Furthermore, picking a particular monad too early might only obscure important business logic details.

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

About the speaker...

Adam Warski

Adam is one of the co-founders of SoftwareMill, a company specialising in delivering customised software solutions. He codes mostly on the back-end using Scala and other interesting technologies. Adam created a couple of open-source projects, such as sttp, MacWire, Hibernate Envers and ElasticMQ. He has been a speaker at major conferences, such as Devoxx, JavaOne, LambdaConf and ScalaDays.

Apart from writing closed- and open-source software, Adam is interested in improving the way we use functional and object-oriented programming.

He is also writing a technical blog on a variety of interesting IT-related subjects.

You can follow Adam on Twitter here, or take a look at SoftwareMill.

CAUTION: If you are responsible for an Akka system deployed to production, attending this talk may cause intense moments of self-doubt, stress and possibly panic.

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.

About the speaker...

Manuel Bernhardt

Manuel Bernhardt is a passionate engineer, author, speaker and consultant who has a keen interest in the science of building and operating networked applications that run smoothly despite their distributed nature. Since 2008, he has guided and trained enterprise teams on the transformation to distributed computing. In recent years he is focusing primarily on production systems that embrace the reactive application architecture, using Akka, Play Framework, Scala and Java to this end.

Manuel likes to travel and is a frequent speaker at international conferences. He lives in Vienna where he is a co-organizer of the Scala Vienna User Group. Next to thinking, talking about and fiddling with computers he likes to spend time with his family, run, scuba-dive and read. You can find out more about Manuel's recent work here.

Static types are fantastic for ensuring code quality, but rather annoyingly they have to be defined at compile time. What happens when you need to determine the structure of your data at run time, for example when you have to load schemas from a database?

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.

About the speaker...

Dave Gurnell

Dave is a developer, trainer, and partner at underscore.io. He has spent over a decade programming, speaking at conferences, and writing books on functional programming.

In his spare time he enjoys making maps, playing with cats, and taking short trips in his space ship.

This talk will be an interactive session of writing code, with no slides, to create a basic physics simulation using Scala JS. Starting with a fresh project, youwill create a small Javascript application which allows objects in motion to interact with themselves and their environment. The project will be driven by types, to help create a model of the world, and should show the awesome power of Scala and Javascript working together.

About the speaker...

Noel Markham

Noel started out as a Java developer in finance before moving to functional programming in startups for both games and social media. More recently, he has worked in broadcast media.

Follow Noel on Twitter

Akka has become a very successful platform for building reactive systems. At its core the akka-actor module implements the actor model as created by Carl Hewitt et al. Surprisingly enough, although Scala and Java are type safe languages, Akka actors are untyped. This means that we can send Any message to an actor even though this will only handle specific ones – the compiler is not able to help us. Fortunately rescue is at hand in the form of Akka Typed. In this talk we introduce its API, discuss differences between the "old and new" world and show options for migration and integration.

About the speaker...

Heiko Seeberger

Heiko Seeberger loves rock climbing and is an internationally renowned expert on Scala, Akka and Functional Programming. He has more than twenty years of experience in software engineering, consulting and training and is an active open source contributor. Heiko works as an independent consultant and regularly shares his knowledge at conferences and user group meetings.

Heiko tweets as @hseeberger and blogs under heikoseeberger.rocks.

Scala has a rich static type system which provides powerful features such as implicits and typeclasses.

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.

About the speaker...

Tamer AbdulRadi

Tamer is a Senior Software Engineer at Disney Streaming Services, building and maintaining distributed systems armed with nothing but Scala, types and the power of functional programming.

Check Tamer's posts at abdulradi.com.

Category Theory has become one of the hot topics in our community. Why is this theory suddenly so interesting for developers? Why are the cool kids talking so much about it?

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.

About the speaker...

Daniela Sfregola

Daniela Sfregola is a Software Consultant based in London, UK. She has worked as Java developer before moving towards Scala.

She is an active contributor to the Scala Community and a passionate blogger at danielasfregola.com.

Scalafix is a rewrite and linting tool for Scala. Initially born for migrating Scala 2 code to Dotty, it has now become general purpose and it's being adopted by library authors and development teams. In this talk, you will discover where Scalafix is positioned in the universe of Scala tooling, what it can do for you and how to write your own Rules for fixing and linting your code.

About the speaker...

Gabriele Petronella

Gabriele is co-founder of buildo, where he’s a software engineer, working with Scala and TypeScript. He founded the Scala User Group in Milan and he’s one of the organizers of Scala Italy, the Italian conference on Scala. In the - rare - free time, you’ll find him on a plane or at the basketball court.

Shapeless has led the way on automatic type class instance derivation since the arrival of the TypeClass type class back in 2013. Since then this mechanism has evolved through the introduction of the Lazy type which allows the most general form of type class derivation currently available in Scala. This is what forms the basis for a whole host of automatic and semi-automatic derivations in a wide variety of libraries.

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.

About the speaker...

Miles Sabin

Miles has been doing stuff with Scala for more than ten years, currently with Underscore Consulting. He is a cofounder of Typelevel and his best known project, the Scala generic programming library shapeless, is the weapon of choice wherever boilerplate needs to be scrapped or arities abstracted over.

Head over to Miles' blog, check out his projects on GitHub and follow him on Twitter @milessabin.

Morgan Stanley has developed a technology that allows the widespread automatic parallelisation of execution. James and Gjeta are part of a team who, using the Scala language and ecosystem, have built a runtime that automatically parallelises users’ Scala code. During this talk, you will discover how code can be written with no concern for parallelism and automatically executed on multiple cores. Similar in aims to Twitter’s Stitch framework, this approach attempts to achieve the same goals without use of for-comprehensions. You will learn how calls to storage and other expensive operations can be automatically grouped by the technology. You will explore how it was built using Scala, see live demonstrations, and hear a discussion of the theory behind the practice. The system is battle-tested in a project comprising of hundreds of devs and millions of lines of Scala code. The technology has been in development for six years and this will represent the first public discussion of it. This talk will cover purely a description of the technology that has been built.

About the speakers...

James Belsey

James has been working on this Scala-based project for six years and is a Scala Center member. Part of the sponsorship process for the initial work on Slick and ongoing work on performance of the core Scala compiler. He has had numerous other engagements with Scala.

Gjeta Gjyshinca

Gjeta is a project engineer working for the last year in the core technology of the project. She has been profiling applications to identify reasons for cache misses and concurrency bottlenecks. She has also been tracking and analysing efficiencies across the codebase and including caching of bitemporal database queries for optimal reuse.

Domain modelling in software is never pure. Next to the domain data and business logic there is a whole other universe of programming language constructs that we have to deal with (control structures, error handling, asynchronous computations, etc).

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.

About the speaker...

Renato Cavalcanti

Renato is a software developer at Lightbend where he works in the Lagom Framework Team. Scala aficionado since 2009, he has been hacking in Scala and related technologies for fun and profit. He has a special interest for Event Sourcing/CQRS, DDD and Microservices Architectures. He's the founder of BeScala (Belgian Scala User Group) and maintainer of Lagom Framework.

Check out BeScala

If you've ever been bitten by a completely unexpected RuntimeException then you've been affected by Hope-Driven Development. If you've ever had to trawl through the source code of the function that you're calling in order to work out what might happen when you call that function, then you'll realise the value of being able to trust a piece of code to do exactly what it says it will do. You would like to know that the code that you call is simple to understand without having to understand the internal workings, and that it will work exactly as expected,*

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.

About the speaker...

Andrew Gustafson

Gus previously worked as a java developer in finance and media, experiencing all of the delights that come with over-engineering a large XML-configured application. He has spent the last few years writing scala apps and playing buzzword bingo in startups. Currently he is a Senior Scala Developer/Technical Architect at Depop, a social selling app.

Follow Andrew on twitter.

Check out Depop at http://www.depop.com/

Blockchain is the current hype in tech. People believe its impact in companies will be of the same magnitude as the event of internet. But, what is Blockchain itself? In this talk, you will discover a blockchain from scratch, using Scala, to understand its capabilities and limitations. That blockchain will be used to built a digital currency on top of it. And you will explore other possible uses of a blockchain.

About the speakers...

Kingsley Davies

Kingsley is a Partner at Underscore consulting, and has spent nearly two decades designing, developing and supporting large scale systems for a number of clients including, Betfair, the BBC, Barclaycard and others that don't start with a B ;-)

While working to make things better, he’s seen a steady evolution towards functional programming, a sharper focus on development operation teams and tools and decomposing big things into smaller composable things commonly called services.

Most recently he's also dived into the ethical tech and tech for good pools and is keen to encourage and support initiatives in these areas.

Pere Villega

Pere is a software developer originally from Barcelona. Passionate about technology and a Scala fan, he has spent over a decade programming, writing blog posts, and for the last few years has grown an interest on functional programming.

Deciding the return types of independent sections of your code base is a complicated and extremely important part of developing in Scala. You want each module to be self contained and descriptive while remaining composable with each other. A difficult balancing act.

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.

About the speaker...

Benjamin Parker

Ben Parker is a scala developer with ITV, working in a microservice architecture on a team dedicated to personal user data and ITVs premium offering. Fanatical about friendly clean code and high-functioning teams.

Programming in Scala is sometimes very time consuming. Finding the most efficient way to solve a problem can end up in days of frustration. During this talk you will discover a story of trial and error with a twist at the end. It’s a story of API endpoints, generic programming, Shapeless and what happens when they all come together. Everything with examples and plenty of code.

About the speaker...

Maria-Livia Chiorean

Maria-Livia joined the Guardian in September 2015 as a graduate software developer. Since then, she has been working with 3 different teams within the company and collaborated with many others, she has been learning Scala and contributing daily to making quality journalism easy to produce and consume.

During this talk, you will discover the current Features available as of Freestyle 0.4.2 Including Freestyle RPC, a new module to build purely functional microservices.

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.

About the speaker...

Raul Raja Martinez

Functional Programmer. Co-founder & CTO @47deg. Scala Center Advisory Board. Check out Freestyle here and also maintains Kategory. Type of a Higher Kind .

Optics (Lens, Traversal, etc.) are great abstractions that allow you to carry out complex state transformations using high-level design patterns. However, current optic libraries are restricted to work with in-memory data structures. In fact, this limitation might be one of the causes why optics are still fairly unknown by the community. Ideally, you should be able to exploit the optic expressiveness and composition capabilities when application state is handled, for instance, through relational databases, event sourcing or web services.

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.

About the speaker...

Jesus Lopez Gonzalez

Jesus is a PhD student at Habla Computing (Madrid), where he tries to take academic functional programming knowledge to the development of real-world systems in industry.

Akka doesn't guarantee message delivery, especially for remoting or persistent actors.

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.

About the speaker...

Piotr Śliwa

Piotr is a software developer living in Kraków, Poland. He is working now for Ocado Technology, making things work in automated warehouse eg. thanks to actor-based software.

Apache PredictionIO can be installed as a full machine learning stack, bundled with Apache Spark, HBase and Elasticsearch, which simplifies and accelerates scalable machine learning infrastructure management.

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.

About the speaker...

Takako Shimamoto

Takako has been programming in Scala since 2012 and has written a few Scala books in Japan. She is also a PMC member.

SDKMAN! is a tool for managing parallel versions of multiple Software Development Kits on most Unix based systems. It provides a convenient Command Line Interface (CLI) and API for installing, switching, removing and listing Candidates.

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!

About the speaker...

Marco Vermeulen

Marco Vermeulen is a South African Software Developer who works and lives in London. He is passionate about writing well crafted code, driven and guided by tests. As a proponent of BDD, he has successfully applied this technique in the Enterprise as well as on Open Source Projects. He is an avid supporter of OSS and is the creator of SDKMAN, the Software Development Kit Manager.

Follow Marco on Twitter and check out SDKMAN!.

The Dotty platform comes with a host of new and revised language features that aim to simplify the Scala landscape. In this talk you take a brief look at one such feature: Phantom Types.

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.

About the speaker...

Joey Capper

Joey is a software developer at OVO Energy using functional programming and Scala to solve problems in the wild. Before that, Joey completed a Ph.D in typed functional programming

Sbt offers a lot of functionality out of the box. A bigger advantage is the ease of creating custom tasks and plugins. Sbt has a high entry threshold but extending builds is easy.

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.

About the speaker...

Krzysztof Otrebski

Krzysztof is a software developer with 10 years of professional experience. Having spent many years on Java programming and problem solving, he has developed useful tools that make a programmer’s life easier. He is also a founder of a few open-source projects.

Follow Krzysztof on twitter.

GitBucket (https://github.com/gitbucket/gitbucket) is a Git centric web based integrated software development platform like GitHub, BitBucket or GitLab. It is one of most popular applications written in Scala which got 6700+ stars on GitHub and many users over the world.

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.

About the speaker...

Naoki Takezoe

Naoki works for BizReach, Inc in Tokyo, Japan. He has over 6 years Scala experience, and author of some books and articles about Scala in Japanese. The latest work is the Japanese translation of "Scala Puzzlers". Creator of GitBucket / Committer of Scalatra and Apache PredictionIO

The latest work is the Japanese translation of "Scala Puzzlers".

Creator of GitBucket / Committer of Scalatra and Apache PredictionIO

Up to now, Scala has seen a lot of adoption on the server side. But JVM warm up is not that a problem in many cases, and with scala-native around the corner, Scala is undoubtedly about to become a language of choice for CLI applications! Yet, packaging a CLI application is not as straightforward as publishing libraries. One has to chose how to package the application (jar, deb, OS X or Windows installers, ...), how to publish these packages, on which servers, etc.

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.

About the speaker...

Alexandre Archambault

Alexandre Archambault is currently working with Criteo. He has been solving data related problems and doing math with Scala professionally since early 2013, and has been contributing regularly to shapeless since mid-2014.

Follow Alexandre on twitter.

You love Scala, but the one aspect you have a hard time accepting are long compile times.

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!

About the speakers...

Iulian Dragos

Iulian Dragoș dreams about a world where the Scala programming language is the default choice for new projects. He learned Scala by writing the compiler backend for it during his PhD at EPFL, back in 2004, and he was the first employee of Lightbend (formerly Typesafe). At Lightbend he helped the company grow from 5 to 85 employees, playing the role of engineer, technical lead, consultant, trainer or sales engineer. Iulian is a frequent speaker at conferences and actively contributing to several open-source projects.

Mirco Dotta

Co-founder of a stealth mode startup aiming at revolutionising Scala developers' life. Mirco has 10+ year experience with Scala, and also has extensive knowledge on Akka, Lagom, Playframework, and Sbt. Before founding his own company, he worked at Lightbend (formerly known as Typesafe), where he wore different hats: from engineering, to consulting, and (fun fact) even sales! He is a certified Lightbend trainer for Akka, Playframework, and Scala. He loves meeting people and sharing experiences, so don't hesitate to say hi when you see him. In his freetime, he plays chess and studies wine - both theory and practice! :)

You can find him on twitter at @mircodotta

As programmers, you want to write high-quality code that doesn’t contain errors. This means that you need to use a considerable amount of logic in your daily work. But you're not only programmers, but also humans. As such, you’re not purely logical, since you only possess a limited reasoning process – and you’re full of cognitive biases. Thus, you tend to rather use heuristics to simplify problems, which introduces errors in your code. – All of this while you're trying to deal with machines that are highly rational.

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.

About the speaker...

Silvia Pina

Silvia Moura Pina is a software engineer working primarily with Scala. She has studied computer science and psychology and she's always interested in bringing up topics that intertwine the two fields.

Ever looked at your exception handling and wondered, "wow this looks a lot like java"? Write Jala no more!

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.

About the speaker...

Netta Doron

Netta's career spans 10 years, 3 companies, and 3 languages. Fortunately, the last four years have been spent at Wix, working in Scala. Her love of clean coding and TDD have helped her build microservices in Scala that run Wix Pro Gallery and Wix Photo Albums. She has two wonderful kids, who don't yet know Scala, and a wonderful husband, who although wonderful, doesn't want to hear another word about that Scala thing.

In this talk, Mohamed will introduce Prometheus, highlight its advantages and disadvantages as a monitoring tool, then share with you how you can get started in 5 minutes.

About the speaker...

Mohamed Menaa

Mo is a developer currently working at Ocado Technology as a tech lead where he makes automated warehouses whizz as efficiently as possible.

You will learn how to cut your applications into isolated, independent pieces using Freestyle library with free monads or tagless final style. The session is based on a multiplayer, purely functional version of Prisoner’s Dillema.

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.

About the speaker...

Michał Płachta

Polyglot software engineer specialised in developing distributed applications. Functional programming enthusiast. Loves the human component in software projects. Drinks a lot of tea. Has a blog at michalplachta.com. He currently works as team leader at Ocado Technology, where he is building actor-based software for automated warehouses.

Serverless is a hot topic in the software architecture world and also one of the points of contention. Serverless can let you run our code without provisioning or managing servers. You don't have to think about servers at all. Things like elasticity or resilience might not longer be our problem anymore. On the other hand, you have to embrace a little bit different approach how to design our applications. You also have to give up a lot of control we might want and the most importantly you have to use technology which just might not be ready.

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.

About the speaker...

Petr Zapletal

Petr is a Consultant who specializes in the design and implementation of highly scaleable, reactive and resilient distributed systems. He is a functional programming and open source enthusiast and has expertise in the area of big data and machine classification techniques.

Petr participates in the whole software delivery life-cycle: from requirement analysis & design through to maintaining systems in production. During his career, Petr has worked for various companies, from start-ups to large international corporations.

Technically, Petr is SMACK (Spark, Mesos, Akka, Cassandra, Kafka) evangelist. Petr enjoys working with Akka and has deep knowledge of toolkit’s features like Akka Clustering, Distributed Data or Akka Persistence. Petr is also certified Spark Developer.

Follow Petr on @petr_zapletal.

It has been known that Scala's implicits allow one to write Prolog-like programs that run at compile time. And although letting the compiler solve your daily Sudoku puzzle for you is fun, how could that possibly be useful in an actual program?

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.

About the speaker...

Daniel Beskin

Daniel is an FP-biased developer with a thing for (esoteric) programming languages.

Stream processing is a hot topic today and it’s easy to get lost among all the possibilities. In this live coding session, you will explore the Reactive Streams approach used by the Monix project - one of the Scala implementations of the Reactive Streams concepts. On an almost real-life example, you will discover both the basics and some more advanced usages of the library.

About the speaker...

Jacek Kunicki

Jacek is a passionate software engineer living in the JVM land - mainly, but not limited to. He also tends to play with electronics and hardware. When sharing his knowledge, he always keeps in mind that a working example is worth a thousand words.

Recursive data structures are a core tool of any functional programmer's toolkit, but they are also one of the most challenging. Budding functional programmers are plagued with nightmares of infinite recursion, mental stack overflows, and the terrifying fixed point. Recursion schemes, generalised folds and unfolds with exotic names and signatures, are a further hurdle to overcome. But past this hurdle there are many rewards.

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!

About the speaker...

Zainab Ali

Zainab is a functional programmer. She is the author of Libra and a contributor to many functional Scala libraries, such as cats and fs2.

What does it means for our programs to be asynchronous and back pressured and why is it so important for scalable services?

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.

About the speaker...

Christopher Batey

Christopher is a Senior Engineer at Lightbend. He is currently on the core Akka team responsible for developing Akka (https://akka.io/), Akka Http, Akka Streams, Reactive Kafka and Alpakka (https://github.com/akka/alpakka). He has previously built trading systems, online television platforms and worked extensively with Apache Cassandra. Likes: Scala, Java, the JVM, Akka, distributed databases, XP, TDD, Pairing. Dislikes: Untested software and code ownership.

Check out Christopher's blog or follow him on twitter.

In this talk, you will explore an underappreciated tool, Church encoding, that allows you to combine the best parts of FP and OO.

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.

About the speaker...

Noel Welsh

Noel is a Scala consultant at Underscore, where he helps people produce better code using Scala. He has a background in machine learning, and an abiding passion for turning his current interests into conference talks.

No doubt that almost every application is multi-threaded nowadays. But building a good one is still a big deal. For example frameworks (that were actually supposed to make the concurrent programming easier) became quite complicated themselves. So now it's IDEs' turn.

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.

About the speaker...

Andrew Kozlov

Andrew has been a JetBrains employee since graduating with a B.Sc. degree in Computer Science. After falling in love with Scala joined the Scala plugin team. Currently is working on Akka and Dotty support in IntelliJ IDEA. Besides programming is interested in public speaking: has participated in several conferences (including ScalaDays), has been teaching programming courses for high school and university students for more than 5 years.

Writing asynchronous code is often an uneasy fit for a language like Scala. While high-level constructs like Futures facilitate asynchronous programming, syntactic limitations often make blocking or the unchecked access of asynchronously-computed values more natural than the safer alternatives.

In this talk, you will discover Impromptu, a lightweight Scala API for safely defining and executing graphs of dependent tasks, avoiding blocking and preventing access of not-yet-completed values, guaranteed the type system.

You will use a combination of several advanced type-system features to encode a task's dependencies, then use these types as constraints to restrict access within a task only to the results of dependent tasks which are known to have been completed. You will further take advantage of Scala's type inference to avoid polluting the code with cumbersome type ascriptions. This gives you very lightweight and natural syntax, without blocking or unsafe access.

During this talk, you will explore how Impromptu is implemented, and learn how dependent types allow the framework to be written in just 30 lines of code, and show how a similar approach may be used to concisely implement typed actors.

Furthermore, you will take advantage of current research into implicit functions in Dotty to remove the small amount of remaining boilerplate from Impromptu task definitions.

About the speaker...

Jon Pretty

Jon has been having fun riding the bleeding edge of Scala for over a decade, and he's not finished yet.

While he's not travelling the world attending Scala conferences, or organizing Scala World, Jon spends his time working on a variety of open-source Scala libraries, and providing professional Scala training services.

Follow Jon on Twitter here, or check out his website.

Unit tests help you to write software that adheres to a certain sets of requirements, expressed as tests. However, they focus on testing units of software in isolation and not so much on how major parts of a system are integrated. Integration tests fill this gap, and they are an important part of every continuous delivery pipeline, adding extra confidence before shipping to production.

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

About the speaker...

Emanuele Blanco

Emanuele has been writing code for almost a decade, beginning with Java then slowly moving to Scala, for fun in 2011 and for profit in 2014.

In the past, he has been actively involved in the organisation of the London Software Craftsmanship Meetup, which aims at raising the bar of professional software development. He is currently Lead Developer at Moneyfarm, and he maintains this github. You can follow Emanuele on Twitter @manub.

In this talk, you will discover how to leverage Scio, the Scala API for Apache Beam and it’s module scio-tensorflow to integrate Deep Learning into your batch or streaming data pipeline. You will explore the core concepts of Apache Beam, a quick tour around Scio Scala API and then illustrate TensorFlow integration with a practical use case of natural language processing for automated phone support.

About the speaker...

Vincent Van Steenbergen

Vincent Van Steenbergen is a Senior Data Engineer who’s been working on Big Data projects using Machine Learning (recommender system, fraud detection) and more recently Deep Learning (voice analysis, natural language processing). He regularly speaks at international conferences and meetups about Big Data tech stacks such as Scala, Akka, Spark as well as Machine Learning and Deep Learning.

ScalaC is getting faster. Performance was a primary theme in 2.12.3. Whilst it may not have hit '10 times faster' we are approaching 50% faster and there is potential to go even faster. During this talk, you will explore the progress made by Lightbend and the community and explore the future of making it even faster.

About the speaker...

Rory Graves

Rory spends his life fighting to find a balance between writing ugly high performance code and beautiful maintainable code. He fights from the trenches to make software better, contributing to open source and has has worked across the entire gamut of software from building a JVM to optimising grid computing.

Follow Rory on twitter.

Decoupled applications exchange messages – between JVMs, over the network or via messaging systems like Kafka, Pub/Sub and Kinesis. Therefore messages are everywhere – sometimes they live for milliseconds, sometimes they get persisted for years. When the types of these messages start to evolve and the applications change at different speed, things get complicated: serialization protocols can help you with that!

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!

About the speaker...

Christian Uhl

Christian is an expert for Search, Big Data topics and a passionate Scala developer who has been using scala in various projects throughout the last three years. He is especially interested in distributed systems, microservice architectures and always curious about how all these pieces fit together.

Using a toy language for declarative infrastructure, this talk will explore functional programming techniques for writing domain specific languages. The talk will start with a single function and demonstrate how to use ADTs to write an embedded DSL and interpreter. You will then discover parser combinators, a monadic DSL for parsing. You will use them to write an interpreter, then extend our program to compile the language into shell commands. As time permits, you will explore different paths forward for your DSL – you will learn some shortcomings of our embedded DSL and how they motivate the Free monad. You will also discover the motivation for data-types a-la-carte and recursion schemes.

About the speaker...

Daniel Porter

Check out Daniel's website here.

Datomic is a relatively new and exiting entry into the database world. Its combination of the read-scalability of a NoSQL solution, the consistency guarantees known from traditional relational databases and a powerful query language is only one reason to take a closer look. No matter whether you are building microservices or a monolithic application, its flexible architecture fits nicely into a reactive Scala stack.

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.

About the speaker...

Peter Brachwitz

Peter is a historian turned software developer. He is spending most of his days writing software in Scala. After work he enjoys exploring new programming languages and organizes the Vienna Clojure user group.

During this talk, you will discover an introduction to Slick's query compiler. Nowadays Slick has many contributors who have worked on different areas of the codebase, from fixing simple documentation bugs to changing intricate details of the asynchronous execution engine. However, only few people venture into the query compiler (which Stefan considers the most interesting part of Slick's implementation). I hope this talk can help to make it more accessible. Slick, SQL, Compiler

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.

About the speaker...

Stefan Zeiger

Stefan Zeiger is a member of the Scala compiler team at Lightbend. He was the tech lead for Slick since 2011 and the creator of its predecessor, ScalaQuery. He has been a user of Java and the JVM platform professionally since 1996, working on a diverse range of projects from web servers to GUI frameworks and programming language design, and moving on from Java to Scala since 2008. He is a frequent speaker at ScalaDays and other conferences.

Developers can get better at their craft by learning from the great writers who mastered theirs. Writing software isn’t the same as writing a novel, but there are parallels. Besides, advice from writers is better because writers have been struggling with their craft for many centuries, not just a few decades. It’s better-written as well. During this talk, you will discover great writers’ best advice for coders: Stephen King on refactoring, Anne Rice on development hardware, Hemingway on modelling with personas, and Neil Gaiman on everything.

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.

About the speaker...

Peter Hilton

Peter Hilton is a software developer, writer, speaker, trainer, and amateur musician. His professional interests are business process management, web application development, functional design, agile software development and documentation. Peter currently consults for Signavio in Berlin, remotely from Rotterdam where he has lived since January 2000. Peter regularly presents at developer conferences and provides the occasional training course.

When you first learn scala, coming from another language such as Java, you'll probably fall in love with the Option type. This type protects you from bugs because you know that the value wrapped in an Option might be absent and if you have a plain value, you know it will never be null.

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.

About the speaker...

Peter Mortier

Peter is a well seasoned freelance developer, who still vividly remembers the birth of the JVM. Currently he's exploring the field of functional programming in scala at the Agency for roads and traffic of the Flemish government

In functional programming you very often find yourselves wanting to use some kind of library that doesn’t really expose a functional API. That’s where embedded domain specific languages come to the rescue.

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.

About the speaker...

Luka Jacobowitz

Luka Jacobowitz is a Software Consultant at codecentric in Germany, focusing on functional and reactive programming. Always interested in trying new things and experimenting with the bleeding Edge. Usually spends his time contributing to various open source projects. Loves to travel and meet all the fantastic people living all around the world.

He is the author of the reactive UI library and you can find his cv here and his blog under lukajcb.github.io.

During this talk, you will explore a journey from the very basics and learn how Akka actor model applies properly in business logic, software infrastructure as well as in managing UI. In the end, you will discover some of the features under development and what you are trying to achieve.

About the speaker...

Andrea Peruffo

Andrea Peruffo is an all-around software developer with hands-on experience in delivering any kind of software system from large scale cloud to embedded devices.