In this talk I will explain what binary compatibility means in the Scala context and why it poses such a problem. I will then put forward a possible solution that relies on a new high-level interchange format of typed trees.

• Fully asynchronous and non-blocking
• Reactive-Streams enabled "all the way through” (http://www.reactive-streams.org/)
• Flexible and concise, yet powerful and type-safe high level APIs
• No external dependencies
• Completely written in Scala, no wrapping of Java libraries
• Deeply typed, immutable, case-class-based HTTP model
• Successor of spray.io

Akka-http delivers an excellent tool for connecting your Scala/Akka applications to the world.

In this session we'll look into what akka-http brings to the table, how it is used and what improvements it delivers over previous solutions. You’ll learn about best practices, what applications will benefit most from, its features as well as the general roadmap for akka-http going forward.

In this talk, Alex will draw on his experiences at Snowplow to explore how to build rock-sold data pipelines in Scala, highlighting a range of techniques including:

• Translating the Unix stdin/out/err pattern to stream processing
• ""Railway oriented"" programming using the Scalaz Validation
• Validating data structures with JSON Schema
• Visualizing event stream processing errors in ElasticSearch

Alex's talk will draw on his experiences working with event streams in Scala over the last two and a half years at Snowplow, and by Alex's recent work penning Unified Log Processing, a Manning book.

"In this talk Noel will discuss six fundamental concepts that underly effective Scala.

How can programmers quickly and effectively learn to write idiomatic Scala? This is a question Noel at Underscore had to answer when developing their own training material. They knew we wanted to go beyond teaching syntax and give developers the concepts and techniques they needed to develop Scala in a systematic and idiomatic way.

They identified six core concepts that cover a wide range of Scala programs. These concepts give programmers a reproducible way to create code -- once the problem domain is understood the code follows through a series of systematic and reproducible steps. The resulting code is robust and easily maintained.

In this talk Noel will describe these six concepts, which are:

• expressions, values, and types;
• objects and methods;
• algebraic data types;
• structural recursion;
• functors and monads; and
• type classes.

Noel will show how they let us create code in a systematic manner, and how we can go about teaching the concepts to new Scala developers. This talk should be of interest to anyone who is transitioning to, or leading a team that is transitioning to, Scala, and anyone interested in guidelines for idiomatic Scala code. "

The talk will focus on practical examples inspired by the lessons of building secure systems for the Guardian. We'll see how an example API implemented naïvely using traditional techniques can be improved when we embrace the type system and change the way we think about APIs.

We've had plenty of cool demos: type-safe Ajax calls, in-browser ray-tracing, games and reactive web-pages, but these demos were not constructed on their own! They are the head of a long chain of dependencies, more and more fundamental, until we answer the question: how do we build something from nothing?

The second part of my session will focus on IntelliJ IDEA and how to leverage your IDE for working with implicits. Among other helpful IDE features, I will show how to debug implicits in IntelliJ IDEA.

As examples we’ll take a look at a few Scala libraries, including Spray with its well-known Magnet pattern.

On top of that, during my talk I’ll show you a few new tips and tricks on how to be more efficient by using IntelliJ IDEA’s hidden gems when working with Scala. "

In this talk we'll demo the new driver and look at the patterns used to create it. You'll be amazed at how simple it is to write a whole new driver for your favourite asynchronous library! We'll look at some of the challenges in making this so and of making a typesafe Document class. You'll see that through the use of implicits we can allow simple interoperability between native scala types and MongoDB Documents.

This talk aims to show what value you can get from using Scalaz in your projects, and help you comprehend some of the unusual terminology used.

We will explore demonstrate real world use cases which make Scala stand out as a choice programming language for for building clean, beautiful, RESTful APIs with tools such as Swagger+Scalatra. Techniques will be demonstrated for producing & consuming JSON (json4s), as well as sending HTTP Requests (Dispatch), using MySQL & Cassandra, and Caching. We will also explore Scala testing frameworks, and how they plug into our larger CI/CD infrastructure, with additional discussions of Netflix OSS components.

