Hadoop and all it's ecosystem have settled down for good (or bad) in our hearts and / or minds. It's quite old and has proven to be quite reliable for certain kinds of tasks. Yet one problem still remains - writing Map Reduce jobs in plain Java is really a pain. The API is clunky and does it's best to hide the actual algorithm beneath tons of boilerplate.

Luckily there are abstractions on top of it - like the great Cascading library, and the even better Scalding DSL built on top of it.

During this talk we'll execute what looks like a Scala map() but using a few dozen worker nodes, and then explore some of the more advanced features of Scalding - like joins, aggregation tricks and tips on how to build not only Jobs, but entire MapReduce Pipelines.

Konrad is a late-night passionate dev living by the motto "Life is Study!". His favourite discussion topics range from distributed systems and type systems to capybaras. In those rare times he's not coding, he spreads the joy of computer science, through helping local user groups and whitepaper reading clubs.

To view the video visit www.parleys.com.

To get started building reactive applications visit http://www.typesafe.com/activator.

Scala 2.10 was the first language release that provided a public native API for metaprogramming Scala, introducing facilities for compile-time (macros) and runtime (Java-like reflection) metaprogramming. These facilities have brought a lot of feedback, and we've been thinking hard how to make sense of it.

At this point it is clear that dedicated support for metaprogramming is useful. Previously, one had to deal with ad-hoc solutions like textual code generation and command-line scalap invocations. However, now there is a full-fledged model of Scala that accounts for the variety of language constructs and includes a comprehensive, backward-compatible API. However, there's still quite some work to be done in order to make our metaprogramming tools enjoyable. The main issues that remain to be addressed are verbosity and brittleness of the underlying API, difficulties with tool integration, tight coupling with scalac, and potential for confusion caused by leaking implementation details and cryptic error messages.

The goal of Project Palladium is to make metaprogramming easy, ensuring that it doesn't require knowledge of compiler internals, is safe by construction and is portable across a wide range of implementors. Towards that end, we have rethought the metaprogramming APIs along with the accompanying macro engine, keeping existing functionality in place and at the same time fixing fundamental problems intrinsic to the original implementation.

In this talk we will present our progress, showing how easy it is to metaprogram with Palladium, and will outline the place of our developments in the future of Scala.

To view the video visit www.parleys.com.

Build Reactive Apps - get started http://www.typesafe.com/activator.

The power of Scala keeps showing up in expected--and unexpected--places. In this talk, I will share how I used Scala in bioinformatics, neuroscience, online games, mobile applications, and desktop applications.

In bioinformatics, the beauty of Scala really shines. Thanks to the abstraction in the Scala collection framework, creating collection types for DNA, RNA, and Protein Chains is super easy. With the proper collections at my disposal, I was able to implement algorithms such as Sequence Alignment, Genome Assembly, and Gibbs Sampling by focusing on the core ideas of the algorithm and not on the nitty-gritty details. On the top of it, Scala makes dynamic programming, which is fundamental in many bioinformatics algorithms, easy to implement and understand.

Last year, I talked about using brainwaves to play games. Since then, I have taken things up a notch and started working to solve more practical problems such as maintaining attention while performing tasks (something that my age group suffers from a lot). This exposed me to a whole new and exciting world of Digital Signal Processing. This project benefited a lot from Reactive programming techniques in cleaning my code and making it more reliable.

Not to be outdone by the serious work of algorithms, I took the desktop version of Collidium and converted it to an online HTML5 Game using Scala.js. I have also improved my Android game, Wordsteal. I even used Scala with Swing to save a few bucks for our budget-starved Student Store by creating a simple cash register application.

In this talk, I will share many interesting techniques I learned and convey why I continue to be a huge fan of Scala. See you there!

Shadaj is a 13 year old, who loves to program. He has programmed in Logo, NXT Mindstorm, Ruby, Python, and C. However, he loves programming in Scala. Besides programming, he likes Math and Science. When he grows up, he wants to be a robotic scientist. Shadaj hosts his projects on GitHub, and has a channel on Youtube. He has presented at Scala Days 2012 and the Bay Area Scala Enthusiast group showing his Scala projects. When not doing his school work or programming, he plays guitar, sitar, and games, some of which he created.

To view the video visit www.parleys.com.

To get started building reactive apps visit: http://www.typesafe.com/activator.

Scala Puzzlers returns with a twist: not only will we be presenting a brand new set of puzzlers for Scala 2.11 that will challenge you with unexpected and unintuitive behavior and help you learn something about your favorite language in the process.

