Externally indexed torrent

If you are the original uploader, contact staff to have it moved to your account

Textbook in PDF format

Master the dark art of creating scalable, type-safe, concurrent apps with ZIO.
ZIO is a new Scala library that helps you rapidly build resilient and efficient concurrent apps that are easy to understand and test, and which don’t leak resources, deadlock, or lose errors.
Now ZIO creator John A. De Goes has teamed up with core contributor Adam Fraser to deliver the ultimate guide to making you a concurrent programmer of extraordinary power.
In a single book that you can work through in just 4 weeks, Zionomicon will give you the in-demand skills to excel at one of the fastest growing libraries in the Scala ecosystem.
We live in a complex and demanding cloud-native world. The applications that we develop are small parts of a much larger, globally distributed whole. Modern applications must process a never-ending stream of new data and requests from all around the world, interacting with hundreds or even thousands of other services, remotely distributed across servers, racks, data centers and even cloud providers.
Modern applications must run 24x7, deal with transient failures from distributed services, and respond with ultra low latency as they process the data and requests from desktops, smartphones, watches, tablets, laptops, devices, sensors, APIs, and external services. The complexity of satisfying these requirements gave birth to reactive programming, which is a style of designing applications so they are responsive, resilient, elastic, and event-driven. This is the world that created ZIO, a new library that brings the power of functional programming to deliver a powerful new approach to building modern applications.
Structured concurrency is a paradigm that provides strong guarantees around the lifespans of operations performed concurrently. These guarantees make it easier to build applications that have stable, predictable resource utilization. Since I have long been a fan of Haskell structured concurrency (via Async and related), ZIO was the first effect system to support structured concurrency in numerous operations:
• By default, interrupting a fiber does not return until the fiber has been interrupted and all its finalizers executed.
• By default, timing out an effect does not return until the effect being timed out has been interrupted and all its finalizers executed.
• By default, when executing effects in parallel, if one of them fails, the parallel operation will not continue until all sibling effects have been interrupted.
• Etc.
Some of these design decisions were highly contentious and have not been implemented in other effect systems until recently (if at all).
ZIO is a new library for concurrent programming. Using features of the Scala programming language, ZIO helps you build efficient, resilient, and concurrent applications that are easy to understand and test, and which don’t leak resources, deadlock, or lose errors. Used pervasively across an application, ZIO simplifies many of the challenges of building modern applications:
• Concurrency. Using an asynchronous fiber-based model of concurrency that never blocks threads or deadlocks, ZIO can run thousands or millions of virtual threads concurrently.
• Efficiency. ZIO automatically cancels running computations when the result of the computations are no longer necessary, providing global application efficiency for free.
• Error Handling. ZIO lets you track errors statically, so the compiler can tell you which code has handled its errors, and which code can fail, including how it can fail.
• Resource-Safety. ZIO automatically manages the lifetime of resources, safely acquiring them and releasing them even in the presence of concurrency and unexpected errors.
• Streaming. ZIO has powerful, efficient, and concurrent streaming that works with any source of data, whether structured or unstructured, and never leaks resources.
• Troubleshooting. ZIO captures all errors, including parallel and finalization errors, with detailed execution traces and suspension details that make troubleshooting applications easy.
• Testability. With dependency inference, ZIO makes it easy to code to interfaces, and ships with testable clocks, consoles, and other core system modules.
ZIO frees application developers to focus on business logic, and fully embraces the features of the Scala programming languages to improve productivity, testability, and resilience.
1 Foreword by John A. De Goes
2 Essentials: First Steps With ZIO 2
3 Essentials: Testing ZIO Programs
4 Essentials: The ZIO Error Model
5 Essentials: Integrating With ZIO
6 Parallelism And Concurrency: The Fiber Model
7 Parallelism And Concurrency: Concurrency Operators
8 Parallelism And Concurrency: Fiber Supervision In Depth
9 Parallelism And Concurrency: Interruption In Depth
10 Concurrent Structures: Ref - Shared State
11 Concurrent Structures: Promise - Work Synchronization
12 Concurrent Structures: Queue - Work Distribution
13 Concurrent Structures: Hub - Broadcasting
14 Concurrent Structures: Semaphore - Work Limiting
15 Resource Handling: Acquire Release - Safe Resource Handling
16 Resource Handling: Scope - Composable Resources
17 Resource Handling: Advanced Scopes
18 Dependency Injection: Essentials
19 Dependency Injection: Advanced Dependency Injection
20 Software Transactional Memory: Composing Atomicity
21 Software Transaction Memory: STM Data Structures
22 Software Transactional Memory: Advanced STM
23 Advanced Error Management: Retries
24 Advanced Error Management: Debugging
25 Advanced Error Management: Best Practices
26 Streaming: First Steps With ZStream
27 Streaming: Next Steps With ZStream
28 Channels: Unifying Streams, Sinks, and Pipelines
29 Streaming: Transforming Streams
30 Streaming: Combining Streams