Izumi 1.0 is the most pragmatic Scala microframework allowing you to achieve new level of productivity. Now it includes full compile-time checks for your configurable applications and completely reworked Tagless Final hierarchy for Bifunctors and Trifunctors.

In this talk we are going to develop a web service using ZIO components only. Even though there are some really nice interoperability libraries available for integration with http4s, cats or akka/http, in this case we are going to see what we can accomplish while staying inside ZIO. We'll start by creating an SMTP server using zio-nio and then we'll add a frontend based on zio-grpc and scala JS. Along the way we'll leverage zio-config to externalize the configuration as well as the ZLayer mechanism for dependency injection. Maybe we'll throw zio-json into the mix and at the end we'll take a step back to appreciate how much is really possible gluing those ZIO components together and discuss what's still left to be done to make ZIO a full-fledged competitor in the area of web service development.

Learn how zio-json is designed to avoid the denial of service attacks in the library that you're using in that public facing service of yours.

Wire Signals is an OSS project that grew together with the Wire Android codebase. It's a cute little event streams library, written in Scala, which transports data across the app in a very reactive way. In this talk, I will discuss its main components: how they work, how they are used to, and how you could write them yourself - but you don't have to.

A story about building data-intensive systems with Scala. In this talk, I will share my experience with Kafka Streams, Akka Streams, and Akka Actors, what is the difference and when to use a certain technology. At last, I will present a case study from a real-world project that utilizes those technologies.

This talk explores lessons about learning (and teaching) Scala: how to approach the learning process, which topics throw people off and how to address them, if (and how) Scala can be taught as a first language, and many more.

Ever wondered how ZIO and other functional effect systems work under the hood? Sure feels like magic sometimes! I'm a big believer in learning by doing, so in this talk we will build a toy Scala effect system - TIO - from scratch, starting with a basic IO monad, gradually adding capabilities such as: - Failure and Recovery - Asynchronous Effects - Stack Safety - and finally Concurrency with Fibers

"Using Dotty Macros, Quill is being rebuilt to be better, stronger, and faster but that's just the beginning of the story. Dotty introduces a new powerhouse keyword called 'inline' that opens up a new continent of capability for Scala 3. This construct enables all Dotty macros, and allows users to interact with staged code almost indistinguishably from normal code allowing familiar patterns such as global-methods, type-classes, and type-level-logic. For Quill, this means that you have the capability to generate compile-time SQL using patterns that we once only dreamed about using. For Scala, this means that we've just scratched the surface of what we can do with staged code."

Too often, our applications are dominated by boilerplate that's not fun to write or test, and that makes our business logic complicated. In object-oriented programming, classes and interfaces help us with abstraction to reduce boilerplate. But, in functional programming, we use type classes. Historically, type classes in functional programming have been very complex and confusing, partially because they import ideas from Haskell that don't make sense in Scala, and partially because of their esoteric origins in category theory. In this presentation, Jorge Vásquez presents a new library called ZIO Prelude, which offers a distinctly Scala take on Functional Abstractions, and you will learn how you can eliminate common types of boilerplate by using it. Come see how you can improve your happiness and productivity with a new take on what it means to do functional programming in Scala!

In this talk, we discuss the algebra of data types and how we can obtain benefits by reasoning algebraically in program design. Some of these benefits take a subtle change of view, with less emphasis on the data type structure, and more on the its algebraic representation. For example, we can observe the benefits of parametricity, where a program's type constrains its implementation, and use algebra to calculate the result. If we can calculate a program's type, algebraically, to be equal to the value 1, then we can reliably conclude that there is only one program with that type (and so it must be that one!). We can use optics as the basis to denote the algebra of a data structure and navigate that structure with an opaque view of any representation. This line of reasoning about data types leads to practical applications such as tackling the data schema update problem, and other problems that collectively cause us all great pain. The benefits of this approach are diverse and in this talk and this talk aims to provoke discussion about what can be achieved by reasoning algebraically about our programs.

Throughout the years, OOP developed the SOLID principles to make it easier to implement new features, without frustrating and error-prone refactorings. Yet with the pervasive shift toward functional programming in mainstream languages, it is clear that we need principles that go well beyond OOP and which cover hybrid functional languages like Scala. In this presentation, Damian Reeves will discuss how compositionality is the key to making functional software easier to maintain. Walking through a real-life example involving workflow-driven Spark applications, Damian will systematically show you how to engineer your code to be compositional, making it easier to understand, test, and change. Come learn the critical skills you need to channel the functional designer within you!

Javascript is a nightmare language invented to bring us pain. Typescript is that same nightmare with an `: any` appended to it. It is time to leave the land of boilerplate; to stop writing your frontends in glorified XML and to start deriving them at compile time. Come, unlearn your frontend helplessness, indulge in hyperbole, and witness the raw power and semi-tapped potential of Scala.js.

Apache Spark is a powerful tool for distributed analytics, but isn’t built to offer rich primitives for local parallelism. Yet using local parallelism, it is possible to dramatically improve the performance of ML projects—for example, by fetching data sources in parallel. Historically, Scala projects have used Future for local parallelism, but increasingly, many projects have begun adopting ZIO as a better Future. Although powerful, ZIO is not easy to set up with Spark. In this talk, Leo will introduce an open source library that handles all boilerplate so you can easily implement Spark and ZIO in your ML projects, and will then present detailed benchmarks showing how much additional performance can be obtained through local parallelism.

So you want to introduce ZIO to your existing Scala codebase. Great Idea! It will make your code more efficient, readable, composable and safe. For the past year we have done this at my team at Wix and we have learned a lot about how to do it right. In this talk you will see how to successfully use ZIO in your legacy service using real-life code examples. You will learn key tips and takeaways including: * How and when to execute the ZIO runtime * How/When to introduce ZLayers into your codebase * How to make your existing APIs interop with ZIO * How to have more flexibility on ZManaged resource shutdown

