Scala Days

Microservices architecture are becoming a de-facto industry standard, but are you satisfied with the current state of the art? We are not, as we believe that building microservices today is more challenging than it should be. Lagom is here to take on this challenge. First, Lagom is opinionated and it will take some of the hard decisions for you, guiding you to produce microservices that adheres to the Reactive tenents. Second, Lagom was built from the ground up around you, the developer, to push your productivity to the next level. If you are familiar with the Play Framework's development environment, imagine that but tuned for building microservices; we are sure you are going to love it! Third, Lagom comes with batteries included for deploying in production: going from development to production could not be easier. In this session, you will get an introduction to the Lightbend Lagom framework. There will be code and live demos to show you in practice how it works and what you can do with it, making you fully equipped to build your next microservices with Lightbend Lagom!

Imagine a world where writing and maintaining build scripts is fun and not black magic. A world without axis-scoped-multi-config-multi-project builds. With fast dependency resolution. Intuitive and statically checked build configuration. Where large builds use few and simple building blocks to compose small, self-contained and easy to understand builds. Where you only need to learn a small Scala library nothing more. Welcome to CBT - fun, fast, intuitive, composable, statically checked builds written in Scala. This is not a prototype. It's ready for prime time. This talk gets you started writing your own CBT builds. We'll do live coding and explain the philosophy behind CBT. If time permits, we'll dive into CBT's actually small and easy to understand code base.

Machine Learning to some is still very magical. The truth however is that this magic is actually much easier to use than you'd expect. Come and learn how you can use Apache Spark and Akka together to build a service that recommends items to users. In this session, I'm going to show you some of the bits that go into building a recommender system, how to actually implement one in Spark and finally how to integrate the recommender system into your application using Akka HTTP.

In the past year, all of my projects have involved using Scala with some moving entity: musical notes, robots, garage doors, and so on. In this talk, I will show how Scala has been consistently helpful, no matter what I throw at it.

In a research project to categorize and identify musical recordings, Scala made a complex processing pipeline look beautiful with its collections. Processing pitches, building musical models, and applying machine learning algorithms could each be implemented as a data transformation.

On my high school robotics team, I was able to use Scala.js and Akka-HTTP to build a web-based dashboard for viewing live sensor and control loop data, as well as running automated calibration routines. The simplicity of both Scala.js and Akka-HTTP made it easy to send data produced by simple functions to clients over a WebSocket and have clients render the data as it arrives.

A combination of Akka, Play Framework, and Scala.js built Ash, a home-automation system with easy extensibility. Modeling server and client portions as actors allowed for easy communication between them. Akka also became a unifying factor for working across a diverse set of hardware -- PCs, mobile devices, and Raspberry Pis

One of the great benefits of the Lightbend ecosystem is its ability to empower great scalability, and it is often considered for this very reason.Indeed, if employed correctly, Scala, Akka and the rest can make it possible to much more easily write systems that scale up (and out) to extremes. However, not every design is able to scale, and the approach and architecture can sharply limit this option, no matter how good the tools. What does ""perfect scalability"" look like? Is there even such a thing? Can systems be designed to scale virtually without limit? Where does the pattern break down, and what can you do about it?

In this session, we will examine the practical architectural constraints on systems intended to scale up in near-linear fashion. It turns out that having the ability to scale to extreme load is more about what not to do than it is about what to do. Why do some system scale up and others don't? How can you take a design that has problems and refactor to a design that has fewer limits? Our teams encounter these problems every day, and we keep track of what works and what doesn't in the real world. What have we seen in the field? What proven real-world design and architecture approaches can we use to help ensure our systems can scale, and what should we avoid? How can we leverage the power of the Lightbend platform to architect such systems? Which parts for which kinds of problems? How does Akka and the actor model fit these patterns? How does Spark, Kafka, Akka streaming?

