Scala Days

The talk will give a quick history of the design motivations behind Scala, summarize its current status, and point out future directions for the language and its ecosystem. Scala was intended from the start to be a simple and powerful language for software components. Today, we see a large number of interlinked components and open source systems that make use of it. However, extensive collaboration and re-use are sometimes hampered by binary compatibility issues. I will argue that the logical next step to overcome these issues is to make Scala a true Software platform, which can operate on a number of different host platforms. This step will also lead to a much-needed separation of concerns between stable interfaces and changing implementations.

Java 8 has Streams, Scala has parallel collections, and GS Collections has ParallelIterables. Since we use parallelism to achieve better performance, it’s interesting to ask: how well do they perform? We’ll look at how these three APIs work with a critical eye toward performance. We'll also look at potential optimizations or additions to the Scala Collections Framework

• Persistent collections vs "plain" immutable collections
• Ctrie vs concurrent hash maps
• @specialized collections vs primitive collections
• open addressing vs chaining in hash maps

How can programmers quickly and effectively learn to write idiomatic Scala? This is a question we at Underscore had to answer when developing our own training material. We 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. In this talk I 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.  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.

Scala has many, well-known WTF LOLs that result from the language too enthusiastically attempting to help the programmer. Scala can also be written across a wide range of styles from the Typelevel to the Better Java. The Scala ecosystem has static analysis and linting tools which can help avoid confusing behavior, baffling compiler messages, and divergent coding styles. A survey of the available tools will prepare attendees to determine which can be best applied in greenfield and existing projects. A case study of a team using static analysis tools over many years will also be presented. Attendees will leave with steps to immediately improve their production builds and strategies to introduce more sweeping changes with time.

Sparkle is an open source data service written in Scala to support interactive data visualization analytics. While much of the attention in the open source data analytics community has been on tools for managing big data batch analytics, in the Sparkle project we've been exploring the possibilities enabled by a service that sits between the big data store and the web/mobile UI to support interactive analytics.  With the growth in server processing power and RAM storage, interactive analytics is becoming ever more general purpose and ever more applicable to larger data sets. As this trend continues, interactive analytics will emerge as the third stage in big data pipelines: ETL -> batch analytics -> interactive analytics. We'll discuss the opportunities this new architectural stage presents. We'll demonstrate some recent progress with Sparkle including handling large datasets with Cassandra, integrating batch calculation with Spark, low latency calculation with Reactive streams, and continued work on supporting a standard protocol for web/mobile visualization clients.

The idea of the present is an illusion. Everything we see, hear and feel is just an echo from the past. But this illusion has influenced us and the way we view the world in so many ways; from Newton’s physics with a linearly progressing timeline accruing absolute knowledge along the way to the von Neumann machine with its total ordering of instructions updating mutable state with full control of the “present”. But unfortunately this is not how the world works. There is no present, all we have is facts derived from the merging of multiple pasts. The truth is closer to Einstein’s physics where everything is relative to one’s perspective.

As developers we need to wake up and break free from the perceived reality of living in a single globally consistent present. The advent of multicore and cloud computing architectures meant that most applications today are distributed systems—multiple cores separated by the memory bus or multiple nodes separated by the network—which puts a harsh end to this illusion. Facts travel at the speed of light (at best), which makes the distinction between past and perceived present even more apparent in a distributed system where latency is higher and where facts (messages) can get lost.

The only way to design truly scalable and performant systems that can construct a sufficiently consistent view of history—and thereby our local “present”—is by treating time as a first class construct in our programming model and to model the present as facts derived from the merging of multiple concurrent pasts.

In this talk we will explore what all this means to the design of our systems, how we need to view and model consistency, consensus, communication, history and behaviour, and look at some practical tools and techniques to bring it all together.

