1.3 Reworked chapter

Author: Froussios

Part 1 - Getting Started/3. Lifetime management.md

@@ -15,7 +15,7 @@ Subscription 	subscribe(Observer<? super T> observer)
 Subscription 	subscribe(Subscriber<? super T> subscriber)
 ```
 
-`subscribe()` consumes events but performs no actions. The overloads that take an `Action1` construct a `Subscriber` with the functions that you provide, or doing nothing where the action is missing.
+`subscribe()` consumes events but performs no actions. The overloads that take one or more `Action` will construct a `Subscriber` with the functions that you provide. Where you don't give an action, the no action is performed.
 
 In the following example, we handle the error of a sequence that failed.
 
@@ -34,15 +34,15 @@ Output
 java.lang.Exception: Oops
 ```
 
-If we do not provide a function for error handling, an `OnErrorNotImplementedException` will be *thrown* at the point where `s.onError` is called. It happens here that the producer and the consumer are side-by-side, so you could do a try-catch. However, on a compartmentalised system you won't receive the exception unless you provide a handler to `subscribe`.
+If we do not provide a function for error handling, an `OnErrorNotImplementedException` will be *thrown* at the point where `s.onError` is called, which is the producer's side. It happens here that the producer and the consumer are side-by-side, so we could do a traditional try-catch. However, on a compartmentalised system, the producer and the subscriber very often are in different places. Unless the consumer provides a handle for errors to `subscribe`, they will never know that an error has occured and that the sequence was terminated.
 
 ## Unsubscribing
 
 You can also stop receiving values *before* a sequence terminates. Every `subscribe` overload returns an instance of `Subscription`, which is an interface with 2 methods:
 
 ```java
-boolean 	isUnsubscribed()
-void 	    unsubscribe()
+boolean isUnsubscribed()
+void unsubscribe()
 ```
 
 Calling `unsubscribe` will stop events from being pushed to your observer.
@@ -66,7 +66,7 @@ Output
 1
 ```
 
-Unsubscribing one observer does not interfere with other observers
+Unsubscribing one observer does not interfere with other observers on the same observable.
 
 ```java
 Subject<Integer, Integer>  values = ReplaySubject.create();
@@ -95,7 +95,7 @@ Second: 2
 
 ## onError and onCompleted
 
-`onError` and `onCompleted` mean the termination of a sequence. An observable that complies with the standard will not emit anything after either of those events. This is something to note both when consuming in Rx and when implementing your own observable.
+`onError` and `onCompleted` mean the termination of a sequence. An observable that complies with the Rx contract will not emit anything after either of those events. This is something to note both when consuming in Rx and when implementing your own observable.
 
 ```java
 Subject<Integer, Integer>  values = ReplaySubject.create();
@@ -119,19 +119,23 @@ Completed
 
 ## Freeing resources
 
-A `Subscription` can be tied to the resources it uses. For that reason, you should remember to dispose of subscriptions. You can create that binding a `Subscription` with the necessary using the [Subscriptions](http://reactivex.io/RxJava/javadoc/rx/subscriptions/Subscriptions.html) factory.
+A `Subscription` is tied to the resources it uses. For that reason, you should remember to dispose of subscriptions. You can create the binding between a `Subscription` and the necessary resources using the [Subscriptions](http://reactivex.io/RxJava/javadoc/rx/subscriptions/Subscriptions.html) factory.
 
 ```java
 Subscription s = Subscriptions.create(() -> System.out.println("Clean"));
 s.unsubscribe();
 ```
-
 Output
 ```
 Clean
 ```
 
-The `Subscriptions` factory has more methods, which allow you to compose the use of resources into a single `Subscription`. `Subscription` itself has several implementations.
+`Subscriptions.create` takes an action that will be executed on unsubscription to release the resources. There also are shorthand for common actions when creating a sequence.
+* `Subscriptions.empty()` returns a `Subscription` that does nothing when disposed. This is useful when you are required to return an instance of `Subscription`, but your implementation doesn't actually need to release any resources.
+* `Subscriptions.from(Subscription... subscriptions)` returns  a `Subscription` that will dispose of multiple other subscriptions when it is disposed.
+* `Subscriptions.unsubscribed()` returns a `Subscription` that is already disposed of.
+
+There are several implementations of `Subscription`.
 
 * `BooleanSubscription`
 * `CompositeSubscription`
@@ -144,7 +148,7 @@ The `Subscriptions` factory has more methods, which allow you to compose the use
 * `Subscriber`
 * `TestSubscriber`
 
-We will see some more later on.
+We will see more of them later in this book. It is interesting to note that `Subscriber` also implements `Subscription`. This means that we can also use a reference to a `Subscriber` to terminate a subscription.
 
 #### Continue reading