Highly scalable systems often put together tools such as Docker, Ansible, Salt, Mesos, ConductR with techniques such as microservices, monitoring, and continious delivery. Automation of the deploy pipeline and deep performance monitoring are essential parts of highly scalable systems - we will look at examples of such systems, and which of the tools in the stack they employ, and why. In this talk, we'll examine both the practices and the pitfalls, and what combinations we have used to scale not only within single clusters, but across data centers for continent-spanning applications where required.We will use use-cases all the way from massive IoT scale wearable devices all the way to high finance, and find the commonalities in the solutions that don't limit their own expansion. If your organization needs to take your scalability to significantly higher levels, this talk will be where you need to start.

Why do developers love IntelliJ IDEA? Because it takes care of all the routine and provides intelligent coding assistance. Once you master it, the productivity gains are quite surprising. In this session I'll show you the 30 hidden gems of IntelliJ IDEA that will help you become a more productive Scala developer. 

Building a complete system out of individual Microservices is not as simple as we're being told. While Microservices-based Architecture continues to draw more and more attention we're also starting to learn about the trade-offs and drawbacks. Individual Microservices are fairly easy to understand and implement, but they only make sense as systems, and it is in-between the services that the most challenging (and interesting) problems arise—here we are entering the world of distributed systems.

As we all know, distributed systems are inherently complex and we enterprise developers have been spoiled by centralized servers for too long to easily understand what this really means. Just slicing an existing system into various REST services and wiring them back together again with synchronous protocols and traditional enterprise tools—designed for a monolithic architectures—will set you up for failure.

This talk is going to distill the essence Microservices-based systems and then introduce you to a new development approach to Microservices which gets you started quickly with a guided, minimalistic approach on your local machine and supports you every single step on the way to a productive scaled out Microservices-based system composed of hundreds of services. At the end of this talk, you've experienced first hand how creating systems of microservices on the JVM is dead-simple, intuitive, frictionless and last and more importantly—a lot of fun!

At the keynote at Scala Exchange, Jessica Kerr mentioned that there is very much documentation for starting and expert Scala developers but (almost) nothing in between. In this talk I want to demystify implicits. Implicits are a fairly advanced feature and a very important aspect of the Scala language. They help with writing concise code and enable lots of DSLs. On the other side, they can be very magical for an untrained eye. In this talk, we will delve into idiomatic use cases of implicits and how the Scala compiler resolves them. If time allows, we will jump into type classes as well.

In this talk we will go over the architecture and implementation of a large-scale graph analysis engine using Scala, Akka and Hbase. Starting from the needs that led to this type of processing, we’ll go through the different implementation considerations, jump into an implementation that includes a query parser and an akka cluster to do the processing, and then see how we can produce a stream output of the results. This talk could benefit anyone that is interested in Scala, Akka, Big Data, stream processing and of course graphs.

Description

Big data and fast data are definitely the buzz words of the last couple of years, but they’re telling us something – people want to get insights out of large amounts of data, whether it’s moving (""fast"") or static. In many companies, and such is the case at Capital One, the basis for generating these insights is data analysis and model building, which requires the ability to get to the data easily.

Getting the data easily is a major pain point, especially at large enterprises – Imagine, what if you needed to integrate massive amounts of data across hundreds or thousands of different sources and then deliver that data in a variety of formats and in a specific “schema”? Add to that, what if that “schema” can change on a whim based on the needs of the business?

That’s where Scala, Akka and graphs come in, and specifically their use for integrating data, sourced from multiple locations, and then delivering that integrated data for analysis via queries, APIs and other interfaces in a distributed, stream based and highly efficient manner.

This talk will start by presenting the need, and then go through an in-depth look at how we took Scala and Akka (Cluster, Remote, Persistence), along with Spark, Kafka, Hbase and other tools to create a graph analysis engine (database) that provides a self-service data computation and delivery platform at Capital One.

A collection of horror stories that derive from a lack of best practices. Everything will be covered: How to make companies lose money, shutdown systems and disable payments (or worse) just from overlooking simple procedures that "take too much time" or "cost too much" to implement. We may even dim the lights at certain points in the presentation.

Finagle is an extensible RPC system for JVM written in Scala that is used and developed at Twitter. It promotes a programming model where servers and clients might be viewed as functions, which are both easy to compose and reason about. Although, there is quite a complex logic (connection pooling, load balancing, circuit breaking and so on) hidden behind those functions. In this talk, we'll dig into Finagle internals and carefully walk through each of its modules to see what happens when we a) send a request to a Finagle client b) receive a request by a Finagle server.

