Northeast Scala Symposium 2020
Proposed Talks

Vote for your favorite talks here! (also don't forget to get your ticket, for your vote to be eligible

Long Talks (45 minutes)

Careful With That Hammer, Eugene... (Toward Simpler Scala)
Audience Level: All

Put the hammer down, you don’t need recursion schemes to parse a JSON file! This talk introduces the principles of Simple Functional Programming, a way to make advanced Scala code approachable to newcomers. We’ll dive into real life code examples, uncovering common anti-patterns and their antidotes.

From Zero To Deep Learning With Scala
Audience Level: Beginner

Deep learning is awesome, trendy and… mysterious for many.

This talk introduces AI / deep learning from scratch to an audience familiar with Scala and provides a unique case (dataset + code) for attendees to start experimenting! Features a live demo with a Raspberry PI on stage.

How Metals and LSP allow you to use your favorite editor for scala
Audience Level: All

With the popularity of LSP and the growing adoption of Metals, let’s take a close look at what the Metals toolchain looks like. We’ll dive into terms and tools like Bloop, BSP, LSP, and SemanticDB giving you an understanding of not just what the Metals toolchain is, but how it all works together.

Magnolify all the Things
Audience Level: All

We’ll dive deep into Magnolia-based type class derivation for various things, including ScalaCheck, Cats, Guava (yes really) and data type conversions. We’ll also discuss interesting problems like recursive ADTs, implicit prioritization, property-based testing and Scala 2.13 migration.

No Need for NIH: Leveraging the Typelevel Stack in the Enterprise
Audience Level: All

There’s a joke that a framework is a product with the business logic removed, but all the assumptions left in. In this talk we’ll explore an alternative: solving the most common enterprise issues with the composable ecosystem of Typelevel libraries, avoiding not-invented-here (NIH) and lock-in.

Scala eDSLs for domain-specific business logic
Audience Level: Intermediate

A powerful pattern in functional programming is embedding small, declarative languages into a host language. I will demonstrate three interpreted eDSLs in Scala that solve three real business problems; time-series financial math, formatting financial reports and working with large data-frames.

Streams - Your New Favorite Primitive
Audience Level: All

Dive into generic streaming with FS2 and explore how FS2 - and streaming libraries in general - can often be the simplest way to solve many common issues. We’ll also examine fallacious definitions of “necessary/simple” in software and why learning new tech doesn’t have to make code more complicated.

Understanding Monix Observable
Audience Level: Intermediate

Monix Observable is a streaming data type which marries ReactiveX with purely functional programming in Scala.

Let’s dive deep into its internals, explain how and why it works and what are some of the less pleasant consequences of its design.

Understanding sharding and CRDT with Raspberry Pi Akka cluster
Audience Level: Intermediate

Understanding how to use distributed data, like sharding and CRDT in Akka cluster is well worth the effort. In this workshop, we will use Raspberry PI cluster with displays to reveal the internal state of each node. We’ll see different scenarios and discuss their consistency with the CAP theorem.

Medium Talks (30 minutes)

Catching More Bugs at Compile Time with Phantom Types and Implicits
Audience Level: Intermediate

Are you writing a library for your team? Are you encountering bugs or runtime errors that you suspect can be found earlier? Learn how to use the magic of implicits with phantom types to catch more bugs at compile time!

Change Data Capture in Distributed Systems
Audience Level: All

Services usually have data stores with various characteristics. A requirement emerging from distributed architectures is the need to capture data changes in primary stores. In this talk, I will discuss how to use Change Data Capture pattern to track these changes and share our experience with it.

Conquering Version Hell
Audience Level: Intermediate

Scala is a wonderful language for enterprise-scale software. But if you have a big group, with many shared libraries, those eviction warnings can go from being a minor annoyance to an existential threat. We will discuss binary compatibility, shading, and a new JSON library that came out of this.

How to Eliminate Surprises In Your Data
Audience Level: Beginner

How do you know you can trust the accuracy of the data flowing through a pipeline, and the insights derived from it? At Spotify, we’ve made both cultural changes and Scala tools to increase confidence and eliminate surprises in our data contents, and solve problems in the wide space of data quality.

Learning to Teach Scala
Audience Level: All

Scala knowledge doesn’t scale easily and some even claim that the language is complex. But make no mistakes, Scala is not a complex language to teach or learn; the learning process is what is complex by itself. This talk aims to show how learning works, using prior OOP knowledge to learn Scala.

liberty, equality, and boxed primitive types
Audience Level: All

This talk is all about == in Scala. Seemingly simple, but == has evolved throughout the history of Scala, and it’s underspecified in the language spec. This is part investigative journalism and, part activism because Scala 3.x is coming up and we have a once-in-a-lifetime opportunity to fix to ==.

Macroless Data Pipelines
Audience Level: Intermediate

We’ll show how Magnolia based type class derivation can be applied to Hadoop-era Java API. We use Magnolia to derive Parquet read/write support for type-safe IO of Parquet files with Scala types. We’ll discuss the difference between macro & magnolia-based approaches.

sbt: its history and future
Audience Level: All

I want to look back at the evolution of sbt, what build tools, ideas, and people had influence on it. What was the motivation behind super shell for example?

Also I’d like to discuss recent developments, how the new ideas are incubated, and talk about big ideas for the future.

ScalaNullSafe: A Macro-Based Approach to Null Safety in Scala
Audience Level: Intermediate

The dreaded NullPointerException is something most Scala and Java programmers are familiar with. Making your code null safe is a difficult task as Scala’s type system doesn’t keep track of possibly null references. I developed a macro-based library to make making your code null safe fast and easy!

The Application and Algebra of Finite State Machines
Audience Level: All

Finite state machines are a great way to model web services, data validation, animations … just about anything! In this talk we will delve into the use and representation of finite state machines in Scala. We’ll see what they can do, and how easy they are to use.

Understanding Scala's Type System
Audience Level: Intermediate

Scala has many types of types. This talk will take you on a tour of Scala’s type system, show you how it is evolving in Scala 3, and help you understand how everything fits together.

What's Old is New Again! Adventures in Metaprogramming with Scalameta
Audience Level: All

How can we take some re-usable code for asynchronous, schema-less data science backend integration, and give it the type-awareness it needs to comply with new schema requirements? Scalameta, code generation, and an sbt plugin to the rescue! The Go4 Decorator re-imagined with a bit of a typing twist!

Comonads and the Game of Life
Audience Level: Intermediate

Have you heard of Conway’s Game of Life? How about comonads?

Let’s put these two things in conversation and implement the Game of Life in Scala!

Lightning Talks (15 minutes)

Analysis of Zinc
Audience Level: Intermediate

When you compile Scala using a build tool, Zinc is called to do incremental compilation. But how does that work? This is a talk to explain what’s going on in Zinc.

Bringing Scala to a Diverse Group of Students
Audience Level: All

We want to tell you how to bring Scala to more people. This might be other developers in your company or a diverse group within your community. What do they need and how do you get and keep them excited about Scala? Come along and find out!

Free Monoids: Monoids for Anything!
Audience Level: All

“Can you make a Monoid[A] for any A?” It seems impossible, but you can do it if you cheat.

This talk will quickly go over why we’d want to do this, the “trick” we can use, and show how this trick can be generalized and used in many contexts.

ONNX-Scala: An ONNX (Open Neural Network eXchange) API and Code Generator for Typeful, Numerically Generic, Functional Deep Learning in Scala
Audience Level: All

Overwhelmed by deciding between many deep learning libraries? Want to train in one context and inference in another? Open Standards! Finding Python solutions sorely lacking in type safety & support for higher-level/pure functional programming constructs? Functional, typeful Scala! Meet ONNX-Scala.

Type Touching - Types at your fingertips in IntelliJ Scala
Audience Level: Intermediate

Scala’s powerful type system helps you develop complex programs with less runtime errors. But sometimes understanding the types while programming becomes a challenge onto itself. I will show you how the IntelliJ Scala plugin helps you get a grip on your types to support your development flow.