Intermediate

Saturday, February 13, 2021

- PST
HKD: stem cells for data
Join Stream

Here is the plan: 1. First we discuss some problems, requiring boilerplate, macro-converters, or loose typing. 2. We describe what HKD is, how it transforms into different data shapes. 3. Here go fancy typeclasses. We define a small hierarchy useful for HKD, and reference to a library, that could derive them automatically (tofu module) 4. We discuss shapes from p2. more deeply, turning them into design pattern implementations, while using previously defined typeclasses. 5. We discuss how to infer ordinary typeclasses for HKD, providing a more general and strict form of magnolia-like derivation for case classes.

- PST
A few tips on modelling things in Scala
Join Stream

This talk will show a few simple and easy to implement tips writing models in Scala. It will answer questions like:

* how can I compare entities from DDD if case classes always compare all fields?

* do I have to give up on non-flat models if my persistence implementation doesn’t like them?

* do I have to pollute my models with annotations and implicits used by e.g. JSON serialization libraries?

* if I want to use things like Scala newtype or Refined, do I really have to several imports in every file that uses them?

* if I am dedicated used o Cats who uses import cats.implicits._ everywhere, do I really have to import it in every single file?

* does it always have to be so painful to update nested immutable model or to transform one object into another?

Some programmers take these for granted, while a lot of them still struggle with writing repetitive or needlessly complex code. This talk will help you go from the later to the former.

- PST
A Deep Dive into Scala Native Internals
Join Stream

When Scala Native was first announced it opened many new possibilities for multiple different areas of computing. For serverless and tooling it promised instant startup and low memory usage. At the same time, for low-level programming it offers interoperability with a multitude of C libraries.

Last year the Scala Center committed to taking care of this project, adding support for the latest Scala releases and extending it with new features. Thanks to cooperation between VirtusLab, the Scala Center and community contributors, Scala Native is now back on track with high hopes for a small revolution in the Scala ecosystem. This talk covers my experience of working on the Scala Native team, and shares what I have learned about Scala and the native ecosystem, as these two worlds come together.

During the talk we will discuss: * working with compiler plugins * how Scala Native differs from alternative solutions * how native is different from the JVM * LLVM and how Scala Native uses it * how Scala Native’s design decisions influenced its advantages and limitations

Additionally I will discuss the current status of Scala Native as well as its roadmap in 2021.

- PST
A Visual Language for Types
Join Stream

Scala has a highly expressive type system for modeling sets of instances, and their properties. But it can be hard for programmers to get a good intuition for what different types represent if we only see types through the source code that describes them.

This talk will be a journey through the Scala type system, examining the wealth of types on offer in Scala 2 and Scala 3, and presenting each in a visual form, showing the relationships between them, and developing an understanding of operations such as finding the least upper-bound of a pair of types. Furthermore, we will see how the concept of categorical duality arises every step of the way.

- PST
Avoiding macros with inline and derived
Join Stream

Have you always wanted amazing compile-time features in your API, but been afraid of the Scala 2 macro syntax? Have no fear, Scala 3 is here! Scala 3 provides a rich set of features that negate the need for most macros and provide an incredible toolset for APis that are easy to maintain. We'll look at using inline methods, tuples and derived code to create performant AND flexible APIs, as well as prototype implementations from GPU + serialization use cases.

A quick agenda: Improving performance with Inline Deriving code at compile time & working with Tuples Writing good error messages w/ inline When not to inline

- PST
Distributed Application Tracing with Trace4Cats
Join Stream

Distributed tracing has been slowly gaining momentum and popularity since the public release of Zipkin by Twitter and thanks to standards such as OpenCensus and OpenTracing which have combined into OpenTelemetry. Many managed monitoring providers now support tracing, while the self-hosted community favourite is Jaeger.

Trace4Cats is both an application library for capturing traces and a partial tracing system aimed at aggregating, sampling and forwarding traces to monitoring systems.

This talk will give an overview of what distributed tracing is, how it works and how it can help you in production. Followed by an introduction to Trace4Cats, what sets it apart from other tracing libraries, how to use it and its integrations, and deployment topologies.

- PST
Understanding the Type System of Scala 3
Join Stream
Bill Venners
Bill Venners
Artima, President

In the first Scala Love online conference on April 17, 2020, I gave a talk entitled Understanding Scala’s Type System. That talk mostly covered aspects common to Scala 2 and 3, it did cover union and intersection types. This talk is a continuation of that talk. It covers more advanced aspects of the type system, mostly new forms of types that are being introduced in Scala 3.