Amanda Laucher has been working with technology her entire life. Some of her favorite childhood memories include working with punch cards alongside her grandmother or learning Morse code from her dad. Solving complex business problems with code is her passion. She is Co-Founder of Mined Minds, a bootcamp style training, and consultancy which facilitates career transitions from coal to code and the diversification of rural economies. You are likely to find her discussing intricacies of languages and type systems, development processes or American football.
Reactive application architectures have become increasingly common in the past few years, mostly involving isolated service architectures that communicate via HTTP Rest APIs and/or Kafka messages, all deployed in the cloud with orchestration. While these approaches have worked, they are fundamentally expensive in resource usage and synchrony. In this talk, I will describe the architecture for where Starbucks wants to go next, why we’ve chosen these approaches and how we plan to get there, with Scala and Akka, but also with other technologies such as HTTP/2, gRPC and linkerd.
Jamie Allen is the Director of Engineering for the Unified Commerce Project at Starbucks, leading all backend service development in support of our strategic customer-facing business goals. Previously, Jamie was the Senior Director of Global Solutions Architects and head of Global Services for Typesafe/Lightbend. Jamie has been a Scala developer for 9 years, and is the author of Effective Akka and co-author of Reactive Design Patterns.
"In the world of distributed microservices, we face many challenges; parallelism, asynchronous boundaries, state management, identity management and consistency deficiencies to name a few. Of all these problems, consistency, state management, and identity management can be particularly challenging.
In this session, we will discuss the ins and outs of dealing with microservice consistency and distributed state and identity coherency with techniques like idempotency, eventual and casual consistency, dealing with CAP theorem, single source of truth and distributed domain design."
Duncan DeVore is co-author of "Reactive Application Development", Senior Software Engineer at Lightbend on the monitoring team, open source developer and frequent speaker. He has been an avid Scala developer since 2009, holds two patents for software design and led the release of one of the first large-scale Reactive applications in 2012.
Target audience level: Beginner, IntermediateDomains are the "business" stuff of our applications, quite often fuzzy, ill-defined, or inconsistent in known (or unknown!) ways. But we can find and apply more structure to them through the ideas of an algebra: something with symbols, operations and laws. Once we have this better structure, we can then use some common techniques to analyze it and make assertions about it. This talk will teach you how to construct domain algebras from scratch, or from your existing code, and we'll show off the induced benefits of better abstractions, along with greater modularity and testability.
Target audience level: Beginner, IntermediateScalaQuest is a fun, enticing game that will take you from Zero to Hero in your path to learning Scala (1).
You will battle Goblins and Wizards and face all kinds of challenges to prove your worth.
Start on the warm, safe haven of plain harmless Classes, hike over Variance Hills and make your way to the trecherous Implicit Forests.
Our goal with ScalaQuest is to make it one of the least painful ways to learn Scala.
This might be the first time you ask your team members to play a game during work hours.
In this talk, we will showcase our work in progress with ScalaQuest, and share our experience building it - our design decisions and the challenges we've faced.
We will then focus on the technical challenges related to compiling user-submitted code on the server side while trying to keep a snappy UI.
I have a strong passion for teaching and coaching others, and I'm lucky to do a lot of professional training in Scala, Akka and Play. This has allowed me to interact with hundreds of people who are new to these technologies, as well as many other experts in charge of building and supporting the platforms.
I also contribute to the Scala community by organizing Scala Up North, the very conference you're reading about now :)
Target audience level: BeginnerThis talk will show how to apply hope, faith, and proof to write the best code you can. It will compare and contrast the three, then pick a winner. Along the way, this talk will look at types and tests from a new angle and highlight a new kind of assertion that deserves a place in your toolbox.
Target audience level: BeginnerScalaz is a modular functional programming library for Scala which provides purely functional data structures to complement those from the Scala standard library. This session will provide an introduction to Scalaz and functional programming in Scala. I’ll explain and demonstrate a few data structures from the Scalaz library including OneAnd for non-empty collections, / for handling success/failure conditions, and Validation for validating non-dependent data. I will also cover how to simplify operations on types like Future[Option[A]] and Option[Either[A, B]] with OptionT and EitherT.
Target audience level: IntermediateStream processing is a hot topic today and it’s easy to get lost among all the possibilities. In this live coding session we will explore the Reactive Streams approach used by the Akka Streams project. On an almost real-life example we’re going to walk through both the basics and some more advanced usages of the library.
Target audience level: BeginnerPlay Framework is fast, and most of the time it works out of the box as-is. But when requests are slow, how do we debug the slowness? This talk will go through some strategies and tools to troubleshoot a slow Play app and issues you may run into including: GC pauses, resource starvation, and other runtime issues.
Target audience level: IntermediateCreating User Interfaces has traditionally been a mostly imperative matter and building UIs in a functional way has never really been easy.
In this talk we’ll learn how to build UIs using only pure functions with the help of Scala.js and Reactive Programming. We will explore OutWatch, a new UI Library based on Rx, look at what works well, identify more challenging tasks and unlock the full potential of functional design and type safety with Scala in the browser.
Target audience level: BeginnerLet’s have some fun with Kubernetes and Akka Cluster. In this talk we’ll spin up a production-ready Akka cluster in seconds through the power of Kubernetes. We’ll deploy, update, scale and randomly kill nodes just to watch them recover automatically, all without touching any underlying infrastructure. If we still have time, we’ll even add Akka persistence to the mix. See how easy it can be to get started with Akka Clustering on Kubernetes.
What is Kubernetes? Kubernetes is a Docker container orchestrator from Google. It enables us to automate the deployment, scaling, and management of containerized applications.
I am an experienced presenter comfortable with speaking to large groups. I was a speaker at the 2015 Pacific Northwest PHP Conference where I spoke about splitting up our PHP monolith into Scala microservices and I’ve spoken at the Vancouver Scala Meetup on Akka Clustering
Target audience level: BeginnerFunctional Programming has many corollaries to Music - Pattern matching, data structures, asynchronous/synchronized data, and even the way the human brain reads, writes, and interprets each form of communication
Finding the beauty in music is easy - we use one of our 5 senses to ingest it and based on how harmonically related the frequencies are, more often than not, they create a pleasing sound. But functional programming doesn’t affect our senses - we have to use our vision to see it, but it really comes much more down to mathematics and compression.
But based on the corollaries between the two, I will show that there is in fact a tangible beauty in software engineering - this talk delves into what makes art (music) beautiful, how it's made so, and how software engineers fill/employ the same roles/tactics to make their code beautiful.
Favorite Colour? Purple.
Favourite Number? 3.1415926535...
Astrological Sign? Gemini.
Global Tech Conference Presenter? Yes.
Scared of Bears? Nope.
Music Preference? EDM / Hip-Hop.
Certified Spin Instructor? Yup.
Favourite Fictional Character? Batman.
Most Over-Used Letter? ‘U’.
Favourite Technology? Scala.
Spoken Word Poetry? Hobby.
Fitness / Nutrition? Passion.
Why. So. Serious? No.
Cards or Ping-Pong? You will lose at either.
Where’d you grow up? NY.
Did you ever REALLY grow up? Caught me.
Target audience level: IntermediateWe will talk about Spotify's story with Scala big data and our journey to migrate our entire data infrastructure to Google Cloud and how Justin Bieber contributed to breaking it. We'll talk about Scio, a Scala API for Apache Beam and Google Cloud Dataflow, and the technology behind it, including macros, algebird, chill and shapeless. There'll also be a live coding demo.
Target audience level: IntermediateNowadays Akka is a popular choice for building distributed systems - there are a lot of case studies and successful examples in the industry.
But it still can be hard to switch to actor-based systems, because most of the tutorials and documentation don't show the way to assemble a real application using actors, especially in microservices environment.
Actor is a powerful abstraction in the message-driven environments, but it can be challenging to use familiar patterns and methodologies. At the same time, message-driven nature of actors is the biggest advantage that can be used for Reactive systems and microservices.
I want to share my experience and show how Domain-Driven Design and Enterprise Integration Patterns can be leveraged to design and build fine-grained microservices with synchronous and asynchronous communication. I'll focus on the core Akka functionality, but also explain how advanced features like Akka Persistence and Akka Cluster Sharding can be used together for achieving incredible results."
Yaroslav Tkachenko is a Senior Software Engineer, Lead at Mobify. He is leading the new Platform team and responsible for development, delivery and maintenance of various components. He also works with the Engagement Engine team to improve the realtime analytics pipeline.
Before that Yaroslav was a Director of Engineering at Bench Accounting. He joined the company as a first employee (and a first Software Engineer) and helped to grow the engineering team from 3 to almost 30 people.
At Bench Yaroslav worked with Platform and Integrations teams and was mostly focused on designing and implementing microservices architecture using various stacks (Scala, Node.js), building low-level infrastructure and contributing to DevOps tooling.
Target audience level: Beginner, IntermediateOften, abstract algebra is delegated to the ‘strictly theoretical’ category of computer science, and ignored in favor of practical programming. In this talk, we give a primer for understanding some of the fundamental algebraic structures (Semigroups, Monoids, Groups, Lattices), as well as some practical applications you can throw in your manager’s face the next time they question your glorious power.
Target audience level: Beginner, Intermediate
Good functional programming practice is to write the overwhelming majority of the logic in pure functions, pushing IO to the "end of the world". This makes the pure part of the codebase easier to test, but leaves us with a "last mile problem" -- testing that our IO code does in fact hook up to the outside world in the way we expect. This talk discusses a unification technique which allows the unit testing suite to simulate end-to-end data via pure code implementing the same interface that IO code does. This obviates the need for separate "mocking" libraries or "interceptor" tests, and allows us to specify from the very beginning (a) the expected datatype of our IO methods, and (b) which ones have the possibility of failure. We will also discuss the unexpected benefit that our team gleaned from this pattern, namely a zero-pain transition from one database implementation to another.
Matthew Smedberg flatMaps like a boss at Athlinks (LifeTime Fitness), where streaming data rules the land and every day is a new PR (that's "personal record", not "pull request"). He has a Ph.D. in mathematical logic from Vanderbilt University and performs baroque and medieval choral music in his spare time.
Target audience level: BeginnerThe core tenet of Agile software development is embracing change. Changes in specification, strategy and technical direction are expected and the team must have the process and tools to easily adapt and deliver. Traditionally, the so-called "dynamic" languages have been associated with agility, but we argue that Scala's type system is a much better tool for agility, by making refactors much simpler even in huge codebases, Scala embraces change more effectively, so it's one of the best choices for the Agile team today.
Target audience level: IntermediateWriting tests is so... boring. And repetitive. And often, in hindsight, rather ad hoc, and therefore ineffective. In this workshop we'll learn about property-based testing using ScalaCheck: how it compares to unit testing, when is it better (or worse); learning about different families of invariants and when they are appropriate for your code; how to structure the tests using the main ScalaCheck abstractions, run them, and debug them; and how to test stateful systems. We will write lots of code! And your code will write lots of tests!
Target audience level: BeginnerScala is an unopinionated language: It offers a wide array of choices, from familiar object-oriented features to sophisticated functional programming tools. While these choices offer great freedom, they can be bewildering. This workshop aims to help you learn the most effective ways to apply Scala to real-world programming problems.
Your instructors will present concise guidelines and encourage debate among all the attendees. Following each presentation you will have the opportunity to practice applying the guidelines to concrete programming problems. Each exercise session will be followed by show and tell and more discussion.
We will assume you know Scala already, but need not be an expert.
Target audience level: IntermediateThis hands on live coding session will get you started using both Akka HTTP and Kafka and have fun writing a async chat application in Scala.
In Akka HTTP you will learn how to create and deploy a couple of rest endpoints for both GETing and POSTing data.
In Kafka you will learn how to add Kafka to your application publish messages and receive messages even on multiple clients.