Processing streaming data is becoming increasingly important in many areas. Scala and the Lightbend Reactive platform offer multiple solutions for processing streaming data, including Akka, Akka Streams and Apache Spark. This talk introduces the advantages and concepts of streaming data processing. It will mention differences between static data and data in motion and their usage as streaming data sources. The main goal of the presentation is detailed discussion of Akka Persistence Query and implementation of the stream production specification in Cassandra plugin for Akka Persistence (akka-persistence-cassandra) that the author participated in. Focus is on architecture and design considerations, implementation details, performance tuning and distributed system specifics such as correctness, efficiency, consistency, order, causality or failure scenario handling that are inherently part of the solution and apply to wide variety of distributed systems. Finally, other improvements to the Cassandra plugin for Akka Persistence project such as reusing the stream generation for non blocking asynchronous Akka Persistence recovery as well as application of the project and the discussed concepts to build modern reactive enterprise stream processing and asynchronous messaging distributed applications are presented.

Domain Driven Design has been a game changer in my career.  Combined with Onion Architecture it has made improvements to my code, in both readability and maintainability.

Scala is ideally suited to Domain Driven Design.  Case classes and traits allow us to rapidly prototype a domain.  We can iterate over that domain quickly as we build. This makes it trivial to specify a rich description of a domain with very little code, and minimal investment of time.

Onion Architecture provides us with the tools needed to create clean package structures. It provides a framework for creating the abstraction layers to allow your code to be portable, testable, and easier to maintain.

In this code-driven talk, I will explore the techniques I developed while using Domain Driven Design and Onion Architecture in Scala.  I will discuss key features such as Repositories, Services, Aggregates, Bounded Contexts and more. I will explore how Onion Architecture can be used with Domain Driven Design to build up applications in fully portable layers.

What does it mean to think like a functional programmer? Why is it so hard to adopt functional programming if you are steeped in OO? In this talk, I'll address these questions, using ideas from the philosophy of science. The talk will give new insight into the process of becoming productive in Scala and the mindset needed to aid this process. Using the framework of "The Structure of Scientific Revolutions", we can see programming as undergoing three revolutions: Structured programming, object-oriented programming, and now, functional programming. Each revolution brings with a new paradigm - basic assumptions and values that make moving across paradigms difficult to achieve. In this talk, I'll describe the paradigm of the functional programmer: What is valued and what is considered good code. I will contrast this to the paradigm of the object-oriented programmer and finally consider if it is possible to reconcile these two approaches to programming.

In order to be successful with asynchronous / reactive programming, when coming from synchronous execution models, you need to change your mindset and look at things from a slightly different perspective. In order to use Akka at it's best, you will have to change the way you think about application design (loosen coupling in space and time between components), and re-think what you've maybe learnt in the past. In this talk we uncover a number of rules that serve as a guide in designing concurrent distributed applications, how those apply to Akka and how they can help you in daily app development.

