NEScala 2015 is all done now.
NE Scala does not select speakers for you to watch and listen to, you do.
Talks are proposed by your peers and in a short time we will open up voting polls for you to select the talks you want to see.
In this presentation, we’ll explore five years of Scala at Localytics in an attempt to distill the “good parts” - common patterns we’ve used across our code to increase productivity and reliability. We’ll examine the full gamut of practices we've found useful, including reader monads, library enrichment, test mocks in pure Scala, The Cake Pattern, and more.
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. Duncan DeVore works for Typesafe, and Co-Author of Reactive Application Development...
"Programming in Scala", by Martin Odersky et al., is one of the most comprehensive and the de facto reference for Scala. However, originally published in 2008 for Scala 2.7, it has not been updated since its 2nd edition in 2010, covering up until Scala 2.8. In the meantime, Scala had 3 major releases with numerous new and advanced features. While we wait for a 3rd edition to describe the latest and greatest Scala features introduced in the last 4 years, this talk presents the main features introduced in Scala 2.9, 2.10, and 2.11.
In this talk I'll compare and contrast the approaches to functional error handling taken by Scalaz and Scalactic. I'll look at how different opinions on typeclass coherence led to two classes in Scalaz, \/ and Validation, and just one in Scalactic, Or. I'll explain why when it comes to success values, I feel left is right and right is wrong, whereas the Scalazzi think the opposite. I'll show how the libraries use algebraic structures differently. And I'll explore how different opinions on how best to leverage functional programming (FP) in Scala led to different library designs.
How do we implement data structures in Scala? We can use Algebraic Data Types, the Visitor Pattern, or fold-s (aka. Catamorphisms). I will first show you how those approaches really are three sides of the same coin by playing variations around the `scala.Option` theme. Then I will explain how to abstract `scala.Option` so that we can switch between implementations.
Tuples and HLists impose access to record fields by their position. In processing of structured data this pattern often leads to obscure programs. I will present Scala Records, a library that uses structural types and macros to provide a type-safe API for manipulating structured data. Structural types provide a convenient interface: fields are accessed by name, IDE auto-completion is seamless, types are comprehensible, and type-errors are actionable. Macros are used specialize all field accesses and to make the compilation overhead negligible. We finish with live coding in the Spark REPL.
This talk is a how-to focusing on building a quizzo trivia game using the Play Framework and AngularJS. We'll look at implementation details on both the client and server side, including using an Akka FSM actor for game management, event-driven communication with WebSockets, and using the Ionic Framework to provide mobile applications using HTML5.
If you want to provide or consume HTTP-based APIs with Scala (or Java) then this talk is for you: Akka HTTP takes reactive high-performance web interactions to the next level. Fully asynchronous & non-blocking, with a type-safe & powerful declarative API and a proper immutable HTTP model it provides an excellent tool for connecting your Scala/Akka applications to the world. In this session we’ll do a thorough double-click on akka-http, how it is used, what improvements it brings over its predecessor spray.io and why you will not want to use anything else after having tried it.
In this presentation we'll look at miniboxing, a compiler plugin that changes the way generics are translated, allowing them to efficiently store primitive types. Compared to the standard (erased) generics in Scala, miniboxing improves the performance and decreases the heap required. And it's really user-friendly: it will tell you exactly where performance can be improved and how to do it. During the talk I'll show miniboxing at work on a stream collection, making it 5x times faster. Oh, did I mention the project's website, scala-miniboxing.org, contains all you need to get started?
Understanding type inference in Scala is a dark art. How does the compiler sometimes manage to conjure up exactly the correct type from an horrendous tangle of polymorphic method calls, while at other times drawing a blank at something that seems plainly obvious to everyone else? I'll cover the core ideas of type inference, show what works, what doesn't work, and why. I'll give really simple explanations of covariance and contravariance, and the differences between type parameters and type members, then show how you can exploit type inference with some good design and applied cunning.
We address referential integrity, a key invariant that goes unchecked in most applications. We show how approachable it can be in Scala, thanks to subtyping and path-dependent types. We present a small library named total-map that provides such a solution (github.com/boldradius/total-map). Since lookups in total maps are always successful, it eliminates important error-handling code paths and increases application reliability.
Using examples involving Play, Slick and others, this talk discusses concepts and trade-offs to help staying on top of a growing code base. Caring about the big picture constantly. Aiming for orthogonality. Avoiding unnecessary complexity. Realizing conceptual redundancies and using language-level abstractions or code-generation to resolve them. Containing technical debt when moving fast. Trying to be effective and realistic instead of dogmatic. Being serious about code quality. Types and FP can often help us, but they won't do it by themselves.
Scala.js allows you to finally throw out Javascript, and program your browser pages using Scala instead. This will be a flying overview of the tools and their status, a glance at some of the resources and libraries currently available, a look at why Scala.js is the right tool for the modern browser, and a rebuttal to the common complaint about Scala, "But we mustn't make our programmers learn another language".
A service-oriented architecture looks great as boxes and lines on a whiteboard, but what is it like in real life? Are the benefits of flexibility worth the overhead of administration? We've built a framework on top of Finagle that enables a simple approach to building and deploying a microservice with SBT and Scala.
Folds recursively apply functions to data structures, building a return value, but we must define a fold for every data structure and the functions must match the shape of the datatype. What if we could define only one fold and have our functions work for any data type? Won't it sort of solve the expression problem? In this talk I'll show Scala-reggen, an (unfinished) experiment in generic programming in Scala. Let's take a trip to category theory land, and see what we can do with folds, F-algebras, and regular functors. Beware, there will be code!
"Scala: Next Steps" outlines the roadmap for "Aida" (after 2.12) and beyond. Let's discuss how the proposed features and changes will affect the way we use Scala: which patterns may be possible that aren't so easy now, which practices might we have to adapt, (how) will the language become easier and more convenient to use? Is something essential missing to allow us to use Scala moving forward? Does the roadmap order align with how we see our use of the language evolving? Are the proposed changes are too much, not enough, or just right? Let's try to ensure Scala gets better for us together!
Without a strong answer for how they can consistently access skilled people, organizations will be less likely to adopt the language and related platforms. Scala is "hard" due to features that make it powerful but that are not found in today's most popular languages. In order to consistently "create" new Scala developers, we need to not only teach, but also establish habits, providing deep understanding of the new concepts. In this talk, I will reveal what BR has learned working with clients & share concepts and practices we use to accelerate the process of "creating" Scala skills.
It's been said before that we can program guided only by the types and the things we'd like to do with those types. But what happens if we make the types depend on the context? Instead of regular functions where we explicitly know the return type, let's use path dependent types where we don't. Let's examine what map and flatMap mean when they share the same signature. Can we get by with just one without losing the power of monadic composition? In the process of exploring these questions we'll get more comfortable with dependent types, what they are and gain insights into our every day code.
Scala is my go-to and what I have used as the platform language at my past two companies. Despite this, there are things a team should consider before adopting the language. In this talk, I plan to describe in-depth our use of Scala to build a system made up of 20+ microservices. I'll dive into what we felt were the real benefits, the pain points and some remedies for making the real-world experience more pleasant.
The Interpreter pattern is a classic object-oriented design pattern that has been overlooked by far too many for far too long. In this talk we will give this unsung hero the accolades it deserves. Please turn to page 243 in your Gang-of-Four book and follow along. Its dry description goes: "given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language." But it's so much more than that! With the interpreter pattern as our hammer, every imaginable problem becomes a nail.
Applications are evolving from a traditional monolithic model to a microservices approach designed to be HA and Scalable. CloudFoundry, a foundation and platform that has widespread industry support and enables hosting on multiple IaaS like vCloud, AWS and OpenStack. 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 leverage the platform for Scala applications.
Since the 1950's, engineering disciplines have used interval arithmetic to track and bound measurement errors. For data with known uncertainty (e.g. 43±1) interval arithmetic produces a range of possible output values (e.g. 86±2). Intervals can also be used to model and operate on contiguous sets of values. Spire's Interval type is generic and can be used with any ordered data type. In this talk we'll see how algebraic type classes support arithmetic over a wide range of types, work through some cases, and see how intervals can also be used in place of Ranges, Sets, and even loops!
Given a higher kinded type, how can you safely cast the inner type into something that might itself be a higher kinded type without being tripped up by type erasure? I'll go over a straight forward method of adding implicit guards and type safe generic casts such that the compiler can prove there will be no runtime cast errors.
Logging as a general concept is more complicated than most people realize. By the time an individual reaches this conclusion, it's often too late to do anything about it until "next time." Learn how to use a writer monad as a logging mechanism in your code. More importantly though, learn why you would want to do this, and what the benefits are. There is a price to pay in adopting this approach, but it s more "functional", addresses existing challenges, and enables new, exciting capabilities.
In this talk, I present how scala macros can be used to improve data pipeline code leveraging parquet, a columnar storage format. We use macros to generate parquet schema projection and filter predicates in compile time. Compared to the standard approach, the macros are type-safe, more concise, and user friendly.
Folds are the bread and butter of functional programming, but... from where they come? what they mean? Let's take a look how folds encode structural recursion, move beyond folding over lists and generalize to any data structures, uncovering the mysteries behind it along the way (like fold's secret relationship with map).
The landscape is littered with vast amounts of loosely typed Java - APIs that consume and return Any or equivalent wrapper classes. Scala gives us a few methods of refining loosely typed, imperative ore into stronger Scala steel. We tackle the AWS DynamoDB library as a specific use case.
Speed, correctness, or simplicity: choose 2. This is the common wisdom when implementing numeric algorithms. With floating point arithmetic, we either live with floating point errors or get stuck implementing clever, but complex ways to reduce them. If we use precise types, like BigInt or Rational, we lose the speed of primitive arithmetic, but know our result is correct. This talk will focus on another option: floating point filters. We will see how Spire's FpFilter type let's us keep the speed of Doubles, the precision of BigInt, Rational or Algebraic, and with no complex error analysis.
Your web application probably needs to play nicely with CORS requests from web browsers. This talk will look at how to do that in a Play Framework application.
The Scaladoc page for Option says: "The most idiomatic way to use an scala.Option instance is to treat it as a collection or monad and use map, flatMap, filter, or foreach [...] A less-idiomatic way to use scala.Option values is via pattern matching." After this talk, you will never have to write "match { case Some(a) => ???; case None => ??? }" again.
In this talk I will outline my experience in setting up a CD pipeline in Jenkins for an sbt-based Scala project. I will discuss the combination of Jenkins plugins, sbt plugins, and sbt file setup that I use in the pipeline to get artifacts published to Bintray and deployed to a cloud runtime.
Give me 15 minutes and I will ask for a whole lot more! Ever wanted to feel more involved in the Scala community? Well now is your chance. We are rejuvenating the Scala contributor ecosystem and in this, perhaps the most important 15 minutes of your life ;-), you can find out how YOU can help. We'll talk documentation, bug fixes, core libraries and even big compiler changes, all in the time it takes to enjoy a latte.
Connected components are subgraphs in which all nodes are connected via one or more paths. Calculating this for a graph which is much larger than working memory is a bit tricky. This talk will cover how it can be done using Scalding, a Scala API for writing Hadoop MapReduce jobs.
Oftentimes we spend most of our engineering efforts designing for other people. However, there are lots of utilities that we could develop to increase our own productivity. This talk gives a short tutorial for how to do the minimum amount of work creating and deploying a command line tool, including how to share and create a rich interface. We'll cover the basics of: Conscript vs. sbt-native-packager, the sbt autocompletion library and general ANSI fun in Java.
Scalding is a Scala library that makes it easy to build Hadoop MapReduce jobs. It's easy to write a job that maps/joins and reduces Big Data to small data. But when we run it in production it takes too long. It steals computation resources from other jobs. How to make it faster? How to scale it if you have big Hadoop cluster? In this talk I'll share my recipes. How to reuse results of computations. How to choose optimal # of reducers. How to make it 2 m/r jobs not 22. How to fight hot keys/reducers. How to use parquet format. If my talk is not selected for the 1st day I can do it on the 2nd!
At @nescalas 2012, I complained that Hadoop's MapReduce is the "EJBs of our time." Hadoop, and Big Data in general, needed Function Programming and an alternative to Java. Fast Forward three years later and we find that Scalding proved that a Scala DSL is far superior to the MapReduce Java API, and Spark is now replacing MapReduce altogether. (High Fives all around!) I'll demonstrate why this happened and argue that Big Data is the Killer App for FP and Scala.
In this talk, I go through the most common arguments I've seen for why Scala is 'a poor technical choice' in an otherwise appropriate situation. Point by point, we'll review these concerns, poke a few holes and provide the necessary counter-evidence. My goal with this talk is to give people knowledge they can leverage to advocate introducing Scala in their work places.
In fifteen minutes, using a real life example, I'll show you how to use constructor injection to enforce the high level constraints of your application design. This turns out to be a very simple, powerful, and elegant approach to doing dependency injection. Your system architecture is no longer something that exists only on paper, to get outdated and forgotten over time.
Have you seen a type signature like this before? trait T[U <: T[U]] F-bounded polymorphism, also know as self-referential types or recursive type signatures, is a powerful object-oriented technique that leverages the type system to encode constraints on generics. This talk explain how to define and use F-bounded types in Scala, enlisting the compiler to enforce advanced trait semantics meanwhile greatly reducing and simplifying your unit tests.