Since you are now aware of the shared mutable state in generic and programming worlds, you can pin down most issues with those two things to side effects.
Every function works in its scope to take an input, apply some logic, and generate an output; functions can have no inputs or outputs as well. For example, a function printing out the state of an object. Side effects occur when the state of the system changes because of the execution of a function. For example, suppose a function named addAndStoreValue() adds two integers and stores the result in the local database and raises a notification for the view to refresh in order to reflect the resulting value, then that change in the view will be the side effect that this function causes because of its execution. In other words, the state of the app changed once the function was executed. This change is called a side effect.
Any time you modify data stored on disk or update the text of a label on screen, you cause side effects.
You must be thinking that side effects are not bad at all; actually, that is the reason we code and execute our programs. We want the state of the system/apps to change once the program has executed.
You don't want your program to run and bring no change to the state of the mobile right? Who wants such an app? Imagine running an app for a while and causing no change in the state of the system at all, pretty useless, aye!
So from the discussion so far, we have understood that causing side-effects is desired, then what's the issue?
The issue with side-effects is that we want to control the side-effects and hence predict the state of the app once a function has finished execution. We want to control the execution to cause side-effects in a predictable manner and forecast the state of the device once our app starts running. We also need to segregate our app in modules to identify which pieces of code change the state of the app and which pieces process and output data.
RxSwift addresses the preceding issues by making use of declarative coding and creating reactive systems, both described earlier. We will delve deeper into these concepts in upcoming sections.
Functional programming mostly avoids side-effects; because of this the code becomes more testable and hence writing robust code becomes easier.
A well-written app differentiates code that causes side-effects from the rest of the program; as a result of this testing the app becomes easier, extending the functionality becomes clear, refactoring and debugging become a straightforward process, and maintaining such a code base is hassle-free. RxSwift serves a great deal in order to isolate side effects as expected.