Merge remote-tracking branch 'owner/master'

Tiltman · Tiltman · commit dc50fae42422 · 2015-12-19T18:39:10.000+01:00
diff --git a/Part 2 - Sequence Basics/1. Creating a sequence.md b/Part 2 - Sequence Basics/1. Creating a sequence.md
@@ -275,7 +275,7 @@ If you're interested in the results of the `Future` for a limited amount of time
 ```java
 Observable<Integer> values = Observable.from(f, 1000, TimeUnit.MILLISECONDS);
 ```
-If the `Future` has not completed the specified amount of time, the observable will ignore it and fail with a `TimeoutException`.
+If the `Future` has not completed in the specified amount of time, the observable will ignore it and fail with a `TimeoutException`.
 
 You can also turn any collection into an observable using the overloads of `Observable.from` that take arrays and iterables. This will result in every item in the collection being emitted and then a final onCompleted event.
 
diff --git a/Part 2 - Sequence Basics/2. Reducing a sequence.md b/Part 2 - Sequence Basics/2. Reducing a sequence.md
@@ -6,7 +6,7 @@ Most of the operators here will be familiar to anyone who has worked with Java's
 
 ### Marble diagrams
 
-This is an appropriate time to introduce to concept of marble diagrams. It is a popular way of explaining the operators in Rx, because of their intuitive and graphical nature. They are present a lot in the documentation of RxJava and it only makes sense that we take advantage of their explanatory nature. The format is mostly self-explanatory: time flows left to right, shapes represent values, a slash is a onCompletion, an X is an error. The operator is applied to the top sequence and the result is the sequence below.
+This is an appropriate time to introduce to concept of marble diagrams. It is a popular way of explaining the operators in Rx, because of their intuitive and graphical nature. They are present a lot in the documentation of RxJava and it only makes sense that we take advantage of their explanatory nature. The format is mostly self-explanatory: time flows left to right, shapes represent values, a slash is an onCompletion, an X is an error. The operator is applied to the top sequence and the result is the sequence below.
 
 ![](https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/legend.png)
 
diff --git a/Part 3 - Taming the sequence/3. Advanced error handling.md b/Part 3 - Taming the sequence/3. Advanced error handling.md
@@ -1,4 +1,4 @@
-# Advance error handling
+# Advanced error handling
 
 We've already seen how we can handle an error in the observer. However, by that time, we are practically outside of the monad. There can be many kinds of errors and not every error is worth pushing all the way to the top. In standard Java, you can catch an exception at any level and decide if you want to handle it there or throw it further. Similarly in Rx, you can define behaviour based on errors without terminating the observable and forcing the observer to deal with everything.
 
diff --git a/Part 3 - Taming the sequence/6. Hot and Cold observables.md b/Part 3 - Taming the sequence/6. Hot and Cold observables.md
@@ -161,7 +161,7 @@ Subscription s1 = cold.subscribe(i -> System.out.println("First: " + i));
 Thread.sleep(500);
 Subscription s2 = cold.subscribe(i -> System.out.println("Second: " + i));
 Thread.sleep(500);
-System.out.println("Unsubscribe first");
+System.out.println("Unsubscribe second");
 s2.unsubscribe();
 Thread.sleep(500);
 System.out.println("Unsubscribe first");
@@ -179,7 +179,7 @@ First: 2
 Second: 2
 First: 3
 Second: 3
-Unsubscribe first
+Unsubscribe second
 First: 4
 First: 5
 First: 6
diff --git a/Part 3 - Taming the sequence/7. Custom operators.md b/Part 3 - Taming the sequence/7. Custom operators.md
@@ -2,7 +2,7 @@
 
 RxJava offers a very large [operator set](http://reactivex.io/RxJava/javadoc/rx/Observable.html). Counting all the overloads, the number of operators on Rx is over 300. A smaller number of those is essential, meaning that you cannot achieve an Rx implementation without them. Many are there just for convenience and a self-descriptive name. For example, if `source.First(user -> user.isOnline())` didn't exist, we would still be able to do `source.filter(user -> user.isOnline()).First()`.
 
-Despite many convenience operators, the operator set of RxJava is still very basic. Rx offers the building blocks that you can combine into anything, but eventually you will want to define reuseable code for repeated cases. In standard Java, this would be done with custom classes and methods. In Rx, you would like the ability to design custop operators. For example, calculating a running average from a sequence of numbers may be very common in your financial application. That doesn't already exist in `Observable`, but you can make it yourself:
+Despite many convenience operators, the operator set of RxJava is still very basic. Rx offers the building blocks that you can combine into anything, but eventually you will want to define reuseable code for repeated cases. In standard Java, this would be done with custom classes and methods. In Rx, you would like the ability to design custom operators. For example, calculating a running average from a sequence of numbers may be very common in your financial application. That doesn't already exist in `Observable`, but you can make it yourself:
 
 ```java
 class AverageAcc {
diff --git a/README.md b/README.md
@@ -8,7 +8,7 @@ No experience with either reactive or functional programming is needed to follow
 
 ### Structure
 
-The content of this book is meant to be read from start to finish. It begins with the basics and every subsequent chapter introduces increasingly advanced features and concepts. Sections of the book are intended to be self-containing and to-the-point, so that the book can be referred back to by non-beginners.
+The content of this book is meant to be read from start to finish. It is bigger than your average tutorial and smaller than an actual book. It begins with the basics and every subsequent chapter introduces increasingly advanced features and concepts. Sections of the book are intended to be self-containing and to-the-point, so that the book can be referred back to by non-beginners.
 
 The examples used in the book are also [available in compilable java files](/tests/java/itrx) in two formats:
 * Examples that print to standard output (recommended for first-time readers)

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-# Advance error handling`
	`1`	`+# Advanced error handling`
`2`	`2`
`3`	`3`	`We've already seen how we can handle an error in the observer. However, by that time, we are practically outside of the monad. There can be many kinds of errors and not every error is worth pushing all the way to the top. In standard Java, you can catch an exception at any level and decide if you want to handle it there or throw it further. Similarly in Rx, you can define behaviour based on errors without terminating the observable and forcing the observer to deal with everything.`
`4`	`4`