Building interactive data analytics products on top of large volumes of data is challenging. This talk will outline Quantifind's infrastructure story for building analytics software. We will describe the infrastructure that we originally built on top of existing systems such as Spark/Hadoop. However, the bulk of this talk will focus on a new, custom distributed system that we have built in-house for our predictive analytics software. This new system includes a distributed, in-memory, real-time computing platform that supports fast interactive querying against large volumes of compacted raw data that isn't pre-aggregated. This infrastructure can be viewed as an in-memory combination of map/reduce style computation and indexed structures built from bit sets to offsets in the compacted data. Akka Cluster sits at the core of this system for distributed communication between nodes. We will discuss why we chose to build our own system as well as tips and tricks that we've learned along the way for pushing the JVM for these types of systems.

Applications are evolving from a traditional model to be able to Highly Available and Scaleable. Platform as a Service in general and CloudFoundry in particular has substantial industry support and enables hosting of multiple applications. The session will start with an overview of CloudFoundry and how to push Scala/Play applications to the cloud. In addition to ease of deployment, we will also look at what the CloudFoundry has to offer in terms of HA, scaling and security which is built in to the platform and how to control those knobs. Attend this session for a technical overview of CloudFoundry and how to run Scala/Play applications on the cloud and to reap the benefits of HA, scaling, security and so on that the PaaS has to offer.

In this talk, we present a case study on how we build high performance distributed programs using Apache Spark and Scala. Based on the case study, we discuss common performance pitfalls and principles for both high level (e.g. task scheduling) and low level (e.g. cache locality) performance optimizations in data intensive applications.

Using Spark and Scala, we recently set a new world record in 100TB distributed sorting in the Sort Benchmark [1]. Participants from all over the world often build dedicated sorting systems using C/C++ for the benchmark, while we enter using a general data processing engine (Spark) and Scala/JVM.

Our program sorted 100TB in 23 mins using 206 i2.8xlarge machines on Amazon EC2. Using only 1/10th of number of machines, our record is 3X faster than last year’s record set by Hadoop MapReduce. Sorting 100TB of data following the benchmark rules generates 500TB of disk I/O and 200TB of network I/O. Our Spark/Scala-based program saturates the bandwidth of 8 SSDs and 10Gbps links on available on these machines during sorting.

The toolkit of data scientists is full of new technologies and frameworks that promise huge scale, fast execution and simplified primitives. The problem is, none of these are really important. What separates great data scientists from good, is their ability to reason about data and iterate quickly through ideas. The main tool to achieve this is the programming model they use, and no language is better at this than Scala.

Join Vitaly Gordon, a Scalding contributor, Spark aficionado and the lead of the newly formed data science group at Salesforce on this talk about how Scala is the real spark of data science.

scala.meta is the culmination of our experience with metaprogramming in Scala. Our design provides an elegant model of the language and solves the problems of compatibility across compilers and tools. Since the announcement of scala.meta at ScalaDays 2014, we've been working hard turning it into reality.

In the talk, we will demonstrate how existing metaprograms can be migrated to our new platform and highlight the benefits that scala.meta brings to macro users, library designers and tool authors. Curious to see how the unification of trees, symbols and types is working? What additional capabilities do our new quasiquotes have? And have we really managed to allow macros to be defined in the same project that uses them? Come over and see for yourself!

This talk will briefly introduce Spark, but focus on various lessons learned maintaining a large code base and developer community in Scala. Some topics that will be discussed are: 1. Interacting with Scala newcomers in the Spark community and our philosophy around exposing Scala features in our public API 2. Maintaining a multi-langauge project baed on Scala. 3. Ecosystem tooling for Scala projects, such as build tools, style checkers, etc 4. Maintaining binary compatibility in a widely used Scala project. 5. Tracking down and reporting bugs in Scala itself. 6. Our overall experience with Scala, Akka, etc. The goal is to provide guidance for other Scala projects and feedback to the broader Scala community.

Data validation is a common enough problem that numerous attempts have been made to solve it elegantly. The de-facto solution in Java (JSR 303) has a number of shortcomings and fails to leverage the powerful Scala type system. The release of Scala 2.10.x introduced a couple of experimental metaprogramming features, namely reflection and macros. In this talk I'll introduce macros by way of a practical example: implementing a full-blown data validation engine, utilizing def macros and a Scala DSL to enable elegant validator definition syntax and call-site.

