Functional Streams for Scala with FS2

Functional Streams for Scala with FS2, available at $84.99, has an average rating of 4.7, with 94 lectures, 6 quizzes, based on 86 reviews, and has 596 subscribers.

You will learn about Understand the differences between Lists and Streams Implement memory efficient tasks via streaming (e.g. file i/o) Build complex flows for your application with streams Handle concurrency and resource safety declaratively This course is ideal for individuals who are Scala functional developers with some experience who want to add functional stream to their toolkit It is particularly useful for Scala functional developers with some experience who want to add functional stream to their toolkit.

Enroll now: Functional Streams for Scala with FS2

Summary

Title: Functional Streams for Scala with FS2

Price: $84.99

Average Rating: 4.7

Number of Lectures: 94

Number of Quizzes: 6

Number of Published Lectures: 94

Number of Published Quizzes: 6

Number of Curriculum Items: 100

Number of Published Curriculum Objects: 100

Original Price: $19.99

Quality Status: approved

Status: Live

What You Will Learn

Understand the differences between Lists and Streams

Implement memory efficient tasks via streaming (e.g. file i/o)

Build complex flows for your application with streams

Handle concurrency and resource safety declaratively

Who Should Attend

Scala functional developers with some experience who want to add functional stream to their toolkit

Target Audiences

Scala functional developers with some experience who want to add functional stream to their toolkit

Many applications involve dealing with large flows of data. Examples are processing files in ETL jobs, reading results from a database or getting a big response from http calls. Handling large amounts of data often means sacrificing either readability or performance.

With streams, you can get the best of both worlds:

– Data is processed using a constant amount of memory, even if the total amount of data is very large

– The processing is built declaratively as if you were dealing with regular Lists or Sequences, with high level methods such as map, filter and flatMap

Furthermore, streams in FS2 are effect-aware. They work in the context of an effect monad like IO, which enables them to do all sorts of useful stuff such as processing elements in parallel, throttling, retrying on failure and many more.

In this course we will turn streams inside out and learn things like:

– Create and combine pure streams

– Add effects to our streams and learn how to compose them

– Handle errors & resources safely

– Apply patterns involving time, such as retries, throttling and debouncing.

– Build our own stream transformations with Pulls and Pipes

– Handle concurrency using many different patterns

– Communicate between streams using primitives such as Signals, Channels, Topics and Queues

Join me in this journey and add yet another amazing tool to your functional programming toolkit!

Course Curriculum

Chapter 1: Introduction

Lecture 1: Introduction

Lecture 2: Setting up environment

Lecture 3: Course files

Chapter 2: Why Streams

Lecture 1: Processing a CSV File – Imperative Version

Lecture 2: Processing a CSV File – Imperative Version – Part 2

Lecture 3: Processing a CSV File – List version

Lecture 4: Processing a CSV File – Iterator version

Lecture 5: Processing a CSV File – Stream version

Lecture 6: Processing a CSV File – Stream Version – Part 2

Chapter 3: Pure Streams

Lecture 1: Introduction

Lecture 2: Creating finite streams

Lecture 3: Iterate

Lecture 4: Unfold

Lecture 5: Range & Constant

Lecture 6: Exercise: Producing the alphabet with Iterate

Lecture 7: Exercise: Producing the alphabet with Unfold

Lecture 8: Exercise: Implementing Iterate in terms of Unfold

Lecture 9: Concatenate

Lecture 10: Map

Lecture 11: FlatMap

Lecture 12: Filter & For Comprehensions

Lecture 13: Zip & ZipWith

Lecture 14: Fold

Lecture 15: Exercise: produce the odds number using Map

Lecture 16: Exercise: implement the repeat method

Lecture 17: Exercise: implement the unNone method

Lecture 18: Summary

Chapter 4: Effectful Streams

Lecture 1: Introduction

Lecture 2: Eval

Lecture 3: Exec

Lecture 4: Covary

Lecture 5: IterateEval

Lecture 6: UnfoldEval

Lecture 7: Exercise: Pagination

Lecture 8: RepeatEval

Lecture 9: For comprehensions

Lecture 10: EvalMap, EvalTap and EvalFilter

Lecture 11: Concatenation

Lecture 12: Exercise: EvalEvery

Lecture 13: Error Handling

Lecture 14: Resources

Lecture 15: Basic Time Methods

Lecture 16: Throttling

Lecture 17: Debouncing

Lecture 18: Retry

Lecture 19: Exercise: Searching

Lecture 20: Summary

Chapter 5: Transforming streams

Lecture 1: Introduction

Lecture 2: Pull based vs push based

Lecture 3: Chunk structure of a stream

Lecture 4: Chunk methods

Lecture 5: Exercise: compact

Lecture 6: Creating pulls via factory methods

Lecture 7: Turning streams into pulls

Lecture 8: Exercise: skipLimit

Lecture 9: First chunk pipe

Lecture 10: Drop pipe

Lecture 11: Exercise: filter

Lecture 12: Running sum pipe

Lecture 13: Exercise: running max

Lecture 14: Summary

Chapter 6: Concurrency

Lecture 1: Introduction

Lecture 2: Merge

Lecture 3: MergeHaltL & MergeHaltBoth

Lecture 4: Exercise: Fetching quotes from two sources

Lecture 5: ParJoinUnbounded

Lecture 6: ParJoin

Lecture 7: Exercise: Multiple producers and multiple consumers

Lecture 8: Concurrently

Lecture 9: Exercise: Progress tracker

Lecture 10: ParEvalMap

Lecture 11: Exercise: ParEvalMapSeq

Lecture 12: Zip

Lecture 13: ZipRight

Lecture 14: ParZip

Lecture 15: FixedRate

Lecture 16: FixedDelay

Lecture 17: AwakeEvery & AwakeDelay

Lecture 18: Summary

Chapter 7: Communication

Lecture 1: Introduction

Lecture 2: Signals

Lecture 3: Exercise: Cooler

Lecture 4: Channels

Lecture 5: Exercise: Improved Cooler

Lecture 6: Topics

Lecture 7: Backpressure with Topics

Lecture 8: Exercise: Car position tracker & notifier

Lecture 9: Queues

Instructors

Leandro Galvan
Senior Software Engineer

Rating Distribution

1 stars: 0 votes

2 stars: 2 votes

3 stars: 2 votes

4 stars: 24 votes

5 stars: 58 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!