LOADING
Do you like it when compiler generates the boring code for you? Fast, mundane, boring-but-error-prone code? Do you need to implement such a code generator yourself? Have you found out that Shapeless/Mirrors bend your brain a bit too much?
Do you like it when compiler generates the boring code for you? Fast, mundane, boring-but-error-prone code? Do you need to implement such a code generator yourself? Have you found out that Shapeless/Mirrors bend your brain a bit too much?
Congratulations! You might have a valid use case for writing a macro! Plain-old code with some plain old, vals, defs and if-elses. So, we’re opening up an IDE, looking at the API and… oh, no. It’s so low-level. And error prone. And everyone needs to copy-paste the same utilities… which are handling like 50% of the cases, and for the remaining 50% politely asking you to rewrite your code to something actually supported.
Oh, and if your users are both on Scala 2 and Scala 3 you have to write everything twice. You’d better have some tests written to keep them aligned!At this point, you might reconsider using macros: maybe generate some files as managed source, or get back to Shapeless/Mirrors, or just write the boring and error-prone code by hand?
But it doesn’t have to be this way. We can have a standard library for macros that makes simple things simple, and hard things (at least) possible. And we can design it in such a way, that most of the code could be shared between Scala 2 and 3.
And this talk will show you how.
Scala Fibers, Java Virtual Threads, and Kotlin Coroutines - this talk shows how this elegant solution manifests at three different abstraction levels.
For nearly a decade, Scala's concurrency has been driven by Akka, Cats Effect and ZIO, each with its own vision for purity, safety, and pragmatism. Kyo enters this incredible ecosystem with a fresh perspective.This talk provides a critical, technical comparison of these systems through a unified framework.
We'll explore type classes in Scala 3, using its new rules for givens, extension methods, and mechanisms for automatic derivation via mirrors or macros.
In my talk I will argue that we can do much better by relying in a systematic way on types and capabilities.
In this talk, we will walk through a concrete example of a boilerplate-heavy domain. By replacing common Scala 2 workarounds with Opaque Types, Extension Methods, Enums, and Union Types, we will demonstrate how to achieve a strictly typed, decoupled architecture without the noise.