Conciseness, expressiveness, and fluency, among other things, are some of the core strengths of Scala. Beyond the language capabilities, the Scala library has a wealth of capabilities to make expressive and concise code quite efficient. This combination of benefits comes from the functional side of Scala where function composition and lazy evaluations are common place. In this presentation we will learn about being lazy and, by doing so, how we can make the code quite efficient both from the point of view of expression and execution.

With the advent of the Reactive Manifesto, the constant development of Java, Scala and toolkit’s such as Akka, we now have the means by which we can create fully distributable applications on the JVM. But even when equipped with this knowledge and set of tools, we still find ourselves looking for a good set of blueprints.

This session will focus on the review of three Reactive Reference Architectures; that will give you a foundation from which you can build a wide variety of distributed software solutions.

Scala boasts a powerful type system which assists developers in writing and maintaining bug-free software. Unfortunately, many members of the growing Scala community struggle to utilize the Scala type system due to prior experience with poor static type systems or none at all. This talk aims to narrow the gap between haves and have-nots of type-level programming by teaching some basics of type manipulation in Scala.

This presentation is the product of my journey into the Scala type system from a background in Java. I will review the familiar value-level runtime programming, and show how the same logic can be utilized at compile time via the type system. By the end of the talk you will be motivated with a new comfort level in types enabling you to take the plunge into the riches of one of Scala's greatest features.

We will cover how to keep abstractions manageable for diverse teams, while still taking advantage of the type system. This includes borrowing from Scalaz, type lambda syntax, cake pattern, and patterns with Trys, Futures, Options, and all your favorite combinations of these.

Our team at PayPal began as a startup (Stackmob) and has transitioned into an internal infrastructure team (Stingray). Along the way, we went from Java to Scala to Scalaz and back to Scala. James and Joe embody creative tension between functional programming elegance and pragmatic maintainability that guides our Scala dialect choices in a mixed Scala/Java landscape.

Object oriented programmers create and use types everyday, however these are usually limited to classes that group and encapsulate data. A type system is a theorem prover, and types are capable of much more. When they are used to express invariants, the type system can prove these hold and show where they do not. Tests prove your code is correct for some values, types can prove your code is correct for all values.

This talk is aimed at Scala developers with a background in object oriented programming who want to learn new ways to use types to improve the correctness of their code. It introduces the topic in a practical fashion, concentrating on the “easy wins” developers can apply to their code today.

We will look at how invariants and preconditions are traditionally expressed with assertions and the runtime errors they produce. We examine how some of these are solved with types in the standard library and elsewhere and the guarantees they provide. Then we show how common invariants can be expressed with custom data types and how these use compiler errors to prevent bugs. This will touch on tagged types, typesafe wrappers, algebraic data types and path dependent types.

Finally the talk demonstrates there is a whole world of types outside of object oriented design and hopes to encourage you to spend the time to discover these for yourself.

Wide adoption of Scala has led to it being used in a vast variety of scenarios ranging from simple apps to massively concurrent distributed services handling millions of requests per second.

Scaling doesn't come for free and at certain stage one becomes limited by the underlying platform. A common scaling problem on the HotSpot JVM is performance of garbage collection on large heaps. Past certain heap sizes GC pauses become completely unacceptable for latency-critical applications.

In this talk, we are going to present an alternative approach for type-safe off-heap memory management that doesn't rely on JVM garbage collection. We believe that it can vastly simplify development of latency-critical applications which suffer from GC pauses. Our framework provides tools for allocation and automatic deterministic deallocation of off-heap memory and other system resources without performance overhead.

"We've all seen them on the corner of our local software development neighborhoods: FP purists, shamelessly peddling scalaz to unsuspecting developers. Lured in by promises of Free Monoids, Semigroups, and Endofunctors these developers soon seem lost in throes of ecstatic coding. "

To the skeptical and stubbornly practical among us, the above might ring a little true – especially if read in Rob Serling's voice. Images of gibbering horrors lurking in the depths of mathematical perfection swim before our eyes.

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, \/, OptionT, and more. How do they work from a practical standpoint? What is their value for real world applications? And just how fun is it to *really* code with these tools?

