diff --git a/Part 1 - Getting Started/1. Why Rx.md b/Part 1 - Getting Started/1. Why Rx.md
index 172298b..7022081 100644
--- a/Part 1 - Getting Started/1. Why Rx.md
+++ b/Part 1 - Getting Started/1. Why Rx.md
@@ -45,5 +45,5 @@ Rx применяется для составления и обработки п
| Назад | Вперед |
| --- | --- |
-| | [Ключевые типы](/Part 1 - Getting Started/2. Key types.md) |
+| | [Ключевые типы]() |
diff --git a/Part 1 - Getting Started/2. Key types.md b/Part 1 - Getting Started/2. Key types.md
index d93424b..6176621 100644
--- a/Part 1 - Getting Started/2. Key types.md
+++ b/Part 1 - Getting Started/2. Key types.md
@@ -1,7 +1,7 @@
Ключевые типы
Rx базируется на двух фундаментальных типах, в то время, как некоторые другие расширяют их функциональность. Этими базовыми типами являются Observable и Observer, которые мы и рассмотрим в этом разделе. Мы также рассмотрим Subject’ы – они помогут в понимании основных концепций Rx.
-Rx построена на паттерне Observer. В этом нет ничего нового, обработчики событий уже существуют в Java (например, JavaFX EventHandler[1]), однако они проигрывают в сравнении с Rx по следующим причинам:
+Rx построена на паттерне Observer. В этом нет ничего нового, обработчики событий уже существуют в Java (например, JavaFX EventHandler[[1](#notes)], однако они проигрывают в сравнении с Rx по следующим причинам:
- Обработку событий в них сложно компоновать
- Их вызов нельзя отложить
@@ -10,17 +10,17 @@ Rx построена на паттерне Observable – первый базовый тип, который мы рассмотрим. Этот класс содержит в себе основную часть реализации Rx, включая все базовые операторы. Мы рассмотрим их позже, а пока нам следует понять принцип работы метода subscribe. Вот ключевая перегрузка [2]:
+Observable – первый базовый тип, который мы рассмотрим. Этот класс содержит в себе основную часть реализации Rx, включая все базовые операторы. Мы рассмотрим их позже, а пока нам следует понять принцип работы метода subscribe. Вот ключевая перегрузка [[2](#notes)]:
```JAVA
public final Subscription subscribe(Observer observer)
```
-Метод subscribe используется для получения данных выдаваемых [3] observable. Эти данные передаются наблюдателю, который предполагает их обработку в зависимости от требований потребителя. Наблюдатель в этом случае является реализацией интерфейса Observer.
+Метод subscribe используется для получения данных выдаваемых [[3](#notes)] observable. Эти данные передаются наблюдателю, который предполагает их обработку в зависимости от требований потребителя. Наблюдатель в этом случае является реализацией интерфейса Observer.
Observable сообщает три вида событий:
- Данные
- - Сигнал о завершении последовательности [4] (что означает, что новых данных больше не будет)
+ - Сигнал о завершении последовательности [[4](#notes)] (что означает, что новых данных больше не будет)
- Ошибку, если последовательность завершилась по причине исключительной ситуации (это событие так же предполагает завершение последовательности)
Observer
@@ -202,14 +202,14 @@ s.onNext(2);
```
Безопасность не может быть гарантирована везде, где используется Rx, поэтому вам лучше быть в курсе и не нарушать этот принцип, так как это может привести к неопределенным последствиям.
-notes
-[1] Или знакомые всем Event Listeners. – Примеч. Автора
-[2] Я, все-таки считаю, что ключевой перегрузкой тут является именно версия с Observer в качестве аргумента, в оригинале в качестве примера приводится версия subscribe(Subscriber subscriber) – Примеч. Автора
-[3] Я буду использовать слово «выдавать», чтобы описать событие передачи данных от Observable Observer’у (to emit в ориг.). – Примеч. Автора
+###### notes
+[1] Или знакомые всем Event Listeners. – Примеч. Автора\
+[2] Я, все-таки считаю, что ключевой перегрузкой тут является именно версия с Observer в качестве аргумента, в оригинале в качестве примера приводится версия subscribe(Subscriber subscriber) – Примеч. Автора\
+[3] Я буду использовать слово «выдавать», чтобы описать событие передачи данных от Observable Observer’у (to emit в ориг.). – Примеч. Автора\
[4] Автор использует термин последовательность (sequence), чтобы обозначить множество всех данных, которые может выдать Observable. – Примеч. Автора
#### Продолжить чтение
| Назад | Вперед |
| --- | --- |
-| [Почему Rx](/Part 1 - Getting Started/1. Why Rx.md) | [Жизненный цикл подписки](/Part 1 - Getting Started/3. Lifetime management.md) |
+| [Почему Rx]() | [Жизненный цикл подписки]() |
diff --git a/Part 1 - Getting Started/3. Lifetime management.md b/Part 1 - Getting Started/3. Lifetime management.md
index c9c03dd..064e479 100644
--- a/Part 1 - Getting Started/3. Lifetime management.md
+++ b/Part 1 - Getting Started/3. Lifetime management.md
@@ -1,10 +1,10 @@
-# Lifetime management
+# Жизненный цикл подписки
-The idea behind Rx is that it is unknown *when* a sequence emits values or terminates, but you still have control over when you begin and stop accepting values. Subscriptions may be linked to allocated resources that you will want to release at the end of a sequence. Rx provides control over your subscriptions to enable you to do that.
+Библиотека Rx основана на идее, что нам не известно *когда* последовательность выдаст значения или закончится, но у нас есть контроль того, когда начать или прекратить получать значения. Подписки могу быть привязаны к выделенным ресурсам, которые нужно освободить по окончании последовательности. Rx предоставляет контроль подписок, чтобы это было возможно.
-## Subscribing
+## Подписка
-There are several overloads to `Observable.subscribe`, which are shorthands for the same thing.
+Есть несколько перегрузок `Observable.subscribe`, которые выполняют одно и то же действие.
```java
Subscription subscribe()
@@ -15,9 +15,9 @@ Subscription subscribe(Observer observer)
Subscription subscribe(Subscriber subscriber)
```
-`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 event is practically ignored.
+`subscribe()` поглощает события, но не выполняет никаких действий. Перегрузки, которые получают одно и более `Action` создают `Subscriber` с функцией, которую вы предоставите. Если вы не предоставляете action, то события игнорируются.
-In the following example, we handle the error of a sequence that failed.
+В примере ниже мы обрабатываем ошибки в последовательности, которая завершается с ошибкой.
```java
Subject s = ReplaySubject.create();
@@ -28,24 +28,25 @@ s.onNext(0);
s.onError(new Exception("Oops"));
```
-Output
+Вывод
```
0
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, 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.
+Если мы не предоставим функцию для обработки ошибок, то `OnErrorNotImplementedException` будет *выкинута* в месте, где вызывается `s.onError`, т.е. на стороне поставщика последовательности. В нашем примере поставщик и потребитель описаны рядом, потому очень просто можно добавить try-catch для обработки ошибки. Однако, в сложных модульных системах поставщик и потребитель очень часто находятся в разных местах. Если потребитель не предоставит обработчика ошибок в `subscribe`, то никогда и не узнает, что произошла какая-то ошибка и последовательность закончена.
-## 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:
+## Отписка
+
+Вы также можете прекратить получать значения *до* окончания последовательности. Каждая перегрузка `subscribe` возвращает экземпляр интерфейса `Subscription` с 2 методами:
```java
boolean isUnsubscribed()
void unsubscribe()
```
-Calling `unsubscribe` will stop events from being pushed to your observer.
+Вызов `unsubscribe` остановит отправку событий вашему наблюдателю.
```java
Subject values = ReplaySubject.create();
@@ -59,13 +60,13 @@ values.onNext(1);
subscription.unsubscribe();
values.onNext(2);
```
-[Output](/tests/java/itrx/chapter1/UnsubscribingExample.java)
+[Вывод](/tests/java/itrx/chapter1/UnsubscribingExample.java)
```
0
1
```
-Unsubscribing one observer does not interfere with other observers on the same observable.
+Отписка одного наблюдателя не влияет на других наблюдателей того же observable.
```java
Subject values = ReplaySubject.create();
@@ -81,7 +82,7 @@ subscription1.unsubscribe();
System.out.println("Unsubscribed first");
values.onNext(2);
```
-[Output](/tests/java/itrx/chapter1/UnsubscribingExample.java)
+[Вывод](/tests/java/itrx/chapter1/UnsubscribingExample.java)
```
First: 0
Second: 0
@@ -91,9 +92,9 @@ Unsubscribed first
Second: 2
```
-## onError and onCompleted
+## onError и onCompleted
-`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 observables.
+`onError` и `onCompleted` означают окончание последовательности. Observable выполняющее соглашения Rx не будет ничего выдавать после любого из этих событий. Это стоит помнить при потреблении событий в Rx и при реализации своих observables.
```java
Subject values = ReplaySubject.create();
@@ -107,32 +108,32 @@ values.onNext(1);
values.onCompleted();
values.onNext(2);
```
-[Output](/tests/java/itrx/chapter1/RxContractExample.java)
+[Вывод](/tests/java/itrx/chapter1/RxContractExample.java)
```
First: 0
First: 1
Completed
```
-## Freeing resources
+## Освобождение ресурсов
-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.
+`Subscription` привязана к ресурсам, которые использует. По этой причине стоит помнить об освобождении подписок. Можно создать связь между `Subscription` и необходимыми ресусами при помощи фабрики [Subscriptions](http://reactivex.io/RxJava/javadoc/rx/subscriptions/Subscriptions.html).
```java
Subscription s = Subscriptions.create(() -> System.out.println("Clean"));
s.unsubscribe();
```
-[Output](/tests/java/itrx/chapter1/UnsubscribingExample.java)
+[Вывод](/tests/java/itrx/chapter1/UnsubscribingExample.java)
```
Clean
```
-`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.
+`Subscriptions.create` получает действие, которое будет выполнено при отписке для освобождения ресурсов. Также есть несколько сокращений для частых действий при создании последовательности.
+* `Subscriptions.empty()` возвращает `Subscription`, которая ничего не делает при уничтожении. Это удобано, когда вам нужно вернуть экземпляр `Subscription`, но ваша реализация не нуждается в освобождении ресурсов.
+* `Subscriptions.from(Subscription... subscriptions)` возвращает `Subscription`, которая уничтожает несколько других подписок при своём уничтожении.
+* `Subscriptions.unsubscribed()` возвращает `Subscription`, которая уже уничтожена.
-There are several implementations of `Subscription`.
+Есть несколько реализаций `Subscription`.
* `BooleanSubscription`
* `CompositeSubscription`
@@ -145,10 +146,10 @@ There are several implementations of `Subscription`.
* `Subscriber`
* `TestSubscriber`
-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.
+Мы рассмотрим больше их примеров позже в книге. Интересно отметить, что `Subscriber` также реализует `Subscription`. Это означает, что мы также можем использовать ссылку на `Subscriber` для прерывания подписки.
-#### Continue reading
+#### Продолжить чтение
-| Previous | Next |
+| Назад | Вперед |
| --- | --- |
-| [Key types](/Part 1 - Getting Started/2. Key types.md) | [Chapter 2](/Part 2 - Sequence Basics/1. Creating a sequence.md) |
+| [Ключевые типы]() | [Часть 2]() |
diff --git a/Part 2 - Sequence Basics/1. Creating a sequence.md b/Part 2 - Sequence Basics/1. Creating a sequence.md
index 376edb8..f05d5b1 100644
--- a/Part 2 - Sequence Basics/1. Creating a sequence.md
+++ b/Part 2 - Sequence Basics/1. Creating a sequence.md
@@ -302,4 +302,4 @@ Completed
| Назад | Вперед |
| --- | --- |
-| [Жизненный цикл подписки](/Part 1 - Getting Started/3. Lifetime management.md) | [Фильтрация последовательности](/Part 2 - Sequence Basics/2. Reducing a sequence.md) |
+| [Жизненный цикл подписки]() | [Фильтрация последовательности]() |
diff --git a/Part 2 - Sequence Basics/2. Reducing a sequence.md b/Part 2 - Sequence Basics/2. Reducing a sequence.md
index c5c824c..2699045 100644
--- a/Part 2 - Sequence Basics/2. Reducing a sequence.md
+++ b/Part 2 - Sequence Basics/2. Reducing a sequence.md
@@ -439,4 +439,4 @@ Subscription subscription = values
| Назад | Вперед |
| --- | --- |
-| [Создание последовательности](/Part 2 - Sequence Basics/1. Creating a sequence.md) | [Исследование последовательности](/Part 2 - Sequence Basics/3. Inspection.md) |
+| [Создание последовательности]() | [Исследование последовательности]() |
diff --git a/Part 2 - Sequence Basics/3. Inspection.md b/Part 2 - Sequence Basics/3. Inspection.md
index c0ae5ca..a2f8413 100644
--- a/Part 2 - Sequence Basics/3. Inspection.md
+++ b/Part 2 - Sequence Basics/3. Inspection.md
@@ -338,4 +338,4 @@ Error: java.lang.Exception
| Назад | Вперед |
| --- | --- |
-| [Фильтрация последовательности](/Part 2 - Sequence Basics/2. Reducing a sequence.md) | [Агрегация](/Part 2 - Sequence Basics/4. Aggregation.md) |
+| [Фильтрация последовательности]() | [Агрегация]() |
diff --git a/Part 2 - Sequence Basics/4. Aggregation.md b/Part 2 - Sequence Basics/4. Aggregation.md
index 7687cfc..5ae9e0b 100644
--- a/Part 2 - Sequence Basics/4. Aggregation.md
+++ b/Part 2 - Sequence Basics/4. Aggregation.md
@@ -567,4 +567,4 @@ Nesting observables to consume them doesn't make much sense. Towards the end of
| Previous | Next |
| --- | --- |
-| [Inspection](/Part 2 - Sequence Basics/3. Inspection.md) | [Transformation of sequences](/Part 2 - Sequence Basics/5. Transformation of sequences.md) |
+| [Inspection](/Part%202%20-%20Sequence%20Basics/3.%20Inspection.md) | [Transformation of sequences](/Part%202%20-%20Sequence%20Basics/5.%20Transformation%20of%20sequences.md) |
diff --git a/Part 2 - Sequence Basics/5. Transformation of sequences.md b/Part 2 - Sequence Basics/5. Transformation of sequences.md
index 82deddf..4834f66 100644
--- a/Part 2 - Sequence Basics/5. Transformation of sequences.md
+++ b/Part 2 - Sequence Basics/5. Transformation of sequences.md
@@ -487,4 +487,4 @@ Observable.range(1, 3)
| Previous | Next |
| --- | --- |
-| [Aggregation](/Part 2 - Sequence Basics/4. Aggregation.md) | [Chapter 3 - Taming the sequence](/Part 3 - Taming the sequence/1. Side effects.md) |
+| [Aggregation](/Part%202%20-%20Sequence%20Basics/4.%20Aggregation.md) | [Chapter 3 - Taming the sequence](/Part%203%20-%20Taming%20the%20sequence/1.%20Side%20effects.md) |
diff --git a/Part 3 - Taming the sequence/1. Side effects.md b/Part 3 - Taming the sequence/1. Side effects.md
index 81be09f..28eb3d7 100644
--- a/Part 3 - Taming the sequence/1. Side effects.md
+++ b/Part 3 - Taming the sequence/1. Side effects.md
@@ -329,4 +329,4 @@ The first subscriber is the first to be called for each item. Its action is to m
| Previous | Next |
| --- | --- |
-| [Transformation of sequences](/Part 2 - Sequence Basics/5. Transformation of sequences.md) | [Leaving the monad](/Part 3 - Taming the sequence/2. Leaving the monad.md) |
+| [Transformation of sequences](/Part%202%20-%20Sequence%20Basics/5.%20Transformation%20of%20sequences.md) | [Leaving the monad](/Part%203%20-%20Taming%20the%20sequence/2.%20Leaving%20the%20monad.md) |
diff --git a/Part 3 - Taming the sequence/2. Leaving the monad.md b/Part 3 - Taming the sequence/2. Leaving the monad.md
index ff12ac9..6c7150d 100644
--- a/Part 3 - Taming the sequence/2. Leaving the monad.md
+++ b/Part 3 - Taming the sequence/2. Leaving the monad.md
@@ -1,6 +1,6 @@
# Leaving the monad
-A [monad] (https://en.wikipedia.org/wiki/Monad_%28functional_programming%29) is an abstract concept from functional programming that is unfamiliar to most programmers. It is beyond the scope of this guide teaching monads. In www.introtorx.com we find a short definition:
+A [monad](https://en.wikipedia.org/wiki/Monad_%28functional_programming%29) is an abstract concept from functional programming that is unfamiliar to most programmers. It is beyond the scope of this guide teaching monads. In www.introtorx.com we find a short definition:
> Monads are a kind of abstract data type constructor that encapsulate program logic instead of data in the domain model.
Monads are of interest to us, because the observable is a monad. Rx code declares what needs to be done but the actual processing happens not when Rx statements are executed, but rather when values are emitted. Readers may find it interesting to read more about monads in general. For this guide, when refering to monads the reader only needs to think about the observable.
@@ -325,4 +325,4 @@ Some blocking ways to access observables, such as `last()`, require the observab
| Previous | Next |
| --- | --- |
-| [Side effects](/Part 3 - Taming the sequence/1. Side effects.md) | [Advanced error handling](/Part 3 - Taming the sequence/3. Advanced error handling.md) |
+| [Side effects](/Part%203%20-%20Taming%20the%20sequence/1.%20Side%20effects.md) | [Advanced error handling](/Part%203%20-%20Taming%20the%20sequence/3.%20Advanced%20error%20handling.md) |
diff --git a/Part 3 - Taming the sequence/3. Advanced error handling.md b/Part 3 - Taming the sequence/3. Advanced error handling.md
index 2fc76f4..db1dfd4 100644
--- a/Part 3 - Taming the sequence/3. Advanced error handling.md
+++ b/Part 3 - Taming the sequence/3. Advanced error handling.md
@@ -234,4 +234,4 @@ It is important to note here that we are responsible for terminating the observa
| Previous | Next |
| --- | --- |
-| [Leaving the monad](/Part 3 - Taming the sequence/2. Leaving the monad.md) | [Combining sequences](/Part 3 - Taming the sequence/4. Combining sequences.md) |
+| [Leaving the monad](/Part%203%20-%20Taming%20the%20sequence/2.%20Leaving%20the%20monad.md) | [Combining sequences](/Part%203%20-%20Taming%20the%20sequence/4.%20Combining%20sequences.md) |
diff --git a/Part 3 - Taming the sequence/4. Combining sequences.md b/Part 3 - Taming the sequence/4. Combining sequences.md
index fa3ea6d..73e08cd 100644
--- a/Part 3 - Taming the sequence/4. Combining sequences.md
+++ b/Part 3 - Taming the sequence/4. Combining sequences.md
@@ -673,4 +673,4 @@ I like to think of `combineLatest` as one event occuring in the context of anoth
| Previous | Next |
| --- | --- |
-| [Advanced error handling](/Part 3 - Taming the sequence/3. Advanced error handling.md) | [Time-shifted sequences](/Part 3 - Taming the sequence/5. Time-shifted sequences.md) |
+| [Advanced error handling](/Part%203%20-%20Taming%20the%20sequence/3.%20Advanced%20error%20handling.md) | [Time-shifted sequences](/Part%203%20-%20Taming%20the%20sequence/5.%20Time-shifted%20sequences.md) |
diff --git a/Part 3 - Taming the sequence/5. Time-shifted sequences.md b/Part 3 - Taming the sequence/5. Time-shifted sequences.md
index abb50bc..c7ee3cd 100644
--- a/Part 3 - Taming the sequence/5. Time-shifted sequences.md
+++ b/Part 3 - Taming the sequence/5. Time-shifted sequences.md
@@ -603,4 +603,4 @@ The output is the same as the previous two examples
| Previous | Next |
| --- | --- |
-| [Combining sequences](/Part 3 - Taming the sequence/4. Combining sequences.md) | [Hot and cold observables](/Part 3 - Taming the sequence/6. Hot and Cold observables.md) |
+| [Combining sequences](/Part%203%20-%20Taming%20the%20sequence/4.%20Combining%20sequences.md) | [Hot and cold observables](/Part%203%20-%20Taming%20the%20sequence/6.%20Hot%20and%20Cold%20observables.md) |
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
index 0800734..f4bd468 100644
--- a/Part 3 - Taming the sequence/6. Hot and Cold observables.md
+++ b/Part 3 - Taming the sequence/6. Hot and Cold observables.md
@@ -364,4 +364,4 @@ The `share` method is an alias for `Observable.publish().refCount()`. It allows
| Previous | Next |
| --- | --- |
-| [Time-shifted sequences](/Part 3 - Taming the sequence/5. Time-shifted sequences.md) | [Custom operators](/Part 3 - Taming the sequence/7. Custom operators.md) |
+| [Time-shifted sequences](/Part%203%20-%20Taming%20the%20sequence/5.%20Time-shifted%20sequences.md) | [Custom operators](/Part%203%20-%20Taming%20the%20sequence/7.%20Custom%20operators.md) |
diff --git a/Part 3 - Taming the sequence/7. Custom operators.md b/Part 3 - Taming the sequence/7. Custom operators.md
index 30f3f2e..c23103f 100644
--- a/Part 3 - Taming the sequence/7. Custom operators.md
+++ b/Part 3 - Taming the sequence/7. Custom operators.md
@@ -404,4 +404,4 @@ Theoretically, any operator can be implemented as both `Observable.Operator` and
| Previous | Next |
| --- | --- |
-| [Hot and cold observables](/Part 3 - Taming the sequence/6. Hot and Cold observables.md) | [Chapter 4 - Concurrency](/Part 4 - Concurrency/1. Scheduling and threading.md) |
+| [Hot and cold observables](/Part%203%20-%20Taming%20the%20sequence/6.%20Hot%20and%20Cold%20observables.md) | [Chapter 4 - Concurrency](/Part%204%20-%20Concurrency/1.%20Scheduling%20and%20threading.md) |
diff --git a/Part 4 - Concurrency/1. Scheduling and threading.md b/Part 4 - Concurrency/1. Scheduling and threading.md
index 5023ba1..dad0759 100644
--- a/Part 4 - Concurrency/1. Scheduling and threading.md
+++ b/Part 4 - Concurrency/1. Scheduling and threading.md
@@ -392,4 +392,4 @@ Again on 11
| Previous | Next |
| --- | --- |
-| [Custom operators](/Part 3 - Taming the sequence/7. Custom operators.md) | [Testing Rx](/Part 4 - Concurrency/2. Testing Rx.md) |
+| [Custom operators](/Part%203%20-%20Taming%20the%20sequence/7.%20Custom%20operators.md) | [Testing Rx](/Part%204%20-%20Concurrency/2.%20Testing%20Rx.md) |
diff --git a/Part 4 - Concurrency/2. Testing Rx.md b/Part 4 - Concurrency/2. Testing Rx.md
index a3530c5..a892158 100644
--- a/Part 4 - Concurrency/2. Testing Rx.md
+++ b/Part 4 - Concurrency/2. Testing Rx.md
@@ -227,4 +227,4 @@ Awaiting with a timeout will cause an exception if the observable fails to compl
| Previous | Next |
| --- | --- |
-| [Scheduling and threading](/Part 4 - Concurrency/1. Scheduling and threading.md) | [Sequences of coincidence](/Part 4 - Concurrency/3. Sequences of coincidence.md) |
+| [Scheduling and threading](/Part%204%20-%20Concurrency/1.%20Scheduling%20and%20threading.md) | [Sequences of coincidence](/Part%204%20-%20Concurrency/3.%20Sequences%20of%20coincidence.md) |
diff --git a/Part 4 - Concurrency/3. Sequences of coincidence.md b/Part 4 - Concurrency/3. Sequences of coincidence.md
index c04bcda..9971b76 100644
--- a/Part 4 - Concurrency/3. Sequences of coincidence.md
+++ b/Part 4 - Concurrency/3. Sequences of coincidence.md
@@ -293,4 +293,4 @@ You can also implement `groupJoin` with `join` and `groupBy`. Doing so would req
| Previous | Next |
| --- | --- |
-| [Testing Rx](/Part 4 - Concurrency/2. Testing Rx.md) | [Backpressure](/Part 4 - Concurrency/4. Backpressure.md) |
+| [Testing Rx](/Part%204%20-%20Concurrency/2.%20Testing%20Rx.md) | [Backpressure](/Part%204%20-%20Concurrency/4.%20Backpressure.md) |
diff --git a/Part 4 - Concurrency/4. Backpressure.md b/Part 4 - Concurrency/4. Backpressure.md
index f239ff7..73bb349 100644
--- a/Part 4 - Concurrency/4. Backpressure.md
+++ b/Part 4 - Concurrency/4. Backpressure.md
@@ -353,4 +353,4 @@ What we see here is that the first 128 items where consumed normally, but then w
| Previous | Next |
| --- | --- |
-| [Sequences of coincidence](/Part 4 - Concurrency/3. Sequences of coincidence.md) | |
+| [Sequences of coincidence](/Part%204%20-%20Concurrency/3.%20Sequences%20of%20coincidence.md) | |
diff --git a/README.md b/README.md
index c63b99e..ee3396f 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@
Для следования этой обучающей программе от вас не потребуются знания реактивного или функционального программирования, однако, предполагается наличие базовых знаний Java.
-[Начать изучение](/Part 1 - Getting Started/1. Why Rx.md)
+[Начать изучение](/Part%201%20-%20Getting%20Started/1.%20Why%20Rx.md)
### Структура