Sign up or log in to bookmark your favorites and sync them to your phone or calendar.

functional [clear filter]
Thursday, November 14

9:40am PST

Functional Electromagnetism
Strengthen your understanding of functional programming by looking at it from a fresh and unconventional perspective.

In this talk, we use GNU Radio to examine digital signal processing systems, and explore how we can use our understanding of functional programming to reason about unfamiliar systems such as software-defined radio by looking through the lens of category theory.

This talk was inspired by the paper "Categories for the Working Hardware Designer" by Mary Sheeran. Where Sheeran used category theory to derive theorems about a hardware description language, we will use it to reason about DSP systems.

avatar for James Earl Douglas

James Earl Douglas

Freelance Scala Developer
Functional programmer, mountain biker, husband, and dad. Occasionally posts computerey things at https://earldouglas.com

Thursday November 14, 2019 9:40am - 10:10am PST

10:20am PST

Thank you, next: Iterators
Iterators are a powerful abstraction in programming languages, that abstract away complex structures and operations. The pattern is used throughout big data and the Scala collection library. In this session, we will dive deep into iterators, and ways to use them in your codebase.

avatar for Umayah Abdennabi

Umayah Abdennabi

Software Engineer, Grammarly
Umayah is a software engineer on the data team at Grammarly where he works on an internal data analytics platform.

Thursday November 14, 2019 10:20am - 10:50am PST

11:00am PST

Hacking F# in JS ecosystem
Javascript has conquered the world - developers can use it in the browser, on the server, to write mobile apps, on the desktop with Electron, and even to create serverless services. Like the language or not, the truth is JS developers have built an incredible ecosystem with libraries and tools to do almost anything. During the talk I'll show how to bring the power of F# - the functional paradigm, static typing with type inference, pattern matching, and more modern language features - to this huge and rich JS world using Fable - F# to JS compiler. Fable doesn't add any runtime overhead and generates clean JS code in conformance with new ES6 patterns, like modules or iterables, making it compatible with modern development tools, including Github Electron or React Native to let you develop not only web but also cross-platform desktop and mobile apps. I'll demonstrate how to create different types of JS applications using F# - from React-based frontend application, through the mobile app using React Native to serverless services with amazing webtask.io

avatar for Krzysztof Cieslak

Krzysztof Cieslak