Two case studies of commercial development projects illustrate using Play and Scala to complete development so easily it feels like cheating. Both projects were based on Play, Scala, Slick, Bootstrap and minimal JavaScript or front-end development. The lessons learned from these projects show how this architecture makes trade-offs between development cost and complexity. Best of all, there wasn’t any PHP at all.

We’ll then see how to declaratively implement an interceptor, and that it’s far easier than it may seem. Finally, we'll take a look at the “Thin Cake Pattern”, and how to use traits to create and compose module.

In this talk Maciek will aim to present the basics of lambda calculus: its syntax, reduction rules and properties, and how the calculus can be used to model programs that we write in higher-level languages. If time permits Maciek will briefly mention a couple of more advanced topics such as Curry-Howard correspondence, combinatory logic and advanced type system features.

The talk falls primarily into the ""Functional programming theory/practice"" category. It will have very few references to Scala -- mostly illustrating how certain features of Scala have their roots in lambda calculus.

We offer solutions for a wide range of problems, ranging from functional data structures, testing and JSON processing to efficient numeric programming, stream processing and generic programming.

This talk will give a whirlwind tour of the ideas and projects behind typelevel, and how they can be used to improve your code base. We'll see some short examples of how to solve problems in a functional manner, and demonstrate some of the tooling around the libraries. Also, a critical review of the progress and an outline of the future plans of the projects will be made.

Jan will show code examples in Scala and Akka only to demonstrate the key principles. Alongside the code, Jan will explore the required shift in thinking that is required to grasp the challenges of distributed reactive systems.

David Pollak, Lift's founder, will walk through the strengths and weakness of Lift... the good decisions and the bad...And talk about how Lift will continue to grow to be a decade-old open source project.

Here at EatingWell, we have learned quite a bit about Slick over the past two years as we transitioned from a PHP website to Scala. I will share with you tips and tricks we have learned, as well as everything you need to get started using Slick in your Scala application.

I will begin with Slick fundamentals: how to get started making your connection, the types of databases it can access, how to actually create table objects and make queries to and from them. We will using these fundamentals to demonstrate the powerful features inherited from the Scala language itself: static-checking, compile-time safety, and compositionality. And throughout I will share plenty of tips that will help you in everything from getting started to connection pooling options and configuration for use at scale.

We will discuss some of the main abstractions in the Scalaz library, but instead of explaining the details of what they are, we will focus on when and how we can use them to write code with less boilerplate. We will attempt to build an intuition and motivation for the abstractions and their use, leaving precise definitions and further details to the excellent material available elsewhere.

The talk will cover monoids, monads, and applicative functors.

Slides available at http://bit.ly/mkhl-scalax-2014

Slick 2.2 adds async support, automatically manages session and transaction lifetime for less boiler plate and less bugs and supports Option for structured data.

One of the things that makes Minecraft so big is the modding scene. Minecraft mods are traditionally created using Java. We have been running workshops using the combination Java and Minecraft with great success. But using Java in this scenario is not really ideal: there is lots of boiler-plate code that have to be simply ignored by beginners. If such boiler plate code can be ignored, why is it even there?

Then we will explore how to solve the common problem of custom data serialisation. Initially we will present some commonly adopted approaches including the Adapter Pattern, showing their pitfalls. Then, we will show how type-classes simplify the design and result in better extensibility and and API usability.

Finally we will discover how users don’t need to understand type-classes to make use of these libraries.

This talk is suitable for Scala beginners but (I hope) will be of use to more experienced Scala developers as well, even if only as a gentle reminder about some of the tricks used, or perhaps in the effective combinations of some of them that have proven useful over time.

In this talk, aimed at beginner-to-intermediate Scala developers, Dave will build a simple, powerful, composable data validation library from the ground up, explaining at each stage the design choices made and the benefits gained from the Scala programming language.

The talk will cover such topics as:

• How do we model errors and warnings?
• How do we bind validation to our data and the user interface?
• How do we make validation modular and composable?
• How do we deal with cross-cutting concerns such as async and dependency injection.

This session will start with an introduction to the Spray/Akka-http routing DSL, making sure to go beyond the basics. It will also show examples of real-world application code to give you a feeling for what the end result looks like. The session will conclude with a discussion of some things to watch out for on your way to becoming an expert user.

Overview:

-The routing DSL
-Real world examples
-Things to watch out for

Detailed Contents:

-The routing DSL
-An overview of the builtin directives.
-Combining directives into route handlers
-Marshalling and unmarshalling your (case) classes
-Dealing with rejection
-Dealing with Futures
-Writing your own directives

Real world examples

-A simple OAuth2 server

Things to watch out for
- Confusing errors
- If you block, things break

Through some live-coding using Parboiled2 (https://github.com/sirthias/parboiled2), Phil will show that writing simple parsers in Scala is easy and demonstrate that parsers are more readable, more composable and provide more useful information when things go wrong than regular expressions.

This will be followed by the traditional park bench discussion on all thins Scala, hosted kindly by Kingsley Davies.

If you have a question you want to ask - use the #scalaxqa or email scalax@skillsmatter.com.

This session finishes at 7PM. Drinks will be hosted around the corner. You'll be directed!

Users of Big (and not so Big) Data roughly divide into three groups, developers like us, traditional data analysts, and a hybrid called data scientists. The analysts prefer SQL, SAS, and similar, traditional tools. The scientists (mostly statisticians, really) prefer Python and R, with Julia emerging. The Developers started with Java, but they are being seduced by Scala, because it offers ideal tools for data-centric applications.

This talk explains why data-centric applications are driving Scala adoption. Scala already provides these essential features:

• Expressive DSLs.
• The JVM.
• Actors for distributed scaling.
• Optimizations for primitives, but uniform source abstractions.
• Functional combinators.

These features combine to yield powerful, scalable tools with concise APIs:

• Scalding and Summingbird - for Hadoop and Storm
• Spark and H2O - the Next Generation...
• Spire and Algebird - Mathematics

Finally, we'll discuss what's missing and what's ahead.

Abide integrates with Sbt, IDEs (via compiler plugins) and soon with Maven. Users can add project-specific rules, and additional rule libraries can be imported from any ivy or maven repository. Rules have access to the fully type-checked tree and may use quasiquotes for easy AST pattern matching.

But not everything is rosy. Case classes come with restrictions, some of which are essential, some not. And they have some characteristics, again some essential, some not, which are not always entirely appropriate or desirable. This has led to the often expressed desire to be able to pick and choose or otherwise customize case class features: case classes a la carte.

Unfortunately this has seemed to require changes to the Scala compiler which for various reasons have been perceived to be too difficult or too risky to attempt. The arrival of macros, macro annotations in particular, briefly raised the prospect that case classes a la carte might again be on the table. But macro annotations are not yet available in a production ready Scala compiler and might never be.

But all is not lost. Generating the scaffolding for case classes is a generic programming problem, and the fact that one solution to that problem is hard coded into scalac doesn't preclude other approaches from being applied. To that end I will demonstrate one way of tackling this problem using the generic programming library shapeless, and show some of the exciting new possibilities this opens up ... crucially in the context of current (ie. 2.10.x and 2.11.x) Scala compilers.

https://github.com/milessabin/shapeless

Its design leads to a number of interesting opportunities.

This talk gives an overview of Ensimes current state, the future plans and shows some interesting things you can do when you have your IDE as a queryable process.

The budding DSL designer, however, will quickly realize that there are precious few resources on how to best approach the problem in Scala; the various techniques, limitations and workarounds are not generally well understood or documented, and every developer ends up running into the same challenges and dead-ends. In this talk I'll attempt to summarize what I've learned from reading, extending and designing Scala DSLs in the hopes that it'll save future Scala library designers a whole lot of pain.

As Scala gains increasing traction in OO developer communities, more and more Java developers are in the progress of making the move from being Imperative-comfortable to FP-fluent. Many are lured by the terser syntax, others by the promise of powerful high-level constructs, and more still by the thrill of challenging themselves and learning something almost entirely new to them. The problem however, is that for many their initial enthusiasm soon wears off and the realization of how much a mind-shift this really is sinks in.

In this session I will discuss in detail the key steps along a path which via much trial-and-error has proved for me to be effective in undertaking this transition. We'll begin at the base-camp of understanding (Java-concepts to let go of, the initially-unfamiliar syntax, the equally-unfamiliar maths idiom) and from there up into the lower foothills (the basics of the type system, infix notation, ""everything is an expression"" and referential transparency) before progressing on to the lower peaks of the language (Pattern-matching with case classes and partial functions) and ending at one significant Monadic taster (Option, map/flatMap and the for-comprehension).

For maximum benefit I'll also point out the pain points I encountered, techniques and resources I used to overcome these, and we'll end by mentioning next steps and further inroads into the language.

The Algebra of Communicating Processes (ACP) has a potential to improve this: it lets one concisely specify event handling and concurrency, and it facilitates reasoning about parallel systems. There is an ACP-based extension to Scala named SubScript. We show how it helps describing the internal behavior of Akka actors, and how it combines with futures. For more information see www.subscript-lang.org

Through a live coding session, we'll show you what programming with Scala.js means today: a simple and fast development cycle with the sbt plugin, a rock solid compiler and optimizer, amazing (cross-compiling) libraries for reactive UIs and easy client-server communications, and more!

Historically BBC projects are generally a combination of centrally managed PHP front end and Java Web Service backend systems. This talk will discuss how our previous technology stack was not fit for the future and how Scala and Play offered a solution for that future. Sometimes we need to reinvent the wheel. By getting management behind us, running successful recruitment campaigns and various staff training techniques this talk will discuss how the responsive future of the BBC Children’s websites are taking shape and built around a centre of excellence for Scala in the north.

This talk should be of interest to anyone looking to facilitate change within their organisation. This talk should be of particular interest to anyone who is part of, or leading a team that is transitioning to Scala.

Site Links:
www.bbc.co.uk/cbbc
www.bbc.co.uk/cbeebies

Whisk is a shopping list app that connects online recipes to online and offline supermarkets. Their users build their shopping lists from online recipes using embedded widgets, browser extensions, our webapp, and our mobile apps. Their lists must stay in sync, or they won’t eat. To complicate matters, users carry their lists with them to supermarkets - the best naturally-occurring examples of Faraday cages. Whisk's apps must work seamlessly with very patchy networks, but also in fully offline mode. To achieve this, their apps use local storage, and sync mechanisms use CRDTs.

Whisk have implemented two specific CRDTs to support shopping lists at Whisk, provided to their clients through an API built with Scala and underpinned by Cassandra. David will describe their approach and architecture, and discuss some practical measures they've taken to address the problem of an ever-growing operations log.

This talk should appeal to anyone interested in cross-device data synchronisation, and practical applications of Scala.

Netlib-java is for accessing hardware optimised linear algebra libraries (i.e. high performance mathematics). It is being used in investment banks, aerospace companies and has recently been adopted by the Apache Spark ecosystem:

https://github.com/fommil/netlib-java

In netlib-java, implementations of BLAS/LAPACK/ARPACK are provided by:

• delegating builds that use machine optimised system libraries (see below)
• self-contained native builds using the reference Fortran from netlib.org
• F2J to ensure full portability on the JVM

In this talk, Sam will be explaining why high performance linear algebra requires hardware support and show how to utilise netlib-java in Scala (e.g. via Breeze).

Sam will also discuss why GPUs are the future for linear algebra, and the technical challenges that remain.

The challenge in that scenario is to test all the containers in collaboration and do so in a nightly build without any human interaction.

The presentation details how we have overcome the challenges

• by packaging all the containers within docker images throughout the build process
• by creating a test framework based on docker-java, Scala, Akka and Scalatest
• by integrating the individual pieces within our maven based build process

The combination of the technologies mentioned above allow us to execute the entire integration test suite over night against the latest, automatically generated docker images.

All framework source is available on Github.

In order to avoid duplication of code and to give us maximum flexibility we have developed banana-rdf [3] - a scala RDF library that allows us to elegantly write code that can be used both on the web client using scala-js and on the server, whilst allowing us to change implementation with one line of code. On the client we gain maximum speed with a scala-js wrapping of the Facebook React framework, allowing us to write clean functional code.

This project is open source with more details on the wiki https://github.com/read-write-web/wiki/wiki

OuiShare Workshop

For those interested in digging deeper a hands on session will be organised in cooperation with OuiShare labs on Wednesday 10th December in London.

Full details on the workshop and how to register can be found here.

[0] http://json-ld.org/ 1 http://www.w3.org/TR/ldp/ [2] http://webid.info/spec/ [3] https://github.com/w3c/banana-rdf

In simple words, this project will let scala programmers use values at type-level, allowing a lot of compelling use-cases. The talk will show where and how literal-based singleton types can be (and in some cases already are) useful.

Other issues only get visibility when you get down to the implementation details. To name a few: service discoverability, integrating new components to existing code, allowing multiple codebases (in different languages) to interact transparently, or incorporating legacy code into the new architecture.

In Gumtree we have been evaluating possible solutions to these challenges. For example, using specific Kafka feeds as a solution for discoverability issues and to facilitate integration of components built using different languages. We are in the process of implement one of the proposals as a trial and we want to share our ideas and the issues found during implementation.

Disclaimer: The title comes from a tweet by ‘The Legend of Klang’ himself: https://twitter.com/viktorklang/status/481109888656244736 "

The examples are from commercial code reviews across a wide range of developers and projects. We've seen what developers are struggling with, and how teams are shipping code while getting to grips with Scala.

We will look at examples including:

• managing error handling and configuration
• failure to use the type system
• battling with libraries; and
• making code easier to read and maintain.

Behind each piece of code there's a reason why the code ended up that way. Richard will provide suggestions from the Scala ecosystem that would give a better result.

But what if there is true value in the world of scalaz? What if it is possible to use these tools for good (and a little bit of evil – it's fun to use learning for evil!) and profit... Without getting hopelessly lost in the opium dens of FP?

In this talk we will look at some of the "gateway drugs" of scalaz: Validation, NonEmptyList, \/, Monad Transformers, and more. How do they work from a practical standpoint? What is their value for real world applications? Can we use them without an advanced Maths PhD? And just how fun is it to really code with these tools?

How the data is structured. Coding up the algorithm and comparing different implementations, both functional and imperative. Automated tests. Rendering the difference results. Build tools and jar publishing.

Github

Map data structures are often used quite liberally to associate data to entities, such as users, sessions or transactions. Those are typically identified by a numeric key. This works well for optional data, but often we'd like to guarantee that data is present for every entity.

We show how identifier types can evolve to track dynamic sets of entities. We use these types as keys to build total maps. Since lookups in total maps are always successful, we can eliminate important error-handling code paths and increase application reliability. We walk through the conversion of an application from maps to total maps and discuss benefits, challenges and alternatives.

Fortunately, tests can be kept clear and easy to maintain through the use of a declarative message representation. A declarative representation describes message structure and content (the "what"), while hiding the actual message construction (the "how").

In this talk, I will demonstrate one approach to defining a declarative representation of FIX messages for testing a trading application.

Herein lies the problem: how can you focus more on the good stuff? We will present some tools written in Scala that help you get dull tasks out of the way quicker. We use this arsenal to support live production systems, to manage byzantine release bureaucracy, and to test inter-process workflows.

To keep things interesting and concise, we’ll present this as a series of very short talks, with a break for questions after each one. We hope you will begin to see a common ethos linking the talks, as well as seeing some useful tools, written in Scala, aimed at Scala developers.