Doing I/O in Scala (and Java) involves either invoking some magic "FileUtil" or browsing through StackOverflow. In this talk, we will introduce better-files (https://github.com/pathikrit/better-files) - a thin wrapper around Java NIO to enable simple, safe and sane I/O in Scala. We will also discuss problems with designing an I/O library that would make everyone happy and different schools of thoughts e.g. monadic vs non-blocking vs effect-based APIs

Scala has historically been a JVM-centric programming language. The situation has started to change with appearance of the Scala.js that opened a door of front-end development to Scala programmers. This talk will expand the horizons of Scala even more. We’re going to announce a new ahead-of-time compiler and lightweight managed runtime designed specifically for Scala.

In this talk, we are going to discuss various state of the art open-source distributed streaming frameworks, their similarities and differences, implementation trade-offs, their intended use-cases, and how to choose between them. I’m going to focus on the popular frameworks including Spark Streaming, Storm, Samza and Flink. In addition, I'll cover theoretical introduction, common pitfalls, popular architectures and many more.

The demand for stream processing is increasing. Immense amounts of data has to be processed fast from a rapidly growing set of disparate data sources. This pushes the limits of traditional data processing infrastructures. These stream-based applications include trading, social networks, Internet of things or system monitoring, are becoming more and more important. A number of powerful, easy-to-use open source platforms have emerged to address this. My goal is to provide comprehensive overview about modern streaming solutions and to help fellow developers with picking the best possible decision for their particular use-case. This talk should be interesting for anyone who is thinking about, implementing, or have already deployed streaming solution.

In ScalaTest 3.0's new async testing styles, tests have a result type of Future[Assertion]. Instead of blocking until a future completes, then performing assertions on the result, you map assertions onto the future and return the resulting Future[Assertion] to ScalaTest. The test will complete asynchronously when the Future[Assertion] completes. This non-blocking way of testing requires a very different mindset and different API. In this talk, Bill Venners will show you how async testing was integrated into ScalaTest and explain what motivated the design decisions. He'll show you how to use the new features, and suggest best practices for async testing on both the JVM and Scala.js.

Jan's talk will give overview of the major components in a ML connected fitness system built on the Lightbend platform. Jan will then show the most exciting aspects of the Akka and Spark code: The Akka cluster and CQRS to handle the volume of users; the Spark code to compute the models for the users. Naturally, the talk will include the infrastructure code for continuous deployment and monitoring of the entire system. As usual, expect a nerve-wracking live demos! Jan closes with lessons learnt in maintaining and evolving the system, helping you avoid the typical pitfalls in Akka & Spark systems, and hopefully motivating you to "have a go" at designing and implementing similarly complex systems yourselves!

Typeclasses are a hidden gem of the Scala language. They provide an immense power not seen in imperative languages, and so their approach might be unusual or alien to those approaching Scala from an imperative background. I will show how typeclasses allow developers to effectively attach their own interfaces to code written by others. In this talk, I describe what a genetic algorithm is and provide an example implementation in Scala. Using this implementation, I will demonstrate how to define a specific typeclass for our problem. I will then derive several different implementations, showing how to get rock solid confidence in testing our algorithm - with the help of ScalaCheck - and then provide a completely different typeclass to provide a fun, visual and creative solution, illustrating the iterations and improvements as the genetic algorithm’s fitness function runs. The talk will be particularly hands-on, with plenty of examples run directly from the REPL.

Deep Learning is taking data science by storm. Unfortunately, most existing solutions aren’t particularly scalable.In this talk, Andy will show how to easily implement a Spark­ ready version one of the most complex deep learning models, the Long Short­ Term Memory (LSTM) neural network, widely used in the hardest natural language processing and understanding problems, such as automatic summarization, machine translation, question answering and discourse. He also shows an LSTM demo with interactive, real­time visualizations using the Spark Notebook and Spark Streaming.

Transitioning from a monolithic application to a set of microservices can help increase performance and scalability, but it can also drastically increase complexity. Layers of inter-service network calls for add latency and an increasing risk of failure where previously only local function calls existed. In this talk, I'll speak about how to tame this complexity using Apache Kafka and Reactive Streams to:
- Extract non-critical processing from the critical path of your application to reduce request latency
- Provide back-pressure to handle both slow and fast producers/consumers
- Maintain high availability, high performance, and reliable messaging
- Evolve message payloads while maintaining backwards and forwards compatibility.

Normally, we use Java or Scala to build applications for large organizations running on servers. We wanted to find out if we could use the same languages and tools on IoT hardware. We also wanted to investigate whether or not (remote) actors could replace REST endpoints. The Lego trains are equipped with a Raspberry Pi, camera, wireless dongle, infrared transmitter, speaker, RFID reader, and battery pack. Next to that, we have automated switch tracks a Lego Ferris Wheel and camera's again with the help of Raspberry Pi's. We also built some lightning effects with LEDs controlled by Particle Photon’s. To control the trains and other parts, we built a remote actor based application with Scala, Akka, Akka HTTP and AngularJS. We will show you when and how to use Akka HTTP and remote actors. We will also show the results of the performance tests we did to compare the two options. Next to that we will talk about our experiences and challenges and of course we will give a live demo!