CEO & Open Source Developer, Lambda Factory
Chris is software developer, consultant, founder of [Lambda Factory](http://lambdafactory.io). He's author of [Ionide](http://ionide.io/), [Forge](http://forge.run), [Fornax](https://gitlab.com/Krzysztof-Cieslak/Fornax), project owner and maintainer of [VSCode-Elm](https://marketplace.visualstudio.com/items?itemName=sbrink.elm... Read More →

Thursday November 14, 2019 11:00am - 11:30am PST

11:40am PST

Recursion schemes with Higherkindness
Recursive structures appear in many problems, from databases to machine learning, and writing functions to operate over them is not always a simple task. As functional programming tries to abstract as many things as possible, it offers a way to decouple a recursion from the implementation of business rules. In this session, Andy and Oli will guide you through recursion schemes fundamentals and Droste, a recursion library for Scala. Along the way, we will explore how it can be utilized in practice, including examples of its usage in Skeuomorph, a library for transforming data protocols.

avatar for Oli Makhasoeva

Oli Makhasoeva

Solutions Architect, 47 Degrees
I'm hosting lovely podcasts about Scala
avatar for Andy Scott

Andy Scott

Person, Stripe

Thursday November 14, 2019 11:40am - 12:10pm PST

1:00pm PST

Solving the Scala Notebook Experience
Notebooks have become an essential tool for data science and machine learning research. We felt the existing tools weren't satisfactory for Scala, and lacked the features that developers need in order to productively create reproducible notebooks. So we set out to create a new notebook tool from scratch, which provides essential code editing features that other tools lack, as well as seamless interoperability between multiple languages – including Scala, Python, and SQL – and a host of other improvements that evolve the notebook experience. We'll demonstrate our open-source notebook solution, and talk about why and how we built it – and some of the great Scala ecosystem libraries that allowed us to go from zero to MVP in an unbelievably short time.

avatar for Jeremy Smith

Jeremy Smith

Sr. Software Engineer, Netflix

Jonathan Indig

Sr. Software Engineer, Netflix

Thursday November 14, 2019 1:00pm - 1:30pm PST

1:40pm PST

A brief introduction to systems programming, with Scala Native
With Scala Native's new unsafe API, Scala programmers have access to just as much power as C programmers have had for 50 years. But what does systems programming even look like in a modern language, with Scala's immensely expressive type system? We'll find out as we explore the fundamental concepts of systems programming: pointers, structs, arrays, and strings. As we proceed, we'll see how Scala can provide safer and more ergonomic patterns than C, and compare Scala Native's capabilities to languages like Rust and OCaml. And finally, we'll look at the ways hardware is changing, and the role systems programming (and Scala) can play in defining the patterns and architectures of the future.

avatar for Richard Whaling

Richard Whaling

Lead Data Engineer, M1 Finance

Thursday November 14, 2019 1:40pm - 2:10pm PST

2:20pm PST

Quill + Doobie = Better Together
The power of today’s Open Source libraries is integration, and the Cats ecosystem is a great case-in-point. Combining Http4s, fs2, and Doobie makes for a powerful recipe that is ridiculously easy to use. As of Doobie 0.7.0, Quill has joined the fray, bridging the gap to the database layer. You can now model your data layer, compose it into queries, transact it, and send it out to the world, without ever having to leave the functional paradigm. By creating this integration, both Doobie and Quill get more than the sum of their parts. Doobie for instance, leverages fs2 to get rich set of effect-level JDBC operations that support everything from parallel-streaming queries, to reactive monitoring of asynchronous events from database change-listeners. Typically, the SQL queries for these varying use-cases will be similar but also different in non-trivial ways. This is where Quill comes to the rescue, allowing the common parts of SQL-queries to be abstracted away from the uncommon parts, ensuring a very DRY and maintainable solution, especially when the queries get very, very big. Join us on the next step of this wonderful journey!

avatar for Alexander Ioffe

Alexander Ioffe

Senior Scala Evangelist, Nasdaq
avatar for Rob Norris

Rob Norris

Programmer, Gemini Observatory
Software Engineer

Thursday November 14, 2019 2:20pm - 2:50pm PST

3:00pm PST

Speedy Scala Builds at Databricks
Building Scala code in general can be really slow. To speed this up, Databricks' Developer Tools team has taken on a variety of projects to attack the problem from different angles - from JVM tuning to cloud infrastructure - resulting in build times that are significantly less infuriating. This talk will walk you through the details of each project, and attach concrete numbers to exactly how much of a difference each one made in this year-long effort.

avatar for Li Haoyi

Li Haoyi

Software Engineer, Databricks
avatar for Ahir Reddy

Ahir Reddy

Software Engineer, Databricks

Thursday November 14, 2019 3:00pm - 3:30pm PST

3:40pm PST

Scoring ONNX ML Models with Scala
ONNX is an emerging standard format for serializing machine learning models. This talk will introduce Agate, Stripe's library for scoring ONNX models on the JVM in pure Scala. Stripe uses Agate to score deep learning models in batch in spark and scalding, and also in real-time using our scala-based scoring service. We'll talk about performance, how Agate was developed, and how we use graal native-image built binaries to interop with python.

avatar for Oscar Boykin

Oscar Boykin

Machine Learning Infrastructure, Stripe
Oscar is the creating of Scalding, Summingbird, and Algebird, and is an overall professor and mathematician turned software magician.

Thursday November 14, 2019 3:40pm - 4:10pm PST

4:20pm PST

Re-programming the programmer, from Actors to FP
Over the last few years I have built a DNS management system. Initially started as an Event Sourcing application built in Akka, the system had to be re-architected multiple times to address unforeseen issues stemming from new requirements, operational issues, and developer pitfalls (mistakes). This talk will introduce concepts in the DNS domain and different architecture styles including Event Sourcing in Akka and Stream processing in FS2. The talk will describe the journey from inception through to the current system design, highlighting the key challenges encountered along the way and the evolution of the design to account for those challenges. I plan on using real code to demonstrate each architecture along the journey.

avatar for Paul Cleary

Paul Cleary

Senior Principal Engineer, Comcast
20+ years of software development experience, spent most of the last 5 years in Scala. Most of my career is building OO systems, recently converted to FP. After all this time I am still learning. Talk to me if you are struggling with Scala or Functional Programming or if you are... Read More →

Thursday November 14, 2019 4:20pm - 4:50pm PST

5:00pm PST

Metals - building rich IDE features beyond the Language Server Protocol
The Language Server Protocol (LSP) has enabled hundreds of programming languages
to support rich code editing features such as code completions in dozens of text
editors including VS Code, Vim, Emacs and Sublime Text as well as the next
generation of web IDEs. While LSP has been successful at gaining industry
adoption, users coming from IDEs such as IntelliJ or XCode quickly observe that
a lot of nice features may be missing from the protocol.

In this talk, you will learn what steps Metals, a Scala language server, is
taking to bridge the gap between IDEs and LSP. We demonstrate how Metals uses a
suite of additional protocols including the Debug Adapter Protocol, Build Server
Protocol and Tree View Protocol to support run/test/debug, package explorers,
build explorers and more. Join us as we build a bright future for
cross-language, cross-platform and cross-editor tooling!

avatar for Ólafur Geirsson

Ólafur Geirsson

Ólafur Páll works on Scala developer tooling at Twitter. He is the author of several open source projects including Scalafmt, Scalafix and Metals.

Thursday November 14, 2019 5:00pm - 5:30pm PST
Friday, November 15

9:40am PST

Unison, and why the codebase of the future is a purely functional data structure
Unison is an open source functional programming language with special support for building distributed, elastic systems. It began as an experiment: rethink all aspects of the programming experience, including the core language, runtime, tooling, as well as code versioning and publishing, and then do whatever is necessary to eliminate needless complexity and make building software once again delightful, or at the very least, reasonable. This talk zooms in on one aspect of Unison: it models the codebase not as a mutable bag of text files, but as a purely functional data structure. We'll explain what that means and show the benefits of the approach, which include: * Perfect incremental compilation and testing, with the compilation and test result caches shared among all collaborators * Refactoring of any size as a totally controlled experience where the codebase always typechecks and the code is always runnable * Instant, 100% accurate renames that never break downstream libraries or users * The ability to assign multiple names to the same definition, with all namings being fully compatible with one another * Simplified and more flexible dependency management; many causes of dependency hell simply cannot arise * The ability to serialize arbitrary Unison code, simply, without dependency management issues * And lots more... Besides introducing the big ideas and theory, we'll also show how the ideas get used in practice by demoing the Unison codebase editing tool live during the talk. It should be a lot of fun!

avatar for Paul Chiusano

Paul Chiusano

Cofounder, Unison Computing

Friday November 15, 2019 9:40am - 10:10am PST

10:20am PST

What is Functional Reactive Programming?
How can we work with time in functional programming? Traditionally, reactive systems—UIs, web servers, robotic controllers, simulations—are seen as inherently imperative, not suitable for functional programming. This does not have to be the case! Functional Reactive Programming (FRP), lets us have our cake and eat it too: we can use the composable, declarative style we love as functional programmers to write this kind of code. But what *is* FRP? It's surprisingly hard to get a clear answer without diving deeply into research literature. I will give you an introduction with practical Haskell examples that will get you over the hump to understanding and using FRP.

avatar for Tikhon Jelvis

Tikhon Jelvis

Principal AI Scientist, Target
I picked up Haskell as my first functional language on a whim, and it's stuck with me ever since. I've worked with other functional languages too—a compiler in Racket, a backend service in OCaml—but now I'm back in the Haskell world, working on Target's supply chain optimization... Read More →

Friday November 15, 2019 10:20am - 10:50am PST

11:00am PST

Rsc: Scala Outlining for Distributed Compilation
Compilation speed is a large pain point for many Scala developers. Twitter is one of the world’s largest Scala shops, and we continuously integrate all our projects at once in our monorepo. Lowering build times is crucial to help Twitter continue developing fast and safely. While Scala compilation is difficult to parallelize, the Language Tools team at Twitter has been working on a Scala outliner, Rsc, which produces the equivalent of C++ header files for Scala. Armed with these outlines, Scala compilation parallelism can be unlocked, allowing developers to take advantage of parallel, and even distributed, compilation to iterate ever faster. Learn how we've rolled out a Scala outliner into our continuous integration pipeline, while using open source APIs and implementations to compile and test millions of lines of code thousands of times a day to support low latency builds of Twitter's projects from source.

avatar for Win Wang

Win Wang

Software Engineer, Twitter

Friday November 15, 2019 11:00am - 11:30am PST

11:40am PST

A Gentle Introduction to Comonads
Aimed at programmers with some Scala experience that are interested in pure functional programming using the Cats library. The talk begins with an introduction to type classes and how they are implemented in Scala. Next we will look at Show, Functor, Monad and finally the Comonad type class, and finally some practical examples of how you can use Comonads in your own programs.

avatar for Justin Heyes-Jones

Justin Heyes-Jones

Software Developer, YoppWorks
Justin is a Scala and pure fp fanatic

Friday November 15, 2019 11:40am - 12:10pm PST

1:00pm PST

Rust and Scala, Sitting in a Tree….
As a Scala developer of many years, I started getting into Rust out of frustration with Scala and the JVM, working on in-memory databases and high performance data manipulation code.  Rust appealed due to its promise of safety, performance, AND high level abstractions.   Does it really deliver, and how does it compare with Scala in those respects?  In particular:
  •  Safety: what does it mean to be a safe language by default?  Let’s compare the two languages approach to safety
  • What are some similar and dissimilar functional features? 
  • Performance: A close look at how Rust delivers fast performance without sacrificing FP, or: Rust vs Scala functional transforms
  • Why Rust holds huge promise in data engineering
  • Is it possible to take advantage of some Rust while keeping your Scala codebase intact?

avatar for Evan Chan

Evan Chan

Senior Data Engineer, UrbanLogiq
Evan is currently Senior Data Engineer at UrbanLogiq, where he is using Rust, among other tools, in building robust data platforms to help public servants build better communities. Evan has been a distributed systems / data / software engineer for twenty years. He led a team developing... Read More →

Friday November 15, 2019 1:00pm - 1:30pm PST

1:40pm PST

Runtime Types at Crunchbase
avatar for Themba Fletcher

Themba Fletcher

Themba Fletcher is an enthusiastic technologist, a bit of a polyglot, and an obsessive troubleshooter who loves making things. He currently manages the Core Platform and Data Insights teams at Crunchbase. Fletcher focuses on scaling platforms, APIs, and engineering teams.

Friday November 15, 2019 1:40pm - 2:10pm PST

2:20pm PST

Taming complex webapps with Scala and React
Sufficiently complex requirements require sufficiently sophisticated patterns and practices to tame the overall complexity! Only then do we have any hope of delivering a useful and high-quality product that meets those requirements. Scala.js combined with React present a coherent combination with emphasizing both functional programming and immutability. In this talk, we will examine how we used this combination to deliver a complex set of requirements in a user-friendly application. We will explore several patterns we utilized: custom hooks to ensure reusable code and consistent user-experience, isomorphic implementation of algorithms to run the same code on servers and clients, and use of memoization to ensure a responsive UI.

avatar for Kavita Laddad

Kavita Laddad

Co-founder, Paya Labs, Inc.
React, Scala.js, Indian classical music

Friday November 15, 2019 2:20pm - 2:50pm PST

3:00pm PST

In Types We Trust
Scala ensures that types are used consistently with their declaration, but checks only the name and structure of the types. A type also implies a semantic contract, which is typically expressed in human-language documentation and checked by tests. Can we do better? In this talk I will propose that we formalize the specification of semantic contracts as statements of predicate logic. I will show how these statements of logic can be used in both property-based unit tests and proofs. I will show you new features of ScalaTest that support this approach.

avatar for Bill Venners

Bill Venners

Principal, Artima
Bill Venners is president of Artima, Inc., publisher of Scala consulting, training, books, and developer tools. He is the lead developer and designer of ScalaTest, an open source testing tool for Scala and Java developers, and Scalactic, a library of utilities related to quality... Read More →

Friday November 15, 2019 3:00pm - 3:30pm PST

3:40pm PST

Running Amok to Ignite a Documentation Revolution!
Why is our ecosystem littered with so much incomplete, out-of-date and inadequate documentation? Why can't we check a library's v1.3.5 docs and read about how it contains a bug that's fixed in v1.3.6? Why can't a humble user contribute an improvement to the docs without involving the project maintainer, and having a new release made? Why does the documentation contain examples which don't compile? Why must we wait longer for a release of a library when only its docs are missing? Documentation needs to evolve faster, and to continue improving even after the software it describes has stopped. We need a documentation revolution! This talk will take a philosophical analysis of the causes of our industry's bad documentation culture and how our incumbent tooling and practises aren't helping. I will introduce Amok, a revolutionary new documentation management tool built upon Fury, for creating, maintaining, evolving, linking, versioning and checking documentation. Amok will take advantage of static build information which is now available thanks to Fury, and provide solutions to all the awkward questions above.

avatar for Jon Pretty

Jon Pretty

Software Engineer, Propensive

Friday November 15, 2019 3:40pm - 4:10pm PST

4:20pm PST

GDPR Data Cleaner: Mutating Immutable Data
Remember when data engineers and data scientists used to say things like: * “Log everything” * “Never throwaway data” * “All data is important” * “What is useless data today is tomorrow’s data of gold” And then that four letter acronym came into our vernacular…. *G-D-P-R* Now, you hear statements like this… * “Do we really need this data?” * “Is this data used at all?” * “What does the GDPR say about this type of data?” Another change that came with the GDPR is the right for a user to request the deletion of their personal data. This is a tricky proposition for those dealing with big data, since all big data technologies were based on the concept of immutable data. Big data systems, such as Hadoop and Spark, scaled so well because there were no updates of data, instead only appends, and the data was written out in large blocks, not conducive to small updates/deletes. In this talk, we discuss how personal data can be cleansed from existing big data storage systems, such as columnar-oriented Hive tables and key-value stores, and we will introduce a new open source project that implements these ideas.

avatar for David Winters

David Winters

Big Data Architect, GoPro
David is an Architect in the Data Science and Engineering team at GoPro and the creator of their Spark-Kafka streaming data ingestion pipeline. He has been developing scalable data processing pipelines and eCommerce systems for over 20 years in Silicon Valley. David's current big... Read More →

Friday November 15, 2019 4:20pm - 4:50pm PST

5:00pm PST

Netty 5: Lessons Learned
Netty is one of the most used network frameworks on the JVM (if not the most used) which provides its users not only with great flexibility but also with superb performance. While Netty 4.x was a great success and is used literally everywhere in production it became clear over the “years” that a few design choices that where made did produce various limitations. As work has started on Netty 5, it’s time to fix these limitations and incorporate all the feedback we received from the community and core maintainers. This talk will focus on multiple core changes that are scheduled for netty 5 by explaining what “real-world issues” these solve and how these changes will help to operate Netty in high-scale production environments. Also it will give a brief overview of the general planed timeline of Netty 5 and roadmap.

avatar for Norman Maurer

Norman Maurer

Software Engineer

Friday November 15, 2019 5:00pm - 5:30pm PST