Preface

As a platform, iOS offers numerous APIs to write asynchronous code and, many a times, this choice becomes hard to manage and a single code base ends up comprising multiple Asynchronous API usages, for example, closures for small Async tasks, delegation for background tasks, notification center for event-based tasks, and such. Managing and modifying such a code base might become a headache even if it is written in the best way possible, and the problem becomes more severe if a big team is involved with a single code base. RxSwift brings in uniformity so that different types of requirements (mentioned earlier) are handled with RxSwift code and hence you, as a developer, get more control over the processes and different module interactions within the app.

The main mission of this book is to give you a platform to catapult your skills to be on par with the best RxSwift developers out there. Follow the content in the book as per the schedule, and rest assured that you will achieve the mission.

Who this book is for

This book is for iOS developers who have intermediate knowledge of Swift development for IOS and want to take their skill set to the next level. RxSwift offers more control over asynchronous code in your iOS environment, and, as a seasoned developer, even a slight advantage to the way asynchronous code is written is always welcome. This book will challenge the way you have been thinking about your apps' logic and guide you along the way as you turn the tables and start thinking in a more declarative way as compared to the traditional imperative way. In short, you will learn how to think in “what to do” terminology as compared to “how to do.”

For those who are eager to become a Swift Ninja, this book aims to work in a slightly unique manner—we will dive straight into the code, and as we build on the demo applications, we will explain the concepts “on the fly,” as they say! Development is all about practice, and this book abides by that rule right from the word go.

What this book covers

Chapter 1, Migrating from Swift 3 to Swift 4, teaches what’s new in Swift 4 and how you can transition your code from Swift 3 to Swift 4. Unlike the previous Swift releases, this time the conversion is more seamless, and you will see this in practice with the help of an example.

Chapter 2, FRP Fundamentals, Terminology, and Basic Building Blocks, takes you through FRP and its basic building blocks, marble diagrams, and sequence diagrams to understand more about sequences and events in brief. Finally, the chapter will unleash Railway-oriented programming and a brief introduction on error handling in FRP. You will learn how you can handle errors in one single place without having to care about handling errors at every single event.

Chapter 3, Set up RxSwift and Convert a Basic Login App to its RxSwift Counterpart, explains that the best way to get the feel about any topic is practice. This chapter will take a nosedive into the RxSwift world by converting an existing Swift app into RxSwift. You will see the RxSwift syntax for the very first time in this chapter and get to work with a real-world application.

You will get a feel of how to convert an existing code base into a RxSwift code base and compare the benefits of the newly learned reactive concepts.

You will note the increased readability and concise but clear code that can be written using the RxSwift library when compared to normal Swift. The gist of this chapter is to provide you with a comparison to understand the benefits that RxSwift code brings into play.

Chapter 4, When to become Reactive?, helps you to use your armor judiciously, as it might lead to increased complexity if not used in a proper setting. When writing any code, keep in mind that the best code might not be the smartest code out there, rather, the best code is the one that is easier to maintain and understand. This chapter will brief you about when to use RxSwift in your application. You will also work with playgrounds to understand some more core concepts that enable you to simplify your complex code base.

Chapter 5, Filter, Transform, and Simplify, along with the next chapter, teaches you how to apply operators to filter out events and then proceed to handle them. You will play with major building blocks of RxSwift and note the clarity and control that you get as compared to normal Swift code while dealing with event-driven concepts. In this chapter, you will work with Playgrounds to transform sequences by filtering them using map, flatmap, and other such operators as they are generated so that you can take respective actions as per the type of the event that is generated.

Chapter 6, Reduce by Combining and Filtering and Common Trade Offs, might sound tedious to read at first, but the concepts will get more clear as we practice with real examples. In this chapter, you will work with some more transforming operators to reduce the observable data stream by making use of combining and filtering operators in conjunction and then gradually work your way to know other operators, such as mathematical and time based.

You will also read about the trade-offs while incorporating these operators in your code so that you can be careful while making the choice to go reactive.

Chapter 7, React to UI Events – Start Subscribing, introduces you to another framework, which is part of the original RxSwift repository—RxCocoa.

Convert your simple UI elements such as UIButtons and UITextFields to Reactive components. You will learn how to subscribe to events emitted by your newly created reactive UI components and perform respective actions depending on the type of the event. For instance, a UIButton might have a touchUpInside or long press event, and you might want to respond to both the events differently.

This chapter will also introduce you to some reactive networking code and how you can subscribe to events while your code is interacting with API calls.

Chapter 8, RxTest and Custom Rx Extensions – Testing with Rx, discusses RxTest, and later, RxBlocking, by writing tests against several RxSwift operations and also writing tests against production RxSwift code. Also, you will create an extension to NSURLSession to manage the communication with an endpoint.

