DynamoDB powers many cloud-scale applications, with its robust horizontal scalability and uptime. Yet, interacting with the Java SDK is error prone and tedious. In this presentation, Avinder Bahra presents ZIO DynamoDB, a new library by Avi and Adam Johnson designed to make interacting with DynamoDB easy, type-safe, testable, and productive.

ZIO Entity is a distributed, fully-functional event sourcing library created to fix all the issues encountered with existing event sourcing frameworks. In this presentation, Tobia Loschiavo, the architect and author of this library, will introduce the API and discuss the principles that drove its design.

Workflows dealing with pre-captured financial transactions data are far more nuanced and complex than simple batch jobs or scheduled cron jobs, because they must juggle state transitions across and within workflows, and embed failure handling, such as retries or resumptions in the same programming context simultaneously. In this presentation, we will see how ZIO provides nice semantics to solve this class of problems gracefully.

Integration tests are how we know that our applications will correctly integrate with databases, cloud APIs, distributed caches, persistent queues, and other critical infrastructure. While indispensable, integration tests are painful to write and they slow down automated builds. In this talk, Balazs Zagyvai will discuss the importance of making integration tests run quickly and correctly by sharing dependencies in a resource-safe way. Balazs will then show how recent improvements in ZIO Test make it trivial to do this across all specs in an application, with support for overriding the default behavior as well. See how integration testing can be less painful and faster using compositional specs.

The is no better way to test your ZIO app than using ZIO Test. In this talk, we will go through the best and most common ways of using the library. After this talk you'll be able to see how powerful and composable ZIO Test can be. We will go through some assertions, specs and resource sharing between suites.

For interacting with external components from our functional Scala application, we need to have libraries that provide a seamless integration to the world of effects and functional data types. In many cases, these external components have some kind of machine-interpretable specification, which can be used to automatically derive a low-level functional wrapper library for them. In this talk, Daniel Vigovszky, author of ZIO AWS and ZIO Kubernetes, demonstrates how to create such libraries using techniques developed on his own generated libraries.

Open source is the engine that powers modern business, and in this presentation by OSS developer Ash Prakasan, you will learn the history of open source, why people spend their time contributing to open source, and why open source development can be so challenging. Finally, Ash addresses some of the challenges in the Scala open source community, shares a personal anecdote from her time contributing to Scala open source, and ends with tips for improving communication in the faceless world of online interaction.

Today Go is the lingua franca of Kubernetes. Go is used to implement Kubernetes, kubectl, kubectx, kops, helm, most of the Kubernetes operators, and more. Is there any hope for Scala? In the opinion of Josip Grgurica, the answer is a definite yes! Josip will show you how to build production-ready operators in a few easy steps connecting Scala libraries like ZIO, ZIO K8S, and ZIO AWS.

Although Typeclasses are considered the pinnacle of FP, they lack the essential functional attribute, composability. We will explore a more ergonomic and functional typeclass auto-derivation with the help of an experimental Scala 3 macro library. The techniques presented are relevant beyond typeclasses, delving into our understanding of algebras.

As developers we spend a lot of time working with tools, languages, and libraries but often these foundational pieces are cumbersome and frustrating. We want to move fast and NOT break things. Is that too much to ask for? In this talk we will explore ways that our developer experience can be improved with some existing tools and some imagined.

In this talk, you will learn about how to get started with ZIO HTTP, building your HTTP microservices and REST API endpoints using the power of functional Scala. We will also look at some of the more advanced features and some bleeding edge stuff that the team has been working on.

In this talk, we are going to look at how the ZIO API could be improved by leveraging Scala 3. We will look into how to exploit union and intersection types to improve the developer experience of dealing with typed errors and environments. We will further discuss how this design could reduce the boilerplate of using libraries of the ZIO ecosystem.

Applying statically typed functional programming techniques to distributed systems can often pose significant hurdles. First among these is how we can handle statically typed computations in distributed environments. ZIO Schema is a library which provides a set of tools that can help solve these issues in a type-safe way by reifying Scala types as pure, serializable values. In this talk we'll give a brief introduction to the key concepts of ZIO Schema and then dive into a concrete example of how we can use them to solve some of the trickiest problems in distributed computing.

In this talk, we will look at the new metrics API in ZIO 2 and walk through some live examples instrumenting a ZIO application. We will finish be looking at the different options to vsualize the captured metrics.