Everyone in the Scala world is using or looking into using Akka for low-latency, scalable, distributed or concurrent systems. I'd like to share my story of developing and productionizing multiple Akka apps, including low-latency ingestion and real-time processing systems, and Spark-based applications.

• When does one use actors vs futures?
• Can we use Akka with, or in place of, Storm?
• How did we set up instrumentation and monitoring in production?
• How does one use VisualVM to debug Akka apps in production?
• What happens if the mailbox gets full?
• What is our Akka stack like?

I will share best practices for building Akka and Scala apps, pitfalls and things we'd like to avoid, and a vision of where we would like to go for ideal Akka monitoring, instrumentation, and debugging facilities.

Have you ever wanted to take your Play application and development workflow to the next level? Make it easier, faster, more productive, and fun? In this very opinionated talk we investigate, layer by layer, how to fully explore Play's typesafe and reactive potential:Polyglot persistence with Slick and NoSQL, Future-based services architecture, Coast-to-coast JSON, Effective templates, Practical asset management pipeline, State-of-the-art internationalization, Advanced end-to-end testing and debugging, Enhanced error reporting, Leveraging Typesafe Config HOCON, Custom environments, Jumpstarting your projects with Typesafe Activator, Lessons learned: our experience with large projects.

In this talk, I'll present some of our ongoing work on a new programming model for asynchronous and distributed programming. For now, we call it "function-passing" or "function-passing style", and it can be thought of as an inversion of the actor model – keep your data stationary, send and apply your functionality (functions/spores) to that stationary data, and get typed communication all for free, all in a friendly collections/futures-like package!

Scala is so flexible that it can be hard to know what it wants. Its syntax will give way and let you program in many different styles. The Scalactic library, on the other hand, quite opinionated about how you should program in Scala. It is guided by a specific philosophy. In this talk you'll find out what's in Scalactic, why it is there, and how you can take advantage of it in your projects.

banana-rdf is a Scala library for RDF and Linked Data. It makes it easy to manipulate RDF data on the JVM (abstracting the Java libraries Jena and Sesame, or using the pure Scala implementation Plantain) and in the browser thanks to scala-js. It adds type-safety and immutability without sacrificing performances.

RDF has now become ubiquitous on the Web. Thanks to schema.org (Google, Yahoo, Microsoft, Yandex) or the Open Graph Protocol (Facebook), Web authors can annotate Web pages with RDF data. More recently, the LDP Working Group at W3C (IBM, Oracle, ...) has led the development of the Linked Data Platform, providing a way to interact (read and write) with such data.

In this talk, I will show how one can leverage such a Web of Data using banana-rdf.

Every enterprise developer these days needs to be an expert in building REST API systems to enable mobile applications, SOA architectures and single page javascript web apps. The challenge is that most REST API backends can’t quickly scale to the numbers of requests needed in a modern enterprise. In this talk, we will introduce enterprise developers to Akka in an engaging and simple way and give them the confidence that they could quickly and easily build an enterprise web service that scales in their own workplace. This live coding session will showcase Akka’s power by taking an existing REST API and improving its throughput drastically by introducing a distributed actor system. Starting from a simple RESTful application exposing read and write operations, we’ll introduce a series of Akka features and patterns, scaling the performance and reliability of the system progressively.

We will introduce the Actor pattern, and show how Akka brings this pattern easily and simply to the JVM. A simple actor system will separate concerns and serve as the basis of the exercise. Clustering will allow the system to grow and shrink dynamically, across one or more machines, with messages being passed transparently between nodes as needed. CQRS (Command-Query Response Separation) will decouple writes from reads and introduce non-blocking message handling, and Akka Persistence will make nodes tolerant to failure and avoid data loss.

We’ll show how simple decoupling via message-passing of the system components allows you to scale each part of your service to match changing load.

If you need more write performance, you can increase the number of nodes handling writes. Need more REST-API capability, increase the nodes binding to HTTP. Each element is independently elastic for full tuneability.