Chapter 9, Testing Your RxCode – Testing Asynchronous Code, says that almost every IOS app needs some sort of API access to fetch or save data over cloud to complete its workflow and hence it becomes important to test code that interacts with APIs. Since response from APIs is uncertain and error prone, the code that interacts with APIs should be tested rigorously before shipping with production code. This chapter introduces you to concepts such as mocking, stubbing, dependency injections, and expectations and sheds some light on how you can substitute your live APIs with dummy data.

You will also know how to continue development even when your API is not ready and, as a result, fasten your sprints.

Chapter 10, Schedule Your Tasks, Don't Queue!, informs that in traditional Swift, there are different ways to handle concurrency—GCD, Operational Queues, and so on. This chapter introduces you to the concept of schedulers. RxSwift encourages a developer not to work directly with locks or queues, and 99% of the times, you will be encouraged to use platform-provided schedulers rather than creating custom schedulers.

Chapter 11, Subscribe to Errors and Save Your App, describes that it does not take long for negative inputs to pour in when an app with users in production shuts down abruptly. This chapter will cover the beauty behind error handling in RxSwift. You can subscribe to errors and react to different types of errors either in one way or follow a specific path for specific errors, for instance, retrying if a download failed abruptly, reauthenticating a user behind the scenes if the session has expired, and so on.

Chapter 12, Functional and Reactive App-Architecture, compares different design patterns that can be used while writing RxSwift apps from scratch or modifying current apps to incorporate Reactive and functional behavior. You will know about observation, iteration, delegation, MVC, and MVVM and try to figure out which design pattern fits the puzzle in the best way possible. This chapter will also introduce you to different open source APIs that can be incorporated to your ongoing projects.

Chapter 13, Finish a Real-World Application, concludes that you would have covered a lot so far and worked on a lot of code examples; now, you will put everything that you have learned so far to practice in one place and finish an app that we started earlier in Chapter 2, FRP Fundamentals, Terminology, and Basic Building Blocks. This chapter will cover the MVVM application architecture and show how a well-designed ViewModel can power an RxSwift app.

To get the most out of this book

We assume that you, the reader of this book, already have intermediate knowledge of Swift programming language and have worked on iOS applications before.

Download the example code files

You can download the example code files for this book from your account at www.packtpub.com. If you purchased this book elsewhere, you can visit www.packtpub.com/support and register to have the files emailed directly to you.

You can download the code files by following these steps:

1. Log in or register at www.packtpub.com.
2. Select the SUPPORT tab.
3. Click on Code Downloads & Errata.
4. Enter the name of the book in the Search box and follow the onscreen instructions.

Once the file is downloaded, please make sure that you unzip or extract the folder using the latest version of:

• WinRAR/7-Zip for Windows
• Zipeg/iZip/UnRarX for Mac
• 7-Zip/PeaZip for Linux

The code bundle for the book is also hosted on GitHub at https://github.com/PacktPublishing/Reactive-Swift-4-Programming. We also have other code bundles from our rich catalog of books and videos available at https://github.com/PacktPublishing/. Check them out!

Download the color images

We also provide a PDF file that has color images of the screenshots/diagrams used in this book. You can download it here: https://www.packtpub.com/sites/default/files/downloads/ReactiveProgrammingwithSwift4_ColorImages.pdf.

Conventions used

There are a number of text conventions used throughout this book.

CodeInText: Indicates code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles. Here is an example: "Setting up an RxSwift environment"

A block of code is set as follows:

use_frameworks!
target 'YOUR_TARGET_NAME' do
pod 'RxSwift'
pod 'RxCocoa'
end

Any command-line input or output is written as follows:

 sudo gem install cocoapods

Bold: Indicates a new term, an important word, or words that you see onscreen. For example, words in menus or dialog boxes appear in the text like this. Here is an example: "Now pick the recently installed Swift 4.0 Snapshot and restart Xcode IDE"

Note

Warnings or important notes appear like this.

Note

Tips and tricks appear like this.

Get in touch

Feedback from our readers is always welcome.

General feedback: Email [email protected] and mention the book title in the subject of your message. If you have questions about any aspect of this book, please email us at [email protected].

Errata: Although we have taken every care to ensure the accuracy of our content, mistakes do happen. If you have found a mistake in this book, we would be grateful if you would report this to us. Please visit www.packtpub.com/submit-errata, selecting your book, clicking on the Errata Submission Form link, and entering the details.

Piracy: If you come across any illegal copies of our works in any form on the Internet, we would be grateful if you would provide us with the location address or website name. Please contact us at [email protected] with a link to the material.

If you are interested in becoming an author: If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, please visit authors.packtpub.com.

Reviews

Please leave a review. Once you have read and used this book, why not leave a review on the site that you purchased it from? Potential readers can then see and use your unbiased opinion to make purchase decisions, we at Packt can understand what you think about our products, and our authors can see your feedback on their book. Thank you!

For more information about Packt, please visit packtpub.com.