Scala 3 comes with an interesting new feature: it constructs a Typed Abstract Syntax Tree (TASTy) for each Scala program that is actually quite easy to inspect. You can use this to create custom linting rules that are specifically suited for your business. In this talk, Vincent gives a practical introduction into TASTy inspection, after which you will be able to write your own linting rule in under ten minutes!

DynamoDB powers many cloud-scale applications, with its robust horizontal scalability and uptime. Yet, interacting with the Java SDK is error prone and tedious. In this presentation, Avinder Bahra presents ZIO DynamoDB, a new library by Avi and Adam Johnson designed to make interacting with DynamoDB easy, type-safe, testable, and productive.

In this case study, you will learn how Jan and his team migrated a Scala application from Akka Actors and Akka Streams to ZIO. Connected with Kafka, REST services, and exposing its own REST API, you will learn the decisions that his team made and the lessons they learned.

Every now and then in the life of a developer, one comes across business problems that do not have efficient solutions. Over the years many, clever heuristics have been designed to solve these problems, sometimes giving birth to whole new fields of research in computer science: greedy algorithms, genetic algorithms, linear programming, etc. In this talk, Regis Kuckaertz will present a mechanical program transformation technique to turn algorithms into incremental versions of themselves, introduce a work-in-progress Scala library to write such programs, and share some initial performance results.

Microservices are a standard decision for almost every modern software project. To make the system components less coupled we need to establish asynchronous interaction between them. Fortunately, we already have mature solutions in that area, and developers often use messaging solutions like RabbitMQ, Apache Kafka, and lately Apache Pulsar, which is gaining traction. Those solutions give us resilience on a system level, but to build a highly concurrent and reliable microservice, the developer has to invest a lot of effort to deal with concurrency primitives, instead of focusing on business logic, which is at the end most important part. ZIO is a solution to this problem since it will abstract a lot of pain points related to concurrency, streaming, resource management, and error handling, and will let you focus on business logic. Finally, Aleksandar will walk you through the example application, where you will capture common patterns while working with ZIO and how to integrate Kafka or Pulsar into your ZIO codebase.

Everybody knows that the problem with free grammars is that higher-order functions like map and flatMap can't be introspected? Or can they? The only thing that you can do with a function is to execute it? Or is it? Well, someone out there certainly knows what is inside of every lambda function you write before it's executed, otherwise how is it executed at all? Guess who that is? Surprise! It's the Scala compiler! The Scala compiler sees into every single lambda you have ever written before it executes it. Not impressed? Here's another question. What if you, the free-grammar author could see into every single lambda function the same way that the Scala compiler does? What if you, the free-grammar author could introspect Free Monads and optimize them, as well as many other 'inscrutable' constructs? What if you, the free-grammar author could guarantee that your DSL expressions are completely tamper-free, and not even a single misplaced asInstanceOf call can make it inside your evaluator? Think these things are impossible? Welcome to the strange, wacky world of Quoted-DSLs (QDSLs) where things that are hard can be easy and things that are impossible can be trivial. Like Alice's Wonderland, it's not a perfect world but it sure makes violating certain laws of physics very easy! Still skeptical? Try putting in `query[Person].flatMap(p => query[Address])` into Quill and you'll get a complete SQL query, probably even at compile-time. How does it see into the flatMap? Try sneaking `4.asInstanceOf[String]` into a Quill query and watch what happens. How does it know that a cast is happening? In order to achieve these seemingly 'impossible' things, Quill uses a QDSL that is invoked with a construct called 'quote'. This construct is nothing more then a macro that takes Scala code between a set of braces (e.g. quote { i + 1 } ) and then parses it into a DSL expression (e.g. BinaryOperation(Ident("i"), Plus, Constant(1)). This construct can then be transpiled into other languages (e.g. SQL), serialized and transported across a wire, or even evaluated later if you provide an evaluator. This approach is not unique to Quill, it can be used to model just about any business logic encoding. Let's see how that happens and write a new QDSL together. Let's explore this strange and beautiful world of QDSLs!