Throughout the process, we’ll use Gatling to gauge our results in the form of handled requests per second. Watch our application go from Fast to Enterprise-Level Web Scale in 45 minutes or less, with very little code.

Scala Records is a new, easy to use library implementing extensible records and type-indexed maps (TMaps) based on intersection types. Extensible records are a more modular alternative to case classes.Type-indexed maps are type-safe maps without the need for key names.

Macros on top allow nicer syntax and additional features and safety. TMaps combined with the Reader pattern are a perfect fit for functional dependency injection.

Scala is an amazingly powerful tool for all sorts of applications, from web and mobile to desktop and the cloud. Monadic patterns in Scala let me express both sequential and asynchronous data flows easier than ever. I could use these patterns in an SBT plugin for submitting solutions to Google Code Jam problems where I could link together REST requests with local computations. Scala futures and Akka let me scale bioinformatics algorithms both up and out. Scala.js let me use bioinformatics algorithms in the browser—one language to rule them all! Combining Scala.js and Play helped me build web applications that are easy to use and fun to build! In this talk, I will present a variety of projects that show Scala's power and versatility.

When I joined Typesafe almost three years ago the big question about Scala was: can we improve quality and stability but keep fast innovation pace? My team has been refining its answer ever since. I’ll tell you the story how we approached this dilemma. We’ve always circled around one theme: automate, automate, automate!

Very early on we’ve realized that we can improve Scala’s quality only if we change how Scala is made. In the talk I’ll dive into Scala’s contribution process and see how it has changed. We’ll watch how various infrastructure pieces evolved over time and how it enabled opening up development of Scala. We’ll see if it’s getting harder or easier to contribute to Scala.

It’s a deceptively simple concept: programming is safer when values don’t change. There’s plenty of depth to explore when applying that concept to real world programs. We'll start by looking at the history of immutability in programming and delve into the details of how vals work in Scala. From there, we'll go beyond the truism that immutable data makes concurrency easier and examine other benefits and tradeoffs in the practice of programming with immutable values. We'll discuss some elegant and counter-intuitive outcomes of functional data structures that take advantage of immutable data. With those in mind, we’ll take a hard look at the performance of the standard library implementations of immutable collections in Scala. Finally, we'll explore frameworks in and out of Scala that do exciting things with immutable data, from the database level (append-only DBs) to data processing (Summingbird) to front-end development (Facebook’s React & Om).

The TypeClass type class (yes, you read that right), introduced to shapeless 2.0.0 at the beginning of 2013 by Lars Hupel of Scalaz fame, deserves a great deal more attention than it has received up until now. Built on top of shapeless's core generic programming primitives it allows instances for a wide variety of useful type classes to be derived for Scala ADTs with no (or at most minimal) boilerplate.

But until recently the types it could derive for (families of Scala case classes sharing a common sealed trait and with fairly minimal support for recursion) was quite limited. In shapeless 2.1.0 its scope has been significantly expanded to include non-case classes (so long as they are sufficiently "case class-like") and more complex recursion patterns (eg. through types outside the immediate family). It now also allows for the provision of specialized, non-derived, instances for specific case class members of the families being derived for.

This means that TypeClass is now the tool of choice for many important generic programming problems in Scala.

In this talk I will demonstrate this with example derivations of ordering and type-safe equality type classes, serialization and deserialization and a variety of other folds, unfolds and transformations which would otherwise require huge amounts of tedious boilerplate to implement.

"Big Data" encompasses more than large data volumes. It's also about flexible approaches to ingesting, managing and leveraging data sets of any size. That flexibility demands tools that are equally flexible, tools that are built on the right abstractions. Functional programming is the source of those abstractions, because FP is based on Mathematics and working with data is essentially doing Mathematics. Because of Scala's basis in functional programming, combined with its general flexibility and JVM roots, it has emerged as the de facto standard for Big Data programming. In fact, Big Data projects are driving Scala adoption right now. This talk shows you why.

We'll examine code examples from the following tools:

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

