As functional programmers, many of us have made use of monoids and semigroups. However, abstract algebra is a rich field that provides many more useful abstractions. This talk will introduce some of these algebraic structures, starting with monoids, but also discussing groups, rings, fields, vector spaces and commutativity. This talk will show why these abstractions are important, how we can model these in Scala, and how they can be of benefit in everyday programming.

Asynchronous programming is the latest hype for web development. While Asynchronous programming can help improve total throughput on a multi-core machine, the current state of the art lacks common patterns for how to define asynchronous flow. This talk covers those patterns, from joining together a series of asynchronous operations to chaining a pipeline of asynchronous tasks. We’ll present a few core abstractions (applicative functors, monads, traversal) that help define asynchronous workflow and then use these same abstractions to test the same flows synchronously.

Stream processing, and especially distributed processing, is one of those problems in FP that is crying out for a simple and usable solution. Iteratees are too complicated (and so last year), and IO monads and Actors just get in the way since I/O and message passing are rather not the point. This is an advanced talk on the design space for modular, compositional stream processors, and we take a stab at creating a library for declarative stream processing that is both powerful and comprehensible.

In this talk, John A. De Goes, CTO of Precog, presents the high-level architecture of PrecogDB, a data science platform written in 100% Scala that provides a robust implementation of the data analysis language Quirrel on top of a proprietary data store. John discusses the challenges the team has had building systems-level code in the presence of megamorphic functions, monadic recursion, boxing, and monad transformers, while also highlighting some of the strengths of Scala and the bright hope of inlining, TCO, specialization, and macros.

As Scala developers we all know that the major performance wins come from choosing appropriate algorithms, taking advantage of parallelism, and using laziness to avoid doing more work than necessary. But sometimes it takes a bit more than that. This talk deals with the dark side of optimizing Scala code. Arrays. Specialization successes (and failures). Boxing and GC pressure. Hotspot voodoo. Inlining limitations. Reading Java Bytecode. Profiling and benchmarking.

Functional programming has a rich history of drawing from mathematical theory, yet in this talk, we make the case that programming is distinct from mathematics. This distinction is healthy and does not mean we can't leverage many results and concepts from mathematics. As examples we'll discuss some recent work: github.com/twitter/{algebird,bijection,scalding} and show cases where mathematical purity were both helpful and harmful to developing products at Twitter.

At Tumblr, we have adopted Scala as our backend language of choice and found it to be an excellent fit due to the expressiveness of the language and the runtime performance on the JVM. Although Scala is often cited as being an excellent target platform for highly concurrent applications, in practice it can be easy to shoot yourself in the foot. In this talk I will review code found in the wild here at Tumblr and discuss the implications in a server context. We'll also look at some graphs. This talk will be most interesting to engineers responsible for building backend service applications.

The actor model has been established as an important tool for dealing with concurrency, parallelism and distribution, but it has one feature which seems at odds with Scala’s statically typed setting: the fundamental communication mechanism is dynamically typed. This talk presents typed channels implemented as an Akka extension. The main focus will be on how types, macros and runtime compilation have been applied to sort actor messages into type-safe channels.

"Finagle is a network stack for the JVM that you can use to build asynchronous Remote Procedure Call (RPC) clients and servers in Java, Scala, or any JVM-hosted language. Finagle provides a rich set of protocol-independent tools." It's node.js for Scala, deployed on one of the most heavily trafficked sites on the web, Twitter. In this talk, we'll review the concepts of Finagle in code and see just how simple it is to create robust asynchronous apps.

This talk will focus on how to achieve simplicity in Scala library, DSL, and application design. It will highlight general principles that can be applied to any programming language, and show specific techniques that can be used in Scala to "implement" the general principles. This talk will give you a set of concrete guidelines that can help you manage complexity in your Scala projects.

How do you count the number of distinct values when there's too many to fit in a Set? How do you find the most frequent items when you don't have space for a Map[T,Int]? When dealing with very large or streaming datasets, it's common to use probabilistic algorithms like bloom filters, hyperloglog counters, or count min sketches. In Scala, it's nice to model these as approximate versions of normal collection classes like Set and Map. I'll discuss some work we're doing on this in the context of the Algebird project started at Twitter.

The new, reorganized version 7 of Scalaz has been under development for quite a while now. However, we are slowly converging against a release. In this talk I'll give a brief overview about the library and new things which improve its usability by far: à-la-carte implicits, helping type constructor inference, automated checking of type class instances, typelevel programming and more.

The standard request/response architecture is so 2008. Lets write code for our current needs. The concept of Concurrency and Asynchronous events allows you to improve request times, by removing the standard "blocking" actions that are performed on DB resources and execution threads. Using Scala and the Play! Framework (v2), we can architect a system that can perform massive computations, very fast, with less blocking of resources. I will review these concepts in code, and see how much improvement can be achieved.

Scala's type system enforces code hygiene in Scala code. But the most common Scala build tools (SBT and Maven) do not enforce dependency hygiene during builds. Loose package hygiene in the build process results in unintended dependency cycles and slower, more error-prone builds. This talk will present a new build tool called pants (part of the twitter-commons library), which is our primary build system at Foursquare. Pants requires explicit declaration of inter-module dependencies, and uses a bottom-up build process to enforce those dependencies without sacrificing compilation speed.

shapeless makes extensive use of Scala's implicit resolution mechanisms to compute types at compile time which guide runtime behaviour and statically witness properties of values and types. This works out very well for the most part, but it sometimes results in explosions in compile times: it's a marvel that implicit resolution can be repurposed as a form of theorem proving, and hardly surprising if it doesn't do it particularly efficiently. In this talk I will show how implicit macros can short-circuit type-level computation and make the techniques used by shapeless even more attractive.

Scala keeps Java's dependency management, with metadata fetched on demand from central repositories. This makes it difficult to mirror, publish releases, reliably cache, and efficiently build. The metadata is limited, with no compatibility data. The lack of this data led to the cross-versioning hack now used to publish for multiple Scala versions. This talk describes current limitations, some improvements, and tips. It proposes a future system addressing compatibility, builds on distributed version control of metadata, and has a mechanism for working with the existing standard.