Command-line applications are pervasive, relied upon by developers,third-parties, and IT staff. While it’s easy to develop a basic command-line application, building one that features rich help, forgiving parsing, bulletproof validation, shell completions, and a clean and beautiful appearance is quite challenging. In this talk, Aiswarya Prakasan, contributor to ZIO CLI, will lead you on a journey to building powerful command-line applications in Scala. Through the power of composition and strong types, you will discover how to build type-safe command-line applications in just a few simple lines of code, which give you rich features of command-line applications like git.

Recursive data structures like lists or trees can be harvested using algebras and catamorphisms. But in order to support sustainable programming ecosystems we need to grow trees. That's where coalgebras and anamorphisms prove their usefulness. Given a seed value, an anamorphism can produce a recursive data structure. Interestingly, we can also produce infinite data structures this way

Metaprogramming is one of the features that sets Scala 3 apart from other languages. We don’t only get “macros done right”, but a a couple of constructs that can be used depending on the scope and complexity of the task: inlines, typeclass derivation and “proper” macros (quoting & splicing). Let’s take a look at how these metaprogramming approaches can be used in practice. What kind of problems can we solve? How readable is the code? Does it feel like magic, or regular programming? If something is know at compile-time and can be computed then, there’s no reason to repeat it every time our program is run. Come and see what Scala 3 has to offer in this area!

Redis is one of the most commonly used in-memory data structure stores. In this talk, Dejan will introduce ZIO Redis, a purely functional, strongly typed client library backed by ZIO. He will explain the library design using the bottom-up approach - from communication protocol to public APIs. Finally, he will wrap the talk by demonstrating the client's usage and discussing its performance characteristics.

Managing application configuration can be quite challenging: we often have to support multiple data sources with overrides, including HOCON, system properties, environment variables, and more. We have to document our configuration so it is clear to IT and DevOps how to configure our applications. We have to do strong validation with error accumulation to ensure bad data is rejected and good error messages are generated for end-users. In this presentation, Afsal Thaj, the author of ZIO Config, shows attendees how to solve all of these problems in a composable and testable way. By separating the description of configuration from what must be done with configuration, ZIO Config provides all standard features—including multiple data sources, data source overrides, documentation, and validation with error accumulation—for free. Come learn how to make your applications configurable in an easy way that will delight IT and DevOps and make it easy to change your applications over time.

These days, there are all sorts of boxes to check when deploying production-grade microservices. Our applications must be (reasonably!) performant and correct, but they must also be observable, resilient, and easily extensible. In this talk, Itamar will share from his experience in running microservices-based on ZIO in production: resilient, Kubernetes-friendly structuring; cloud-native observability with logs, metrics and telemetry and modern ways of service communication.

In this talk, Adam will introduce ZIO Cache, a new library in the ZIO ecosystem that provides a drop in caching solution for ZIO applications. We will see how ZIO’s support for asynchrony and concurrent lets us implement a cache in terms of a single lookup function and how we get many other things such as typed errors and compositional caching policies for free. See how easy it can be to add caching to your ZIO application!

The software development community, including the functional programming community, has been, for as long as it has existed, centred around activities in the USA, European countries and other rich nations. But electricity is becoming more dependable and internet connectivity more ubiquitous in many African nations, particularly with projects like Loon coming online. At the same time, working remotely is becoming the new “normal” in the tech industry, in no small part due to the COVID-19 pandemic. And the barriers are coming down for software development work anywhere in the world to be carried out by developers based anywhere in the world. That includes Africa. However, most companies in the rich world still recruit locally, or within their established communities. This may be for reasons of culture, inertia, marketing reach or simply convenience. But for many organizations, hiring a developer from a less economically-developed country will likely involve more bureaucracy, and will at the very least seem harder, even taking into account lower costs. We want to change that. Many people in the world are also disadvantaged from having more limited access to learning resources. Communities are less established and less connected to those in the rich world. And high-quality training is largely unaffordable and access to the best teachers is more difficult. We want to change that. Of all the products and services a less economically-developed country could export to the rich world—food, flowers, coffee, coal—nothing should be easier to trade with the western world than software. Of all the globalization opportunities available to African industry, none have such a low environmental footprint as software. Of all the human potential most underutilized for its enormous value, developers in Africa rank close to the top. Africa is a huge continent of huge potential, and Africans deserve the right to compete in the software development industry on an equal footing, just as much as companies in the rich world deserve to be able to access that potential. This talk is about what we are doing and what you can do to help to redress this balance.

Functional programming is one of the possible paradigm that we can use to write applications using Scala, In this talk you will learn about: * The benefits of using Functional programming approach * The type classes in Scala * And the common functional abstractions: semigroup, monoid, functor and monad The challenge that the newcomers who were writing imperative code and want to start using Scala is: to change the way of thinking and reasoning about the code in a Functional way, in this talk I will go through the details and explain functional programming paradigm and how to work with type classes in Scala.

Scala 2.x has had a giant impact on the JVM, influencing both the Java programming language, and new languages like Kotlin, as well as the entire data ecosystem through highly successful projects like Spark and Kafka. Yet, the world is a very different than when Scala 2.x was created. Some features that were cutting-edge in 2006 are now mainstream in Java. Some features, like implicits, have been criticized for being too low-level and confusing. Enter Scala 3, a massive revision of the language nearing its first release candidate. In this presentation, John A. De Goes provides a compelling new vision of the future of the Scala programming language, showing how more than a decade of feedback and collaboration between industry and academia has yielded a powerful language with the features we need to build modern, cloud-native applications. Discover what your apps will look like on Scala 3!