Finally, we'll discuss that natural synergy between functional programming and SQL, the venerable standard for data processing.

Scala does not have checked exceptions: the compiler will not consider a failure to handle exceptions as an error. This is, perhaps, the single area in which Java offers better static safety than Scala, but offers no way for this checking to be turned off when it's not wanted, which frequently leads to the compiler being a hindrance rather than a help to developers.

Jon will demonstrate how Scala's type system can be persuaded to enforce checked exceptions, with negligible syntactic burden at the call site, supporting validation-style aggregation of exceptions, and with the flexibility to be turned on and off as desired.

This is an experience report in building an open-source soft real-time character processing system (an IDE for Scala).

Version 4.0 has been in development for more than 2 years and came up with a slew of new features and performance improvements. But how did we get there? In this talk I'll go through the most important features in 4.0 and cast a look back at previous releases, showing how we got from a bare-bones IDE to a fully-fledged IDE for Scala. I'll touch on technical aspects, but also on the social and open-source dynamics we faced along the way.

Suppose you have some input--maybe a configuration file, maybe a log, maybe structured numeric data. Suppose you want to extract some key information--maybe a little, maybe as much as you can. You think you have a pretty good idea of the format, but the input needs validation and of course there could always be errors. If there is an error, you'd like to know something about what or where it was. What should you do?

You could try using primitives like String.split and .toInt, but they're fragile, don't pass back detailed information, and are incredibly slow in the face of numerous minor (recoverable) errors. Regex matching gives more flexibility in specifying what you want, but recursion is awkward and again, information about errors is hard to come by.

You could encode all possibilities for failure into your types, including how to pass back the relevant information about errors, but then you spend most of your effort thinking about every which way something can go wrong, and more effort handling the error cases than the successes, when you really want to think about success.

Grok provides an alternative by doing everything wrong: it is mutable, low-level, and has non-local return flow (via stackless exceptions). But it often provides just what you need: robustness to error, low-effort collection of error information, and speed, all while allowing you to optimistically focus on getting the information you need out of the input.

This talk will give a number of examples of input and validation tasks, showing the strength and weakness of various approaches, mostly but not exclusively focusing on those where Grok is compelling.

If you want to provide or consume HTTP services with your Actors then this talk is for you: Akka HTTP is the successor of spray.io and building on this excellent foundation it takes reactive web interactions to the next level. Fully asynchronous and non-blocking, a type-safe and very powerful declarative API, an immutable HTTP model without compromises, all these are perfectly fitted to the Actor world. And being based entirely on Akka Streams enables interoperation with all other Reactive Streams implementations for producing or consuming data.

This presentation details how Akka HTTP is structured, how it is used and why you will not want to use anything else after having tried it.

Implicit conversions and implicit parameters are fundamental and unique features of Scala that are powerful at the same time. To use these features to their maximum potential, and do so with confidence, you have to understand the specifics of how Scala compiler’s implicits search works. I will cover this topic in details, including ways you can optimize the implicits search algorithm in your library.

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.

With evergrowing numbers of servers in our data centers, operating these servers has become a complex task. In addition there is a trend towards writing microservices instead of monolithic systems, because they are easier to maintain and deploy independently. Because of the fewer resources such a microservice needs, we traditionally divide our large servers into smaller pieces using VMs, which leads to even more servers that need to be operated.

Mesos takes a different approach. Instead of dividing server nodes into smaller pieces, it creates a pool of all the resources in the cluster. These resources can then be used by all applications in the cluster, very similar to a threadpool on a local machine. This makes it easy to create fault tolerant, heterogeneous systems, because tasks do not have a fixed amount of resources allocated to them. They get their resources assigned on demand.

