Zionomicon

Description

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. Foreword by John A. De Goes A Brief History of ZIO The Birth of ZIO Contentious Concurrency Typed Errors & Other Evolution Contributor Growth Improved Type-Inference Batteries Included ZIO Stream ZIO Environment Software Transactional Memory Execution Traces Summer 2019 ZIO Test ZLayer Structured Concurrency Why ZIO ZIO Alternatives Zionomicon Essentials: First Steps With ZIO Functional Effects As Blueprints Sequential Composition For Comprehensions Other Sequential Operators ZIO Type Parameters The Error Type The Environment Type ZIO Type Aliases Comparison to Future A Future Is A Running effect Future Has An Error Type Fixed To Throwable Future Does Not Have A Way To Model The Dependencies Of An Effect More Effect Constructors Pure Versus Impure Values Effect Constructors For Pure Computations Effect Constructors for Side Effecting Computations Default ZIO Services Clock Console System Random Recursion And ZIO Conclusion Exercises Essentials: Testing ZIO Programs Writing Simple Programs With ZIO Test Using Assertions Test Implementations Of Standard ZIO Services Common Test Aspects Basic Property Based Testing Conclusion Exercises Essentials: The ZIO Error Model Exceptions Versus Defects Cause Exit Handling Defects Converting Errors to Defects Multiple Failures Other Useful Error Operators Combining Effects with Different Errors Designing Error Models Execution Tracing Interpreting Error Tracing Dealing With Stacked Errors Leveraging Typed Errors Conclusion Exercises Essentials: Integrating With ZIO Integrating With Java Integrating With Javascript Integrating With Cats Effect Integrating With Specific Libraries Conclusion Exercises Parallelism And Concurrency: The Fiber Model Fibers Distinguished From Operating System Threads Forking Fibers Joining Fibers Interrupting Fibers Fiber Supervision Locking Effects Conclusion Exercises Parallelism And Concurrency: Concurrency Operators The Importance Of Concurrency Operators Race And ZipPar Variants of ZipPar Variants of Race Other Variants Conclusion Exercises Parallelism And Concurrency: Fiber Supervision In Depth Exercises Parallelism And Concurrency: Interruption In Depth Timing Of Interruption Interruption Before An Effect Begins Execution Interruption Of Side Effecting Code Interruptible and Uninterruptible Regions Composing Interruptibility Waiting For Interruption Conclusion Exercises Concurrent Structures: Ref - Shared State Purely Functional Mutable State Ref As Purely Functional Equivalent Of An Atomic Reference Operations Are Atomic But Do Not Compose Atomically Ref.Synchronized For Evaluating Effects While Updating FiberRef For References Specific To Each Fiber Conclusion Exercises Concurrent Structures: Promise - Work Synchronization Various Ways of Completing Promises Waiting On A Promise Promises And Interruption Combining Ref And Promise For More Complicated Concurrency Scenarios Conclusion Exercises Concurrent Structures: Queue - Work Distribution Queues As Generalizations Of Promises Offering And Taking Values From A Queue Varieties Of Queues Back Pressure Strategy Sliding Strategy Dropping Strategy Other Combinators On Queues Variants Of Offer And Take Metrics On Queues Shutting Down Queues Conclusion Exercises Concurrent Structures: Hub - Broadcasting Hub As The Optimal Solution To The Broadcasting Problem Creating Hubs Bounded Hubs Sliding Hubs Unbounded Hubs Dropping Hubs Operators On Hubs Conclusion Concurrent Structures: Semaphore - Work Limiting Interface Of A Semaphore Using Semaphores To Limit Parallelism Using Semaphore To Implement Operators Using Semaphore To Make A Data Structure Safe For Concurrent Access Conclusion Exercises Resource Handling: Acquire Release - Safe Resource Handling Inadequacy Of Try And Finally In The Face Of Asynchronous Code Acquire Release As A Generalization Of Try And Finally The Ensuring Operator Conclusion Exercises Resource Handling: Scope - Composable Resources Scope As A Reification of Acquire Release Scope As A Dynamic Scope Constructing Scoped Resources Fundamental Constructors Convenience Constructors Transforming Scoped Resources Using Scoped Resources Varieties Of Scoped Resources Conclusion Exercises Resource Handling: Advanced Scopes Scopes Revisited From Scopes To Resources Using Resources Child Scopes Putting It All Together Conclusion Dependency Injection: Essentials The Environment Type Fundamental Operators For Working With The Environment Typical Uses For The Environment The Onion Architecture Layers Constructing Layers Providing Layers Conclusion Dependency Injection: Advanced Dependency Injection Software Transactional Memory: Composing Atomicity Inability To Compose Atomic Actions With Other Concurrency Primitives Conceptual Description Of STM Using STM Limitations of STM Conclusion Exercises Software Transaction Memory: STM Data Structures Description Of STM Data Structures TArray TMap TPriorityQueue TPromise TQueue TReentrantLock TSemaphore TSet Creating Your Own STM Data Structures Conclusion Exercises Software Transactional Memory: Advanced STM Debugging Optimization Effects Conclusion Exercises Advanced Error Management: Retries Limitations Of Traditional Retry Operators Retrying And Repeating With ZIO Common Schedules Schedules For Recurrences Schedules For Delays Schedules For Conditions Schedules For Outputs Schedules For Fixed Points In Time Transforming Schedules Transforming Inputs and Outputs Summarizing outputs Side Effects Environment Modifying Schedule Delays Modifying Decisions Schedule Completion Composing Schedules Intersection And Union Of Schedules Sequential Composition Of Schedules Alternative Schedules Function Composition Of Schedules Implementation Of Schedule Conclusion Exercises Advanced Error Management: Debugging Execution Traces Fiber Dumps Conclusion Exercises Advanced Error Management: Best Practices Sandboxing At The Edge Recoverable Versus Non-Recoverable Errors Logging Errors Conclusion Exercises Streaming: First Steps With ZStream Streams As Effectual Iterators Streams As Collections Implicit Chunking Potentially Infinite Streams Common Collection Operators On Streams Constructing Basic Streams Constructing Streams From Existing Values Constructing Streams From Effects Constructing Streams From Repetition Constructing Streams From Unfolding Running Streams Running A Stream As Folding Over Stream Values Running A Stream For Its Effects Running A Stream For Its Values Type Parameters The Environment Type The Error Type Conclusion Streaming: Next Steps With ZStream Sinks Pipelines Conclusion Exercises Channels: Unifying Streams, Sinks, and Pipelines Channels Channel Constructors Channel Operators Channel Scopes Conclusion Exercises Streaming: Transforming Streams Streaming: Combining Streams Streaming: Transducers Streaming: Sinks Streaming: Summaries Testing: Basic Testing Tests As Effects Specs As Recursively Nested Collections Of Tests Conclusion Exercises Testing: Assertions Assertions As Predicates Using Assertions To ``Zoom In'' On Part Of A Larger Structure Common Assertions Labeling Assertions Implementing New Assertions Conclusion Exercises Testing: The Test Environment Test Implementation Of Standard Services Test Implementation of Clock Service Test Implementation Of Console Service Test Implementation Of Random Service Test Implementation Of System Service Accessing The Live Environment Creating Custom Test Implementations Conclusion Exercises Testing: Test Aspects Test Aspects As Polymorphic Functions Ability To Constrain Types Common Test Aspects Running Effects Before And After Tests Flaky And NonFlaky Tests Ignoring Tests Diagnosing Deadlocks Handling Platform And Version Specific Issues Modifying The Environment Accessing Configuration Information Controlling Parallelism Asserting That A Test Fails Running Each Test On A Separate Fiber Timing Tests Verifying Post-Conditions Implementing Test Aspects Conclusion Exercises Testing: Using Resources In Tests Shared Versus Unshared Resources Providing Resources To Tests Composing Resources And Extending The Test Environment Conclusion Exercises Testing: Property Based Testing Generators As Streams Of Samples Constructing Generators Operators On Generators Transforming Generators Combining Generators Choosing Generators Filtering Generators Running Generators Random And Deterministic Generators Samples And Shrinking Conclusion Exercises Testing: Test Annotations Using Test Annotations To Record Additional Information About Tests Implementing Test Annotations Implementing Test Annotation Reporters Conclusion Exercises Testing: Reporting Applications: Parallel Web Crawler Definition Of A Parallel Web Crawler Interacting With Web Data First Sketch Of A Parallel Web Crawler Making It Testable Scaling It Up Conclusion Applications: Command Line Interface Applications: Kafka Stream Processor Applications: gRPC Microservices Applications: REST API Applications: GraphQL API Applications: Spark Appendix: The Scala Type System Types And Values Subtyping Any And Nothing Any Nothing Product And Sum Types Product Types Sum Types Combining Product And Sum Types Intersection And Union Types Intersection Types Union Types Type Constructors Conclusion Appendix: Mastering Variance Definition of Variance Covariance Contravariance Invariance Advanced Variance Conclusion