New Course: Beginning RxSwift

Have you wanted to try using reactive programming in your iOS apps, but didn’t know where to start? Are you looking for a more streamlined way to write asynchronous code?

Today, we are releasing a brand new course for you: Beginning RxSwift. In this 39-video course, you’ll get started with reactive programming in Swift and iOS with RxSwift. You’ll learn about foundations of RxSwift like observables, subscribing, and more. You’ll also learn to use RxSwift in your iOS apps!

Take a look at what’s inside:

Part 1: Getting Started with RxSwift

In part one, set up an Xcode project with RxSwift and get started using the foundation of RxSwift: the observable.

1. Introduction: Let’s review what you will be learning in this course, beginning with a brief history of RxSwift.
2. Hello RxSwift: Learn what are the goals of RxSwift, compare the pros and cons of learning and using RxSwift, and become familiar with the foundation of RxSwift: the observable.
3. Installing RxSwift: See how to install RxSwift in an Xcode project using CocoaPods, and how to add a playground to a project.
4. Creating Observables: Go over several operators you can use to create observables from individual values and collections of values.
5. Subscribing to Observables, Part 1: Learn how to subscribe to an observable, and how to manage memory by using dispose bags.
6. Subscribing to Observables, Part 2: Continue learning how to subscribe to observables and see how to make an observable emit an error event to subscribers.
7. Challenge: Performing Side Effects: Get introduced to the do operator for performing side effects, and then use the do operator in an example from the previous video.
8. Subjects and Variables, Part 1: Find out how Subjects can receive new elements and emit new events to subscribers at runtime.
9. Subjects and Variables, Part 2: Continue learning about using Subjects and see how to use Variables for a similar purpose but with some added conveniences.
10. Challenge: Create a Blackjack Card Dealer: Put your new skills to work by creating a reactive algorithm to deal hands of blackjack.
11. Observables, Subjects, and Variables in Practice, Part 1: Get an overview of your first iOS project, Combinestagram, and then apply what you’ve learned so far to Rx-ify it.
12. Observables, Subjects, and Variables in Practice, Part 2: Continue incorporating use of RxSwift in Combinestagram, including how to create your own custom observable to save images to disk.
13. Conclusion: Review what you learned in this section, and find out how you’ll apply that knowledge throughout the rest of the course.

Part 2: Filtering Observables

In part two, learn how to use filtering operators to filter data emitted by observables.

1. Introduction: Get an overview of why you’d use filtering operators, and an example of how you might chain filtering and other kinds of operators together to perform complex operations.
2. Filtering Operators: See how to use filtering operators to apply conditional constraints to next events and only pass through the elements you want to subscribers.
3. Challenge: Create a Phone Number Lookup: Use filtering operators to create a utility that looks up phone numbers in a sample data set.
4. Filtering and Sharing Operators in Practice: Improve the Combinstagram app with filtering operators, and learn how to enable multiple subscribers to consume the elements from a single observable.
5. Creating a Custom Filtering Operator: Continue improving the Combinestagram app by creating a custom filtering operator to handle the authorization status for access to the Photos library.
6. Schedulers and Timing Operators: Find out how to manage threads in RxSwift and get an introduction to using timing operators to filter consecutive input. [FREE]
7. Challenge: Optimize Combinestagram: Use sharing, throttling, and schedulers to optimize and finish up Combinestagram.
8. Conclusion: Wrap up on what you learned in this section and see how you’ll continue to build up your repertoire of RxSwift in the next section.

Part 3: Transforming Observables

In part 3, learn to use transforming operators to manipulate and convert data that comes from an observable.

1. Introduction: Kickoff your introduction to learning about most one of most important categories of operators in RxSwift.
2. Transforming Operators: Review concepts and go through several examples of putting the most widely-used transforming operators in RxSwift to work.
3. Challenge: Improve the Phone Number Lookup: Improve upon the phone number lookup utility from earlier but including the use of transforming operators.
4. Hello, RxCocoa!: Get introduced to RxCocoa and understand how it applies RxSwift concepts and patterns to provide APIs for working with Cocoa and Cocoa Touch.
5. Transforming Operators in Practice, Part 1: Apply what you’ve learned about transforming operators to implement the nessessary functionality of the GitFeed app.
6. Transforming Operators in Practice, Part 2: Continue working on the GitFeed app from the previous video by implementing a way to retrieve saved data.
7. Challenge: Improve GitFeed: Modify GitFeed to make it more useful and interesting, by finding the top trending Swift repos instead and displaying their combined activity.
8. Conclusion: Review what you learned in this section and see what’s in store for you next as you continue to level up your Rx game.

Part 4: Combining Observables

In the final part of the course, learn to use combining operators to merge data coming from multiple observables into one.

1. Introduction: Get introduced to what you will be learning about in this part: joining observable sequences together.
2. Combining Operators, Part 1: Learn how to use a wide variety of operators to prepend, join, and merge observables.
3. Combining Operators, Part 2: Continue working with combining operators to merge, choose between, and accumulate observables.
4. Challenge: The Zip Case: Get additional hands-on experience working with two commonly used combining operators to improve upon an example from the previous video.
5. Combining Operators in Practice, Part 1: Apply everything you’ve learned in this course so far to implement the functionality for an app that resembles how you would use RxSwift in your own app projects.
6. Combining Operators in Practice, Part 2: Continue implementing the functionality for Our Planet, beginning with how to fetch data from the EONET public API.
7. Downloading in Parallel, Part 1: See how to improve Our Planet to retrieve data more efficiently by fetching in parallel.
8. Downloading in Parallel, Part 2: Finish implementing Our Planet by incrementally updating the UI with data coming back from parallel fetching.
9. Challenge: Indicate Download Activity: Add some polish to Our Planet by appropriately showing and hiding the activity indicator for network activity.
10. Conclusion: Wrap up this course by reviewing what you learned, and get some handy resources to continue the learning on your path to Jedi mastery of RxSwift.