This time, we've added a key set of tips and recommendations to help you avoid these pitfalls when real deadlines are at stake. That's not the time for head-scratching - better to laugh and learn at ScalaDays 2014!

Andrew is VP of Products for XebiaLabs, providers of the industry-leading release automation solution, Deployit. Andrew is a cloud, service delivery and automation expert and has been part of the shift to more automated application delivery platforms.

In his spare time as a developer, he worked on Multiverse, the open-source STM implementation, contributes to Apache jclouds, the leading cloud library and co-maintains the Scala Puzzlers site.

To view the video visit www.parleys.com.

Build Reactive Apps. Get started at http://www.typesafe.com/activator.

Scala's effectiveness in rapid-prototyping is only one of the properties that make it a fantastic tool for eviscerating Git's guts. Taking advantage of the others allowed The BFG (an alternative to git-filter-branch, written in Scala) to outperform the native ‘git-filter-branch' command by a factor of 50x or more - turning an overnight job into one that takes less than 5 minutes.

This talk will share experiences from building The BFG (successfully prototyped in a single high-stakes journey on the London Underground), highlight properties of Scala that made it possible, and explain the reformed-alcoholic pattern of user behavior.

oberto Tyley is the author of Agit (the Git client for Android devices) and The BFG Repo-Cleaner (a faster, simpler alternative to git-filter-branch), a software developer at The Guardian, and contributor to various open-source projects. He's worked at GitHub, 'invented' animated diffs, and loves explaining things.

Videos available on www.parleys.com.

Build Reactive Apps. Get started at http://www.typesafe.com/activator.

Functional programming (FP) is regularly touted as the way forward for bringing parallel, concurrent, and distributed programming to the mainstream. The popularity of the rationale behind this viewpoint (immutable data transformed by function application) has even lead to a number of object-oriented (OO) programming languages adopting functional features such as lambdas (functions) and thereby function closures. However, despite this established viewpoint of FP as an enabler, reliably distributing function closures over a network, or using them in concurrent environments nonetheless remains a challenge across FP and OO languages.

This talk presents an approach for more principled distributed and concurrent programming by introducing a new closure-like abstraction and type system, called spores, that can guarantee closures to be serializable, thread-safe, or even have general, custom user-defined properties. Crucially, our system is based on the principle of encoding type information corresponding to captured variables in the type of a spore. We'll see the power of the guarantees that this safe foundation for migratable closures facilitates through a case analysis touching upon several real-world frameworks such as Akka and Spark.

To view the video visit www.parlays.com.

In this presentation you will learn how to leverage the features introduced in Akka Persistence: opt-in at-least-once delivery semantics between actors and the ability to recover application state after a crash. Both are implemented by storing immutable facts in a persisted append-only log. We will show you how to create persistent actors using command and event sourcing,

replicate events with reliable communication, scale out and improve resilience with clustering. All examples will be available as an Activator template allowing you to get started right away.

Get started building reactive applications with Typesafe Activator. http://www.typesafe.com/activator

To view the video visit www.parleys.com.

Apache Spark has emerged as the next-generation platform for writing Big Data applications. The combination of Spark and the Typesafe Reactive Platform, including Scala, Akka, Play, and Slick, gives Enterprise developers a comprehensive suite of tools for building Certified on Spark applications with minimal effort.

Dean Wampler, Ph.D. is a Consultant for Typesafe, where he specializes in helping clients succeed with Scala and Functional Programming projects. He works with "Big Data" tools like Hadoop, Spark, and Machine Learning libraries, and Reactive tools like Akka and Play. Dean is an author and a frequent conference speaker and organizer. He has a Ph.D. in Physics from the University of Washington.

The DOT (Dependent Object Types) calculus attempts to ground Scala's type system in fewer, but powerful, constructs. In this talk Nada will describe what these constructs are, and how they relate to Scala's current type system. She will also show how DOT simplifies type inference. Finally, Nada will touch upon the challenges in the meta-theory.

To view the video visit www.parleys.com.

As software developers, we learn to abhor maintaining other people's old software. It's old, funky and brittle. In fact, we spend much of our work lives trying to kill it or at the very least marginalize its use, so we can limit our exposure to it. We pity people who have to do it.

This is what we call "legacy software".

But the word "legacy" gets a bad rap. In most other contexts, it has a positive meaning.

Maybe we're just bitter. The average life span of a software system is hardly long enough to even use the word "legacy" to describe it.

How can we turn this word around? How can we leave an actual legacy of our work as software developers?

For the video visit www.parleys.com.