Frameworks are bulky, quirky, and non-compositional, which has led to a rejection of Spring and similar frameworks in the Scala ecosystem. Yet, despite their drawbacks, frameworks have been used to boost team productivity in many large companies. In this presentation, Paul and Kai will introduce Izumi 1.0, a Scala microframework based on compositional functional programming. Designed to help you and your team achieve new levels of productivity, Izumi now includes full compile-time checks for your configurable applications and completely reworked Tagless Final hierarchy for Bifunctors and Trifunctors.

Frameworks are bulky, quirky, and non-compositional, which has led to a rejection of Spring and similar frameworks in the Scala ecosystem. Yet, despite their drawbacks, frameworks have been used to boost team productivity in many large companies. In this presentation, Paul and Kai will introduce Izumi 1.0, a Scala microframework based on compositional functional programming. Designed to help you and your team achieve new levels of productivity, Izumi now includes full compile-time checks for your configurable applications and completely reworked Tagless Final hierarchy for Bifunctors and Trifunctors.

ZIO has excellent interoperability with http4s, Cats, Akka libraries, and more, and there are a number of posts and videos that help developers use ZIO with these great libraries. Yet, the question remains: can you develop a web service using ZIO libraries alone? In this talk, we'll explore the answer to this question directly. 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! Finally, we'll conclude by discussing what's still left to be done to make ZIO a full-fledged competitor in the area of full-stack web service development.

Scala has more JSON libraries than Go has language features! Yet, very few of these libraries can protect your application from very rudimentary exploits against your public API, and fewer still offer the blazing fast performance required for extremely high throughput applications. In this presentation, Sam Halliday presents his work on ZIO JSON, showing you how this library's approach to serialization defends against the devastating exploits that would otherwise take your application down, all while providing best-in-class performance in a friendly, easy-to-use package.

Reactive programming has helped developers tame the complexity of UI, data processing, and async applications, but some solutions can be a little overwhelming. In this presentation, Maciek Gorywoda will introduce Wire Signals, a small and beginner-friendly reactive library that grew together with the Wire Android codebase, and which transports data across an application in a very reactive way. Maciek will discuss the main components of this library: how they work, how they are used, and how you could write them yourself--but don't have to!

One of the strengths of Scala is it's incredible support for solving complex, data-intensive problems. In this presentation, Aleksandar Skrbic will present his own personal story about developing such solution in Scala, using technologies like Kafka Streams, Akka Streams, and Akka Actors. Along the way, Aleksandar will explain the differences between these technologies and when to use which. Finally, Aleksandar will present a case study from a real-world project that utilizes these technologies.

In this talk, Daniel Ciocîrlan, the creator of RockTheJVM, explores lessons about learning and teaching Scala: how to approach the learning process, which topics put people off and how to deal with these challenges, if (and how) Scala can be taught as a first language, and many other lessons. Come explore the lessons learned through teaching tens of thousands of Scala engineers!

Ever wondered how ZIO and other functional effect systems work under the hood? Sure feels like magic, sometimes! Dmitry Karlinsky is a big believer in learning by doing, and in this talk, the speaker will walk you through building a toy Scala effect system (called 'TIO'), from scratch, starting with a basic IO monad, and gradually adding capabilities such as: Failure and Recovery, Asynchronous Effects, Stack Safety, and finally Concurrency with Fibers. Peek behind the curtain and demystify the technology that is becoming the backbone of modern Scala applications!

Scala 3 is arriving, and with it comes incredible new power for library authors. In this presentation, Alexander Ioffe, contributor to Quill (a LINQ-like persistence layer for Scala), will show how using Scala 3 Macros, Quill is being rebuilt to be better, stronger, and faster. As you will learn in this presentation, Scala 3 introduces a new powerhouse keyword called 'inline' that opens up a new continent of capability. This construct powers all Scala 3 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, Alexander will show how this allows generating compile-time SQL using patterns that we once only dreamed about using--and these features just scratch the surface of what can be done with staged code. Come discover the bright future of powerful, type-safe libraries in Scala 3!

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, Tony Morris will 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. In this presentation, Kit Langton will exhort you to come, unlearn your frontend helplessness, indulge in hyperbole, and witness the raw power and semi-tapped potential of Scala.js! (Don't forget to bring popcorn.)

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 Scala's 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. Learn how to use ZIO to make Spark better and faster!

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, Natan Silnitsky has done this at Wix and has learned a lot about how to do it right. In this talk, Natan will show you 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; and how to have more flexibility on ZManaged resource shutdown. When you're done attending the presentation, you'll be able to introduce ZIO into your existing Scala code base with confidence!

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

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, type class derivation and “proper” macros (quoting & splicing). In this presentation, Adam Warski will show you 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 knowable 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, with excellent performance and extensive support for nearly all of Redis' features. 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.

Over the years Kubernetes has proved its power in building ecosystems. But where should Scala developers can start from when they want to try working with Kubernetes? And is there a way to create pods with a Scala code? In this presentation, Roksolana Diachuk will provide you the answer to all these questions and more. Come learn how you can benefit from the Kubernetes revolution!

Functional programming is one of the paradigms we can use to write apps using Scala. Yet, newcomers who write procedural code often have difficulties changing their way of thinking about programming. In this talk, Wiem Zine Elabidine, contributor to ZIO and other functional Scala libraries, will gently introduce functional programming and teach type classes (including common ones like semigroup, monoid, functor, and monad). By the end of this talk, you'll have a better understanding of functional programming principles and know some of the jargon. Come discover how easy functional programming can be!

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!