RocktheJVM – ZIO 2

成为一名高效的 Scala 工程师。开发高性能应用程序。编写纯函数式编程。设计可组合、可测试的软件。在 ​​ZIO 2.0 的终极指南中成长为一名工程师

什么是 ZIO？

ZIO 是一个 Scala 工具包，它允许我们使用纯函数式编程在 Scala 中编写功能强大、并发和高性能的应用程序。

什么？！

ZIO 描述了在您的代码中执行“效果”的含义。它是一个强大的模型，允许我们组合任何类型的动作，处理并行性、并发性和协调性，所有这些都使用 Scala 无与伦比的类型系统进行强类型化。

在主要的 ZIO“效果”类型之上，ZIO 库带有基于经过实战检验的实践和设计模式构建的强大工具，因此我们可以编写更容易组合的代码。

最终结果是强大的应用程序、更少的错误、更具表现力和更易于理解的代码，最重要的是，作为 Scala 开发人员的我们更加安心和生产力。

这就是您将在本课程中学到的内容。

这个 ZIO 课程是如何运作的

ZIO 务实，我们也是。

与 Rock the JVM 的任何内容一样，本课程是动手实践的。我们从第一原则开始，不假设任何 ZIO 经验。我们发现 ZIO 效果以及如何使用它们，然后我们将学习如何编写复杂的代码，如何在我们的应用程序中引入并行性和并发性，如何安全地运行关键代码流以及如何测试所有内容，所有这些都是通过实际示例和练习完成的. 在这个 13 小时的课程中，我们总共编写了 3000 多行代码。

不过，这不仅仅是关于 ZIO API——本课程将教您纯函数式编程和高性能应用程序的永恒原则，这样即使您停止使用 ZIO（或 Scala）也可以随身携带它们。

本课程对 ZIO 中的所有重要主题进行解构和排序。一旦开始，您不需要任何其他资源。坐下来和我一起在相机上工作。

在这个 ZIO 课程中，我们从实践到理论，直到纯函数式编程深入您作为 Scala 开发人员的骨子里。

您可以在本课程中同时编写 Scala 3 和 Scala 2，因为我们支持两者。

此 ZIO 课程面向经验丰富的 Scala 开发人员

我会提前：ZIO 的某些方面可能很困难，本课程适用于高级开发人员。

您需要一些扎实的 CS 基础知识：内存、线程、并行性，也许还有一些设计模式。这些基础有助于理解底层的 ZIO 机制。
在高级课程的水平上，您应该非常熟悉 Scala 作为一种语言。
即使您很有经验，自学 ZIO 也可能需要几个月的时间。这门课程花了将近一年的时间来创建，但您可以在一个周末内学习所有内容。

课程结束后你将获得的技能

本课程将为您提供使用 ZIO 提高工作效率所需的一切

您将区分纯/非纯 FP，您将知道什么是“效果”
您将知道如何使用 ZIO 效果构建应用程序和可组合程序
您将能够使用 ZIO、Fibers 编写并行和并发代码以及在它们之上的工具
你将能够通过谨慎的中断机制来管理精确的程序控制
你将能够使用协调原语编写并发的、纯函数式程序
你将能够基于来自 ZIO 的内置资源 您
将使用获取-发布模式以纯功能方式管理资源您将能够编写异步代码并在同一代码中无缝组合同步和异步效果

您将使用久经考验的依赖注入和关注点分离实践
您将能够使用强大的工具测试所有内容，包括基于属性的测试
完成本课程后，您将了解在项目中使用 ZIO 所需的一切。

最重要的是，无论您最终使用哪种语言或工具，您都将获得永远随身携带的永恒技能

您将深入了解纯函数式编程在日常项目中的实际好处
您将对编写可组合代码的意义有一个新的认识
您将内化与语言和框架无关的关于代码组织、设计模式的想法，作为价值的程序等等
作为开发人员，您将变得更有效率和更快乐

Released 12/2022
MP4 | Video: h264, 1728×1080 | Audio: AAC, 44.1 KHz, 2 Ch
Genre: eLearning | Language: English | Duration: 38 Lessons (13h 21m) | Size: 1.5 GB

Become a productive Scala engineer.Develop high-performance applications.Write pure functional programming.Design composable, testable software.Grow as an engineer in this ultimate guide to ZIO 2.0

What is ZIO?

ZIO is a Scala toolkit that allows us to write powerful, concurrent, and high-performance applications in Scala using pure functional programming.

Zay What?!

ZIO describes what it means to perform an “effect” in your code. It is a powerful model that allows us to compose any kind of actions, deal with parallelism, concurrency and coordination, all strongly typed with Scala’s unparalleled type system.

On top of the main ZIO “effect” type, the ZIO library comes with powerful tools built on battle-tested practices and design patterns, so we can write more easily composable code.

The end result is powerful applications, fewer bugs, more expressive and easily understandable code, and most importantly, more peace of mind and productivity for us as Scala developers.

This is what you’ll learn in this course.

How this ZIO course works

ZIO is pragmatic and so are we.

As with anything at Rock the JVM, this course is hands-on. We start from first principles and don’t assume any ZIO experience. We discover ZIO effects and how to use them, then we’ll learn how to compose complex code, how to introduce parallelism and concurrency to our applications, how to run critical code flows safely and how to test everything, all through practical examples and exercises. In total, we write more than 3000 lines of code in this 13-hour course.

It’s not just about the ZIO APIs, though – this course will teach you timeless principles for pure functional programming and high-performance applications so that you can take them with you even if you stop using ZIO (or Scala).

This course deconstructs and sequences all the important topics in ZIO. You don’t need any other resource once you start. Just sit back and do the work with me on camera.

In this ZIO course, we go from practice to theory, until pure functional programming gets deep in your bones as a Scala developer.

You can write both Scala 3 and Scala 2 in this course, as we support both.

This ZIO course is for experienced Scala developers

I’ll be upfront: some aspects of ZIO can be difficult, and this course is for advanced developers.

You need some solid CS fundamentals: memory, threads, parallelism, maybe some design patterns. These foundations are useful to understand the underlying ZIO machinery.
You should be very comfortable with Scala as a language, at the level of the advanced course.
Even if you’re experienced, learning ZIO on your own can take months. This course took almost a year to create, but you can learn everything in a weekend.

Skills you’ll get after the course

This course will give you everything you need to be productive with ZIO

You’ll make the difference between pure/impure FP and you’ll know what “effects” are
You’ll know how to build applications and composable programs with the ZIO effect
You’ll be able write parallel and concurrent code with ZIOs, Fibers and the tools on top of them
You’ll be able to manage pinpoint program control, with careful interruption mechanisms
You’ll be able to write concurrent, purely functional programs with coordination primitives
You’ll be able to design your own concurrency tools based on the built-in ones from ZIO
You’ll manage resources in a purely functional way with the acquire-release pattern
You’ll be able to write asynchronous code and compose synchronous and asychronous effects seamlessly in the same code
You’ll use battle-tested practices for dependency injection and separation of concerns
You’ll be able to test everything with powerful tools including property-based testing
After this course, you’ll know everything you need to work with ZIO in your project.

Most importantly, you’ll get timeless skills that you’ll carry with you forever, regardless of which language or tool you’ll end up using

You’ll deeply understand the practical benefits of pure functional programming in day-to-day projects
You’ll get a new perspective on what it means to write composable code
You’ll internalize language and framework-agnostic ideas about code organization, design patterns, programs-as-values and more
You’ll become more productive and happier as a developer