Northeast Scala Symposium 2019
Proposed Talks

Long Talks (45 minutes)

Fire and Fury
Audience Level: All
Fury is an exciting new build tool and dependency manager for Scala with bold aspirations to revolutionize the way we define and distribute source builds. You will learn Fury’s radical—but simple—model, see its fast and beautiful UI, and start to believe how Fury can be the future of building Scala!
Solving a Rubik's Cube with Group Theory in Scala
Audience Level: All

Have you solved a Rubik’s Cube Yet?

In five minutes, I’ll teach everything you need to know to solve it. Really! Then, with the easy stuff out of the way, we’ll dive into the math behind the solution, teach it to a computer, and demonstrate the result with a live solve on a Bluetooth Rubik’s Cube.

A Tale of Two Type Systems
Audience Level: Intermediate
What are typeclasses and why do so many functional libraries use them? How do they fit into our standard understanding of inheritance and interfaces? What systems in the language exist that are designed to help us think about and model programs?
Data Science with Apache Zeppelin
Audience Level: All

Notebooks are interactive environments which combine code, markdown, plots and interactive forms. This talk will highlight unique development workflow benefits that notebooks provide, by demonstrating building and training machine learning models for image classification using Apache Zeppelin.

Domain Driven Testing: Know What You're Doing
Audience Level: All

In this talk, we discuss how to use Domain knowledge around your product to help improve your Software Quality. We use Domain Driven Testing tools to ensure we validate what your customers work with, rather than what you think they might use.

Great code reviews — the superpower your team needs
Audience Level: All

Are you a bit terrified when merging to master?

Do you loathe having to read hundreds of LOC to understand that PR you got tagged in?

Do you polish and re-polish before asking for a review?

Then you should come to my talk. We’ll talk about how your team can be awesome at reviewing code.

Intro to Functional Error Encoding in Scala
Audience Level: Beginner

Nulls. Exceptions. We’ve all been there. But what’s the alternative? Lucky us, Scala gives us three solutions out of the box. Learn how to be more functional about handling your errors. There might even be monads!

Intro to Implicits
Audience Level: Beginner

Implicits. Dark magic or powerful tool? Learn about Scala’s most unique and powerful feature, the different kinds of implicits, and where they are best to use. You too can be a functional implicit rockstar wizard.

Kafka Meets Functional Programming
Audience Level: Advanced

The talk is on “Kafka meets FP”, and the ultimate intention of proving the fact that “Nothing actually stops us from striving to write a good piece of software”, and how Functional Programming in Scala can make us achieve it.

Reading Haskell for Scala Programmers
Audience Level: Intermediate

Haskell, the infamous! Improve your functional programming in Scala by learning a tiny bit of Haskell and revealing the true essence behind type classes and data classes.

Stress Driven Development, and How to Avoid It
Audience Level: All

In this talk, we discuss how to manage your day and avoid the daily stressors of any engineering team. The main takeaways of this presentation are not only how to prevent stress from being accumulated at work, but also how to organize the work itself in a productive way.

The Role of the Minority in the World of Technology
Audience Level: Intermediate
Key Takeaways:
  • Understanding of why few qualified individuals of Diversity work in IT
  • Strategies that technology companies can use to recruit more qualified people of diversity in the IT world
  • Novel recruitment policies that will enable technology companies to employ more qualified Minorities
Understanding FP Concepts via Refactoring
Audience Level: All

The Reader monad sounds rather intellectual, but we can derive it from the very concrete problem of passing dependencies to some computation. We’ll deconstruct a number of FP concepts this way, to demystify them so you can feel more confident using them and teaching them to others.

Your Database is a Monad! Query it with Quill!
Audience Level: Beginner

Why does your datastore exist? So you can query it, right?

Wrong! It’s so you get confused by strange annotations that cause opaque behaviors! —Sincerely Hibernate.

Wrong! It’s so you can go mad reading Query Shapes and Mapping Projections! —Sincerely Slick.

You Bet! —Sincerely Quill.

Medium Talks (30 minutes)

portable-files: local and remote file IO, on the JVM and JS, for "src/"s and "test/"s
Audience Level: All

Java’s (N)IO interfaces are insoluble in idiomatic Scala, so I wrote an alternative in portable Scala.

It reads local files, HTTP URLs, and cloud-store objects, bakes in block-LRU-caching, captures effects with the tagless final pattern, and more.

I’ll demo it and discuss designs and alternatives!