Admit it: You have used a String to model email values, even though most strings aren’t valid emails (don’t worry, we all have!). Imprecise data models are easy, but they crash applications and corrupt external systems. On the other hand, precise data models take time and generate boilerplate. So-called newtype libraries have stepped up to the challenge, making it easier to model data precisely using runtime validation. However, newtype libraries aren’t able to validate constants at compile-time, and they don’t generally work with Scala 3. Enter ZIO Prelude Smart Types, which make it simple to model data types precisely, without any boilerplate, runtime overhead, or compile-time overhead. ZIO Prelude Smart Types work at compile-time and runtime, and they have a uniform API across Scala 2 & 3. Join ZIO Prelude contributor Jorge Vásquez as he teaches you how to be smart, and constrain your types to free your brain!

Scala 3 has formalized meta-programming in Scala as a concrete discipline; however, in the ZIO-ecosystem and the broader Scala ecosystem as a whole, there exists a need to harness the power provided by the new first-class meta-programming capabilities of the language. Runtime reflection has been a tool used to provide information about the structure of user code for decades now on the JVM; however, this tool comes with a cost. What if you could easily extract information about the structure of your code in an easy and composable manner, that works at compile time. This is one of the goals of ZIO meta. In this talk, Damian Reeves will introduce you to ZIO Meta, and learn about the class of problems it is being developed to solve.

Learn how to architect small, medium, and large applications using the power of ZLayer and ZIO 2.0. Wiring together a large applicaiton usually calls for intensive quantities of boilerplate; under the Sturm und Drang of code churn, even the most carefully tended repositories turn to spaghetti by the edges. Instead, with some trusty, battle-tested "best-practices", learn how to architect your ZIO applications such that you can focus on your business logic, while the morale-mulching mundanity of application assembly becomes a near effortless act of compile-time automaticity.

Fibers are the backbone of the highly performant, asynchronous and concurrent abilities of ZIO. They are lightweight “green threads”, implemented by the ZIO runtime system. In this talk you will learn about: * How to handle fibers dying due to unexpected failures * How to guarantee a ZIO fiber is interrupted * How to set up fiber tracking and executing a fiberDump for increased debuggability

There are various use-cases for building a framework that runs analytical queries in your business, trying to solve a variety of use-cases, such as bringing observability into your platform by computing user metrics. Custom analytical frameworks need to fetch data from a single data-source to multiple data-sources, such as Redis/In-Memory, Postgres, DynamoDb, or AWS S3., and can involve complicated questions, such as how to audit the calculations or compute efficiently. In this talk, Afsal Thaj will show you how functional programming in Scala provides the perfect toolkit to solve these problems in a principled and practical way.

In cloud-native land, where everything is an API provided as a service, we often need to orchestrate complex cross-service processes. Whether it is a database backup job, a periodic analytics query or a self-service operation for developers, it'd be unusual to reach for something over than Golang or Python. But is there an alternative for functional programing aficionados? In this talk, I'll show how the ZIO ecosystem has grown outstanding tools for automating Kubernetes and AWS in a highly concurrent, type-safe and functional fashion.

We want people from all backgrounds to be able to get the benefits of functional programming, but there are obstacles that make that harder than it should be. In this talk, Adam Fraser will look at some of the common pitfalls in working with functional effects and see how ZIO is addressing them in a way that makes life easier for all of us!

AdTech is a very innovative sphere and brings more and more attention now with the removal of cookies. Captify is one of the industry players and is the largest independent holder of user search data outside of Google. But how do companies like Captify leverage big data to find solutions for the advertising problems? Which problems can be solved using big data? And where’s Scala in all of that? You will find out in this talk by Roksolana Diachuk!

Functional programming has a rich legacy of intellectual innovation, producing a never-ending barrage of useful (if sometimes esoteric) tools, ranging from optics to effect systems to parsers. Object-oriented programming, meanwhile, is still a dominant paradigm within large-scale Enterprise software engineering. Historically, many functional programmers in Scala have avoided objects, subtyping, inheritance, and variance, preferring to model their programming based on Haskell. Yet, without embracing the object-oriented side of Scala, there is little reason to choose Scala. In this talk, John A. De Goes will argue that object-oriented programming brings facilities for code organization and architecture that all functional programs can benefit from. Rather than competing with each other, functional programming and object-oriented programming can work in harmony, and Scala can be the language that unites the two in a way not possible with Haskell or other pure functional programming languages. Come see what functional programming can learn from object-oriented programming!