In this talk, we will learn how the distributed init and control system Marathon (https://github.com/mesosphere/marathon) utilizes Scala and Akka to reliably deploy applications in a cluster and how it ensures that a configured number of instances is always running. In addition, we will see how Marathon coordinates rolling upgrades of hierarchical application groups with interdependencies and makes sure that a minimum number of instances is kept running to serve the incoming requests and how it prevents faulty deployments from destroying the cluster.

Project Valhalla promises to add virtual machine support for value classes and specialization in Java. However, the assumptions built into the low level specialization scheme are not compatible to all of the Scala programming language features, such as existentials and variance: there is a semantic gap between the Java specialization in Project Valhalla and the Scala programming language.

In this talk I will explain the inner working of the specialization in Project Valhalla, highlighting where the semantics in Java and Scala diverge. We will go through several language-level solutions to bridge this gap, each with its own trade-offs, finally converging towards a scheme that allows Scala to define new specialized classes and to interoperate with Java-defined ones.

With all facts on the table, we can look at the changes necessary in the Scala type system and the patterns that will become invalid. In doing so, we'll be able to isolate what's good about embracing Project Valhalla, what's bad and what's ugly: those patterns that will just have to go away. Expect to learn about reified types, bytecode transformations and their correspondence to high-level Scala code. 

Jan will build a system that collects data from a wearable fitness tracker, communicating through a mobile app to an actor system, which processes the data, looking for type of exercise, effort and checks for proper form. The core of the talk is the actor system in Akka and Scala that—with help from Spark—analyses the data, and exposes appropriate REST APIs. The rest of the codebase includes some C and C++ for the wearables, and Swift in the mobile application.

I'm going to take you on a journey. We will go deep inside the human brain to explore some age-old questions. What does the brain do? Is it many things, or is there one algorithm to rule them all? Then we will get to the fun part. How do you build one? Together, we will explore why Scala is the ideal language in which to build brain-inspired AI algorithms in surprisingly few lines of code.

A key aspect of the success in the research and application of Natural Language Processing (NLP) systems relies on the use of methodological approaches developed and tested in other disciplines, from Linguistics and Cognitive Sciences to Information Theory and Machine Learning. The purpose of this presentation is to show how some of these methodologies can be successfully applied to a variety of scenarios thanks to the power and versatility of Scala. We will provide details on pragmatic implementations of these methodologies using functional programming approaches, resulting in correct and performing systems that can be used in industry for a variety of NLP tasks.

After an introduction to the building blocks of NLP, we will move to a more advanced topics in statistical parsing making use of ScalaNLP, a set of Scala libraries for processing natural language. We will introduce Epic, an NLP library with models available for eight languages. We will explain how to use this library, and then will drill down into how you can extend the system to build your own models while introducing some of the theory of Machine Learning for NLP. We will also present a library that makes extensive use of the facilities that Scala provides to build external Domain Specific Languages (DSL). These external DSL can be utilized by linguists and data scientists to provide accurate transcriptions and transliterations of texts, allowing them to obtain relevant quantitative and qualitative results from the linguistic corpora. Finally, we will discuss examples of large, complex systems that combine different modules from NLP and Natural Language Understanding using the Stanford NLP libraries, including an application that identifies metaphors in the web. Along the way, we will describe the relevant parts of the Scala Breeze numerical computing library, and how Breeze and Scala make building these kinds of systems easier.

Enlist now!

Ask not what your Scala can do for you, but what you can do for your Scala!

Never, in the field of developing Scala, has so much been owed by so many to so few.

Yes, this is a propaganda talk. It's a talk about getting involved, what you can do to help Scala development, and how to do so. We will cover:

• Documentation submissions
• Bug fixes
• Library contributions and Larger Scala language changes (SIPs, etc)

It might be propaganda, but it will not be technically light. Instead we will have practical demos and details of how to contribute each of the above, and why you should do so.

If you have ever thought about volunteering some time on the Scala compiler, Libraries, Documentation or anything else in the Scala-verse, come and find out how.

CODE, FOR VICTORY!

Scala 2.12 will target JDK 8.

In the first part of my talk I will present the technical details of how the next version of Scala takes advantage of the new features provided by the platform. At the language level, function types in Scala and Java are compatible in both directions. At the bytecode level, Scala generates function objects in the same way as Java. I will also discuss the utility of Java's default methods in interfaces for compiling Scala traits.

The second part of the talk is about the new bytecode optimizer available in Scala 2.12. A compile-time optimizer can improve performance even when running on an optimizing runtime like the JVM. I will outline the differences and advantages of the new optimizer compared to the current one in Scala 2.11. I will also show the fundamental limitations of the optimizer imposed by binary compatibility and separate compilation.

There are two types of 5 year old software startups: the ones that are embarrassed about the technical debt they accrued during rapid growth, and the ones that failed. To survive and scale towards 100M users, Hootsuite is undergoing an architectural transformation from our legacy monolithic PHP to reactive SOA with Scala, Akka, and Play. How do we pivot to a new architecture while retaining identical functionality with low risk and zero downtime? How do we interface new reactive systems with legacy systems that can’t keep up?

This talk will detail two modernization projects accomplished in 2014. The first was our user authentication and information microservice, which we developed, migrated to and deployed with zero downtime. The second is a URL shortening and image hosting service that provides both an API to our web and mobile products and a user interface.

Remotely is an elegant, purely functional machine-to-machine communication library developed in Scala at Verizon. Remotely is fast, lightweight, and models network operations as a monad. It features compositional, reusable protocols and codecs, where the compatibility between client and server is enforced using Scala's type system. It has support for TCP endpoints, with combinators for encryption, circuit-breaking, and load-balancing. In this talk we describe the API of Remotely, and delve into its design and implementation.

In this talk we will present our discoveries having written a new, distributed application named Typesafe ConductR. We will present the application in order to set the scene, and then we will describe how we've applied akka-cluster, akka-streams, akka-http and akka-data-replication (Conflict Free Replicated Data Types). This is a talk for anyone writing a distributed application using Akka, but may also be useful if you have an operations focus within your organization.

Scala.js is a Scala to Javascript compiler that lets you write Scala source code, compile it to Javascript, and run it in the browser. There are several other X to Javascript compilers, for X in {Typescript, Dart, Clojure, Ruby, Python, C#, Java, Haskell...} and dozens of other languages. So, then, what's interesting about Scala.js?  In this talk, I will cover how language features (or misfeatures!) such as: Type Erasure, Static Typing, Macros, Object-Oriented-ness, Specified-ness, An ecosystem of managed dependencies, A culture of tooling.

All contribute to make Scala.js a pretty special experience. Tiny executables, fast-turnarounds, multiple full-featured IDEs, a rich ecosystem right off the bat, together with a shallow learning curve, all for a minuscule amount of implementation effort compared to many of its alternatives.

In some of these dimensions, other Compile2JS languages can catch up, given a sufficiently large effort. In others, the advantage is basically insurmountable. I will explore how the fundamentals of the language, design decisions made years or decades ago, continue to affect the Compile2JS experience of several of these languages today. I will close with the heavy baggage weighing Scala.js down, and what the Scala language could do to improve our own Compile2JS experience.

When it comes to using relational databases in a reactive, scalable and non-blocking application design, Java's standard JDBC API and the way in which it is traditionally used has always been a sore point. Scoping database sessions correctly and configuring a connection pool in an efficient way were already non-trivial in blocking JEE-style applications, but if you try to fit the inherently blocking JDBC API into a Play or Akka app, it gets even harder. In the newest version of Slick, Typesafe's database library, we provide a different way of sequencing database actions, based on the ideas of Haskell's IO monad. This talk will show you how to use this new API to safely compose and execute database calls, returning Futures and Reactive Streams from them. Bridging the gap between the blocking JDBC API and your non-blocking applications also requires a very different threading model and connection pool configuration than in a blocking app. You will learn what Slick does behind the scenes to take care of these issues in order to give you good scalability and performance out of the box.

The Scala roadmap may have declared war on puzzlers, but there's still plenty of head-scratching moments to be had for now. As previously, we will present a new set of seemingly innocent examples of Scala code that behave in highly surprising ways, give you a chance to guess the result, and explain what actually happens.

We will also look at common patterns underlying many puzzlers, and outline some approaches to avoiding these pitfalls. Laugh, learn and take a few steps on the fun path to deeper Scala understanding!