Building a Resilient, Typesafe, and Modelled ETL Framework in Scala
Audience Level: Intermediate
Come see how we’ve made use of Scala to build an ETL framework that preserves many of the benefits of off-the-shelf platforms while solving many of the problems - it is resilient, typesafe, testable, modelled, abstracted over source and destination, and it’s easy to build in new jobs!
Teaching Scala
Audience Level: All

In this talk I explain what techniques I have found most effective for teaching Scala. I hope it will be useful for leaders of all sorts and anyone who wants to consider their own learning journey.

We all teach more than we think and doing it better results in more learning and more fun!

Compositional, Expressive, Performant Database Queries: Choose 3
Audience Level: Intermediate
ORMs are slow and frustrating and SQL queries are giant, type-unsafe strings, incapable of modular reuse. Functional programming lets you access your database without sacrificing composition (modularity and reuse), expressivity (complex edge cases), and performance.
Exploring the Scala Tooling Ecosystem
Audience Level: All

Scala’s tooling experience has improved and now there’s an increasing number of tools to choose from. We can feel the hype but might not be fully aware of tools that exists, alternatives, trade offs or even recent efforts such as LSP initiative. This talk’s goal is to create such tooling awareness.

Free Boolean Algebras: Boolean Logic for Free!
Audience Level: All

You may have heard of Free Monads, but there are other “Free” structures. Another useful type are Free Boolean Algebras, which give us Boolean logic for a set of primitives “for free”. We’ll derive the Free Boolean Algebra and show how you can use it in your programs.

FS3: Evolving a Streaming Platform
Audience Level: Advanced

FS3 is the code name for the next major version of FS2. In this talk, we’ll look at how pull based streaming may be implemented in FS3 and how various API decisions guide the design process. As a result, I hope a few will be inspired to help make FS3 reality.

Functions and Data: The Essence of Functional Programming
Audience Level: All

I’m going to show a way to write programs that are easy to understand, test, refactor and change, using only pure functions and immutable data types.

Improving Your FP with Visualizations
Audience Level: All

As a functional programming teacher and mentor, I’ve experimented in many ways to visualize types and their signatures to help my students and peers learn new concepts like functors or monads. In this talk I’ll share the techniques that have helped the most, so you try them out yourselves.

Using FreeBooleanAlgebras in the Real World
Audience Level: Advanced

This talk will introduce a new free structure, the free boolean algebra, and show you how this is super useful in production, too. What’s not to love?

Lightning Talks (15 minutes)

Adopting GraalVM
Audience Level: All
After years of development, Oracle published GraalVM and sparkled a lot of interest. GraalVM is a high-performance polyglot VM with a number of interesting traits we can take advantage of. I’d like to discuss the advantages and disadvantages of adopting GraalVM also share our story in this area.
Apache Spark Structured Streaming: The Easy Path to Data Lake
Audience Level: Beginner
This speech shows you how to organize simple Data Lake with Apache Spark structured streaming if you need to do it fast and flexible. This solution will be near-production ready, and your data science team will be happy because they can start checking their hypotheses and share feedback with you.
Build a micro-services API in 15 minutes
Audience Level: All
This talk introduces Mu, a new FP library for building micro-services APIs. Mu offers code annotations for defining RPC or REST APIs, message types, and serialization formats, thus removing the dependency on protocol-specific declarations and enabling seamless changes between different implementations.
Empowering Soft Skills with Team Dynamics & Communication Skills (for Software Engineering Team Projects & Customer Service): Using Active Listening Techniques
Audience Level: All
Key Takeaways:
  • Creative Problem Solving
  • Customer Service & Support
  • Generational Gaps & Workplace Diversity
  • Goal Setting
  • Leadership and Influence
  • Employee Efficiency
  • Using Group Dynamics
  • The loss of translation in a text/email
  • The value of how things are said
  • How someone hears a word
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.

Generic Programming in Scala - all that we must know!
Audience Level: Advanced

The talk is on Generic Programming in Scala, starting from basics, to shapeless, and all the way to concepts in scalaz-deriving. We will showcase an algorithm built to compute state of cloud infrastructure, and explain how important it is to know these concepts to make robust solutions.

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 lacking in type safety & support for higher-level/pure functional programming constructs? Functional, typeful Scala! Meet ONNX-Scala.

Type class survival guide
Audience Level: Intermediate

Monad, Monoid, Functor, Semigroup. What’s the difference!? Become a type class master with these handy visual aids! Learn their powers and the relationships between them. Gotta catch ‘em all!