diff --git a/src-russian/01_introduction.md b/src-russian/01_introduction.md
index 1378e1c..621fe49 100644
--- a/src-russian/01_introduction.md
+++ b/src-russian/01_introduction.md
@@ -5,9 +5,9 @@
 начиная от простого приложения с рендерингом в браузере и постепенно перейдём к full-stack
 приложению с рендерингом на стороне сервера и гидратацией.
 
-Данное руководство не ждёт, что вы знаете что-либо о мелкозернистой реактивности (англ. [fine-grained reactivity](https://www.google.com/search?q=fine-grained+reactivity))
+Данное руководство не ждёт, что вы что-либо знаете о мелкозернистой реактивности (_англ. [fine-grained reactivity](https://www.google.com/search?q=fine-grained+reactivity)_)
 или о особенностях современных Веб-фреймворков. Оно подразумевает, что вы знакомы 
-с Rust, HTML, CSS, а также DOM и простые Web API.
+с Rust, HTML, CSS, а также с DOM и с простыми Web API.
 
 Leptos больше всего похож на такие фреймворки как [Solid](https://www.solidjs.com) (JavaScript)
 и [Sycamore](https://sycamore-rs.netlify.app/) (Rust). У него также есть схожие черты с другими фреймворками,
diff --git a/src-russian/SUMMARY.md b/src-russian/SUMMARY.md
index fac4c6b..d13d5c9 100644
--- a/src-russian/SUMMARY.md
+++ b/src-russian/SUMMARY.md
@@ -13,8 +13,8 @@
     - [Формы и поля ввода](./view/05_forms.md)
     - [Порядок выполнения](./view/06_control_flow.md)
     - [Обработка ошибок](./view/07_errors.md)
-    - [Общение Родитель-Ребёнок в дереве компонентов](./view/08_parent_child.md)
-    - [Передача Детей другим компонентам](./view/09_component_children.md)
+    - [Коммуникация Родитель-Ребёнок](./view/08_parent_child.md)
+    - [Передача дочерних элементов другим компонентам](./view/09_component_children.md)
     - [Без макросов: синтаксис билдера View](./view/builder.md)
 - [Реактивность](./reactivity/README.md)
     - [Работа с сигналами](./reactivity/working_with_signals.md)
diff --git a/src-russian/getting_started/leptos_dx.md b/src-russian/getting_started/leptos_dx.md
index c095350..fb779e6 100644
--- a/src-russian/getting_started/leptos_dx.md
+++ b/src-russian/getting_started/leptos_dx.md
@@ -16,7 +16,7 @@
 1. Выполните `cargo add console_error_panic_hook` в вашем проекте
 2. В вашей функции main добавьте вызов `console_error_panic_hook::set_once();`
 
-> Если это непонятно, [вот пример](https://github.com/leptos-rs/leptos/blob/main/examples/counter/src/main.rs#L4-L15).
+> Если это не понятно, [вот пример](https://github.com/leptos-rs/leptos/blob/main/examples/counter/src/main.rs#L4-L15).
 
 Теперь сообщения о паниках в консоле браузере будут намного лучше!
 
diff --git a/src-russian/view/01_basic_component.md b/src-russian/view/01_basic_component.md
index 225e310..6155319 100644
--- a/src-russian/view/01_basic_component.md
+++ b/src-russian/view/01_basic_component.md
@@ -158,7 +158,7 @@ move |_| {
 [Кликните чтобы открыть CodeSandbox.](https://codesandbox.io/p/sandbox/1-basic-component-3d74p3?file=%2Fsrc%2Fmain.rs%3A1%2C1)
 
 <noscript>
-  Пожалуйста включите Javascript для просмотра примеров.
+  Пожалуйста, включите Javascript для просмотра примеров.
 </noscript>
 
 > Чтобы увидеть браузер в песочнице вам может понадобиться нажать `Add DevTools >
diff --git a/src-russian/view/02_dynamic_attributes.md b/src-russian/view/02_dynamic_attributes.md
index 5c2f0e9..bfd5526 100644
--- a/src-russian/view/02_dynamic_attributes.md
+++ b/src-russian/view/02_dynamic_attributes.md
@@ -166,7 +166,7 @@ let double_count = move || count() * 2;
 > #### Продвинутая тема: Вставка Сырого HTML
 >
 > Макрос `view` поддерживает дополнительный атрибут, `inner_html`, который можно использовать для прямого задания
-> тела любого элемента в виде HTML, затирая при этом любых Детей, которые могли в нём находиться.
+> тела любого элемента в виде HTML, затирая при этом любых дочерние элементы, которые могли в нём находиться.
 > Обратите внимание, что он **не** экранирует HTML, который вы передаете. Вам следует убедиться в том, что передаваемый HTML
 > собран из доверенных источников или что все HTML-сущности экранированы, дабы предотвратить cross-site scripting (XSS)  атаки.
 >
@@ -184,7 +184,7 @@ let double_count = move || count() * 2;
 [Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/2-dynamic-attributes-0-5-lwdrpm?file=%2Fsrc%2Fmain.rs%3A1%2C1)
 
 <noscript>
-  Пожалуйста включите Javascript для просмотра примеров.
+  Пожалуйста, включите Javascript для просмотра примеров.
 </noscript>
 
 <template>
diff --git a/src-russian/view/03_components.md b/src-russian/view/03_components.md
index dc2157b..68917c0 100644
--- a/src-russian/view/03_components.md
+++ b/src-russian/view/03_components.md
@@ -396,7 +396,7 @@ fn ProgressBar(
 [Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/3-components-0-5-5vvl69?file=%2Fsrc%2Fmain.rs%3A1%2C1)
 
 <noscript>
-  Пожалуйста включите Javascript для просмотра примеров.
+  Пожалуйста, включите Javascript для просмотра примеров.
 </noscript>
 
 <template>
diff --git a/src-russian/view/04_iteration.md b/src-russian/view/04_iteration.md
index b81630f..99e7b05 100644
--- a/src-russian/view/04_iteration.md
+++ b/src-russian/view/04_iteration.md
@@ -104,7 +104,7 @@ view! {
 [Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/4-iteration-0-5-pwdn2y?file=%2Fsrc%2Fmain.rs%3A1%2C1)
 
 <noscript>
-  Пожалуйста включите Javascript для просмотра примеров.
+  Пожалуйста, включите Javascript для просмотра примеров.
 </noscript>
 
 <template>
diff --git a/src-russian/view/04b_iteration.md b/src-russian/view/04b_iteration.md
index 4f23958..7f6d282 100644
--- a/src-russian/view/04b_iteration.md
+++ b/src-russian/view/04b_iteration.md
@@ -125,7 +125,7 @@ pub fn App() -> impl IntoView {
 
 ## Вариант 2: Вложенные Сигналы
 
-Если мы всё же хотим мелкозернистую реактивность (англ. [fine-grained reactivity](https://www.google.com/search?q=fine-grained+reactivity))
+Если мы всё же хотим мелкозернистую реактивность (_англ. [fine-grained reactivity](https://www.google.com/search?q=fine-grained+reactivity)_)
 для значения, одним из вариантов явлется обернуть `value` каждого ряда в сигнал.
 
 ```rust
diff --git a/src-russian/view/05_forms.md b/src-russian/view/05_forms.md
new file mode 100644
index 0000000..32a252c
--- /dev/null
+++ b/src-russian/view/05_forms.md
@@ -0,0 +1,328 @@
+# Формы и поля ввода
+
+Формы и поля ввода — важная часть интерактивных приложений. Есть два паттерна взаимодействия
+с полями ввода в Leptos. Вы, возможно, уже их знаете, если вы знакомы с React, SolidJS или похожим фреймворком:
+использование **контролируемых** или **неконтролируемых** элементов форм.
+
+## Контролируемые поля ввода
+
+В случае с "контролируемым полем ввода" фреймворк контролирует состояние элемента. При каждом `input` событии, он
+обновляет локальный сигнал, хранящий текущее состояние, который, в свою очередь, обновляет значение свойства `value`.
+
+Есть две важные вещи, которые нужно запомнить:
+
+1. Событие `input` срабатывает (почти) при каждом изменении элемента, когда как `change`  (обычно) срабатывает только
+после того, как вы сняли фокус с поля ввода. Вам наверно подойдёт `on:input`, но мы хотим дать вам свободу выбирать.
+
+2. Значение _атрибута_ `value` лишь задает первоначальное значение поля ввода, то есть, оно обновляет значение поля ввода
+лишь до тех пор, пока вы не начали печатать. _Свойство_ `value` продолжает обновлять поле вода и после этого.
+По этой причине, обычно вам стоит использовать `prop:value`. (Это также справедливо для `checked` и `prop:checked`
+   в `<input type="checkbox">`.)
+
+```rust
+let (name, set_name) = create_signal("Controlled".to_string());
+
+view! {
+    <input type="text"
+        on:input=move |ev| {
+            // event_target_value is a Leptos helper function
+            // it functions the same way as event.target.value
+            // in JavaScript, but smooths out some of the typecasting
+            // necessary to make this work in Rust
+            set_name(event_target_value(&ev));
+        }
+
+        // the `prop:` syntax lets you update a DOM property,
+        // rather than an attribute.
+        prop:value=name
+    />
+    <p>"Name is: " {name}</p>
+}
+```
+
+> #### Зачем нужно `prop:value`?
+>
+> Веб-браузеры это самая вездесущая и стабильная платформа рендеринга графических пользовательских интерфейсов из всех существующих.
+
+> Они также сохранили невероятную обратную совместимость на протяжении трёх десятков лет. Это неизбежно означает, что есть и странности.
+> 
+> Одна из странностей состоит в том, что есть разница между HTML атрибутами и свойствами DOM элемента, то есть, 
+> между так называемым "атрибутом", что берется из HTML и может быть задан DOM-элементу с помощью  `.setAttribute()`,
+> и между "свойством" — полем в JavaScript-представлении этого элемента HTML.
+>
+> В случае с `<input value=...>`, _атрибут_ `value` задаёт первоначальное значение этого поля ввода,
+> а _свойство_ `value` задаёт его текущее значение. Возможно самый простой способ разобраться с этим это открыть  `about:blank`
+> и выполнить следующий код на JavaScript в консоли браузера строчка за строчкой:
+>
+>
+> ```js
+> // создадим поле ввода и добавим его в DOM
+> const el = document.createElement("input");
+> document.body.appendChild(el);
+>
+> el.setAttribute("value", "тест"); // изменяет значение поля ввода
+> el.setAttribute("value", "тест тест"); // тоже изменяет значение поля ввода
+>
+> // теперь напечайте что-нибудь в поле ввода: удалите какие-нибудь символы и т. д.
+>
+> el.setAttribute("value", "ещё разок?");
+> // ничего не должно было измениться. смена "первоначального значения" теперь ни на что не влияет
+>
+> // однако...
+> el.value = "А это работает";
+> ```
+>
+> Многие другие frontend фреймворки объединяют атрибуты и свойства или в порядке исключения для полей ввода устанавливают
+> значение корректно. Может Leptos'у тоже стоит так делать; но пока что я предпочитаю давать пользователям максимальную
+> степень контроля над тем что они задают — атрибут или свойство, и делаю всё, что в моих силах, чтобы рассказать людям
+> о реальном поведении браузера, вместо того, чтобы скрывать его.
+
+## Неконтролируемые поля ввода
+
+В случае "неконтролируемого поля ввода" браузера сам управляет состояние элемента поля ввода.
+Вместо того чтобы постоянно обновлять сигнал, чтобы он содержал значение поля, мы используем [`NodeRef`](https://docs.rs/leptos/latest/leptos/struct.NodeRef.html) для
+получения доступа к полю ввода когда мы хотим получить его значение.
+
+В данном примере мы уведомляем фреймворк лишь когда `<form>` вызывает событие `submit`.
+Обратите внимание на использование модуля  [`leptos::html`](https://docs.rs/leptos/latest/leptos/html/index.html#), который предоставляет набор типов для каждого элемента HTML.
+
+```rust
+let (name, set_name) = create_signal("Uncontrolled".to_string());
+
+let input_element: NodeRef<html::Input> = create_node_ref();
+
+view! {
+    <form on:submit=on_submit> // on_submit defined below
+        <input type="text"
+            value=name
+            node_ref=input_element
+        />
+        <input type="submit" value="Submit"/>
+    </form>
+    <p>"Name is: " {name}</p>
+}
+```
+
+Данный view уже должен быть достаточно понятен без объяснений. Обратите внимание на следующие вещи:
+
+1. В отличие от примера с контролируемыми полями ввода, мы используем `value` (не `prop:value`).
+   Это потому, что мы просто задаём первоначальное значение поля ввода и позволяем браузеру его состояние.
+   (Мы могли бы использовать `prop:value` вместо этого.)
+2. Мы используем `node_ref=...` чтобы заполнить `NodeRef`. (Более старые примеры иногда используют `_ref`.
+Это то же само, но `node_ref` лучше поддерживается анализатором Rust.)
+
+`NodeRef` это наподобие реактивного умного указателя: мы можем использовать его для доступа к узлу DOM, на который тот указывает.
+Значение `NodeRef` задаётся когда соответствующий элемент отрендерен.
+
+```rust
+let on_submit = move |ev: leptos::ev::SubmitEvent| {
+    // stop the page from reloading!
+    ev.prevent_default();
+
+    // here, we'll extract the value from the input
+    let value = input_element()
+        // event handlers can only fire after the view
+        // is mounted to the DOM, so the `NodeRef` will be `Some`
+        .expect("<input> should be mounted")
+        // `leptos::HtmlElement<html::Input>` implements `Deref`
+        // to a `web_sys::HtmlInputElement`.
+        // this means we can call`HtmlInputElement::value()`
+        // to get the current value of the input
+        .value();
+    set_name(value);
+};
+```
+
+Наш обработчик `on_submit` получит доступ к значению поля ввода и использует его при вызове `set_name`.
+Чтобы получить доступ к узлу DOM хранимому в `NodeRef`, мы можем просто вызвать его как функцию (или использовать `.get()`).
+Она вернёт тип `Option<leptos::HtmlElement<html::Input>>`, но мы знаем, что элемент уже был примонтирован (как иначе возникло событие!),
+так что вызов unwrap() здесь безопасен. 
+
+Затем мы можем `.value()` чтобы получить значение поля ввода, поскольку `NodeRef` даёт нам доступ к корректно типизированному 
+HTML элементу.
+
+Посмотрите на [`web_sys` and `HtmlElement`](../web_sys.md) чтобы узнать больше об использовании `leptos::HtmlElement`.
+Также посмотрите полный CodeSandbox пример в конце этой страницы.
+
+## Особые случаи: `<textarea>` и `<select>`
+
+Эти два элемента формы склонны вызывать непонимание, каждый по-своему.
+
+### `<textarea>`
+
+В отличие от `<input>`, элемент `<textarea>` не поддерживает атрибут `value`.
+Вместо этого, он получает своё значение в качестве текстового узла в своих HTML детях.
+
+В текущей версии Leptos (а точнее, в Leptos 0.1-0.6), создание динамического child-узла влечёт также вставку узла комментария-маркера.
+Это может вызвать некорректный рендеринг `<textarea>` (и проблемы во время гидратации) если вы попробуете использовать этот элемент для
+отображения какого-то динамического контента. 
+
+Вместо этого вы можете передать нереактивное первоначальное значение внутрь `<textarea>` и использовать `prop:value` чтобы задавать
+текущее значение.  (`<textarea>` не поддерживает **атрибут** `value`, но _поддерживает_
+ **свойство** `value`...)
+
+```rust
+view! {
+    <textarea
+        prop:value=move || some_value.get()
+        on:input=/* etc */
+    >
+        /* plain-text initial value, does not change if the signal changes */
+        {some_value.get_untracked()}
+    </textarea>
+}
+```
+
+### `<select>`
+
+Элемент `<select>` может таким же образом контролироваться через свойство `value` самого `<select>`, 
+`<option>` с этим значением будет выбран автоматически.
+
+```rust
+let (value, set_value) = create_signal(0i32);
+view! {
+  <select
+    on:change=move |ev| {
+      let new_value = event_target_value(&ev);
+      set_value(new_value.parse().unwrap());
+    }
+    prop:value=move || value.get().to_string()
+  >
+    <option value="0">"0"</option>
+    <option value="1">"1"</option>
+    <option value="2">"2"</option>
+  </select>
+  // a button that will cycle through the options
+  <button on:click=move |_| set_value.update(|n| {
+    if *n == 2 {
+      *n = 0;
+    } else {
+      *n += 1;
+    }
+  })>
+    "Next Option"
+  </button>
+}
+```
+
+```admonish sandbox title="Controlled vs uncontrolled forms CodeSandbox" collapsible=true
+
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/5-forms-0-5-rf2t7c?file=%2Fsrc%2Fmain.rs%3A1%2C1)
+
+<noscript>
+  Пожалуйста, включите Javascript для просмотра примеров.
+</noscript>
+
+<template>
+  <iframe src="https://codesandbox.io/p/sandbox/5-forms-0-5-rf2t7c?file=%2Fsrc%2Fmain.rs%3A1%2C1" width="100%" height="1000px" style="max-height: 100vh"></iframe>
+</template>
+
+```
+
+<details>
+<summary>Код примера CodeSandbox</summary>
+
+```rust
+use leptos::{ev::SubmitEvent, *};
+
+#[component]
+fn App() -> impl IntoView {
+    view! {
+        <h2>"Controlled Component"</h2>
+        <ControlledComponent/>
+        <h2>"Uncontrolled Component"</h2>
+        <UncontrolledComponent/>
+    }
+}
+
+#[component]
+fn ControlledComponent() -> impl IntoView {
+    // create a signal to hold the value
+    let (name, set_name) = create_signal("Controlled".to_string());
+
+    view! {
+        <input type="text"
+            // fire an event whenever the input changes
+            on:input=move |ev| {
+                // event_target_value is a Leptos helper function
+                // it functions the same way as event.target.value
+                // in JavaScript, but smooths out some of the typecasting
+                // necessary to make this work in Rust
+                set_name(event_target_value(&ev));
+            }
+
+            // the `prop:` syntax lets you update a DOM property,
+            // rather than an attribute.
+            //
+            // IMPORTANT: the `value` *attribute* only sets the
+            // initial value, until you have made a change.
+            // The `value` *property* sets the current value.
+            // This is a quirk of the DOM; I didn't invent it.
+            // Other frameworks gloss this over; I think it's
+            // more important to give you access to the browser
+            // as it really works.
+            //
+            // tl;dr: use prop:value for form inputs
+            prop:value=name
+        />
+        <p>"Name is: " {name}</p>
+    }
+}
+
+#[component]
+fn UncontrolledComponent() -> impl IntoView {
+    // import the type for <input>
+    use leptos::html::Input;
+
+    let (name, set_name) = create_signal("Uncontrolled".to_string());
+
+    // we'll use a NodeRef to store a reference to the input element
+    // this will be filled when the element is created
+    let input_element: NodeRef<Input> = create_node_ref();
+
+    // fires when the form `submit` event happens
+    // this will store the value of the <input> in our signal
+    let on_submit = move |ev: SubmitEvent| {
+        // stop the page from reloading!
+        ev.prevent_default();
+
+        // here, we'll extract the value from the input
+        let value = input_element()
+            // event handlers can only fire after the view
+            // is mounted to the DOM, so the `NodeRef` will be `Some`
+            .expect("<input> to exist")
+            // `NodeRef` implements `Deref` for the DOM element type
+            // this means we can call`HtmlInputElement::value()`
+            // to get the current value of the input
+            .value();
+        set_name(value);
+    };
+
+    view! {
+        <form on:submit=on_submit>
+            <input type="text"
+                // here, we use the `value` *attribute* to set only
+                // the initial value, letting the browser maintain
+                // the state after that
+                value=name
+
+                // store a reference to this input in `input_element`
+                node_ref=input_element
+            />
+            <input type="submit" value="Submit"/>
+        </form>
+        <p>"Name is: " {name}</p>
+    }
+}
+
+// This `main` function is the entry point into the app
+// It just mounts our component to the <body>
+// Because we defined it as `fn App`, we can now use it in a
+// template as <App/>
+fn main() {
+    leptos::mount_to_body(App)
+}
+```
+
+</details>
+</preview>
diff --git a/src-russian/view/06_control_flow.md b/src-russian/view/06_control_flow.md
new file mode 100644
index 0000000..7ab9a58
--- /dev/null
+++ b/src-russian/view/06_control_flow.md
@@ -0,0 +1,375 @@
+# Порядок выполнения
+
+В большинстве приложений вам порой нужно принять решение: Мне рендерить это как часть view или нет? 
+Мне рендерить  `<ButtonA/>` или `<WidgetB/>`. Это и есть **порядок выполнения** (_англ. control flow_).
+
+## Несколько советов
+
+Думая о том, как сделать это в Leptos, важно помнить несколько вещей:
+
+1. Rust это язык ориентированный на выражения: такие выражения порядка выполнения, как
+   `if x() { y } else { z }` и `match x() { ... }` возвращают свои значения. Это делает их очень полезными для декларативных 
+пользовательских интерфейсов.
+2. Для любого `T` реализующего `IntoView` — другими словами, для любого типа, который Leptos может рендерить
+— `Option<T>` и `Result<T, impl Error>` _тоже_ реализуют `IntoView`. И так же как `Fn() -> T` рендерит реактивный `T`, `Fn() -> Option<T>`
+   и `Fn() -> Result<T, impl Error>` тоже реактивны.
+3. В Rust есть множество полезных хелперов, таких как [Option::map](https://doc.rust-lang.org/std/option/enum.Option.html#method.map),
+   [Option::and_then](https://doc.rust-lang.org/std/option/enum.Option.html#method.and_then),
+   [Option::ok_or](https://doc.rust-lang.org/std/option/enum.Option.html#method.ok_or),
+   [Result::map](https://doc.rust-lang.org/std/result/enum.Result.html#method.map),
+   [Result::ok](https://doc.rust-lang.org/std/result/enum.Result.html#method.ok), и
+   [bool::then](https://doc.rust-lang.org/std/primitive.bool.html#method.then), позволяющих вам декларативно конвертировать значения между несколькими стандартными типами, все из которых 
+могут быть отрендерены. Потратить время на чтение документации к `Option` и `Result` это один из лучших способов
+выйти на новый уровень в Rust.
+4. И всегда помните: чтобы быть реактивными, значения должны быть функциями. Ниже вы увидите как я постоянно оборачиваю вещи в
+`move ||` замыкания. Это чтобы убедиться, что они действительно выполняются повторно когда меняется сигнал, от которого они зависят,
+поддерживая реактивность UI.
+
+## Ну и что?
+
+Чтобы немного собрать всё воедино: на практике это значит, что вы можете реализовать большую часть контроля над
+порядком выполнения при помощи нативного Rust кода, без особых компонентов,
+управляющих порядком выполнения и не обладая специальными знаниями.    
+
+К примеру, давайте начнём с простого сигнала и производного сигнала:
+
+```rust
+let (value, set_value) = create_signal(0);
+let is_odd = move || value() & 1 == 1;
+```
+
+> Если вы не понимаете что происходит с `is_odd`, то не волнуйтесь. Это лишь простой способ 
+> проверить число на нечётность, используя побитовое «И» с 1.
+
+Мы можем использовать эти сигналы и обычный Rust чтобы реализовать большую часть управления порядком выполнения.
+
+### Оператор `if`
+
+Предположим, я хочу выводить одну надпись если число нечётно и другую если оно чётно. Что скажете вот об этом?
+
+```rust
+view! {
+    <p>
+    {move || if is_odd() {
+        "Odd"
+    } else {
+        "Even"
+    }}
+    </p>
+}
+```
+
+Выражение `if` возвращает своё значение, а `&str` реализует `IntoView`, поэтому
+`Fn() -> &str` реализует `IntoView`, так что это... просто работает!
+
+### `Option<T>`
+
+Предположим мы хотим выводить надпись если число нечётно и ничего не выводить, если чётно.
+
+```rust
+let message = move || {
+    if is_odd() {
+        Some("Ding ding ding!")
+    } else {
+        None
+    }
+};
+
+view! {
+    <p>{message}</p>
+}
+```
+
+Это отлично работает. Мы можем, как вариант, немного сократить код, используя `bool::then()`.
+
+```rust
+let message = move || is_odd().then(|| "Ding ding ding!");
+view! {
+    <p>{message}</p>
+}
+```
+
+Вы даже можете обойтись без переменной, если хотите. Хотя, лично я иногда предпочитаю улучшенную поддержку `cargo fmt` и `rust-analyzer`,
+которую я получаю, вынося такое за пределы `view`.
+
+### Конструкция `match`
+
+Мы всё ещё пишем обычный код на Rust, ведь так? Это означает, что в вашем распоряжении вся мощь сопоставления с образцом, доступного в Rust.
+
+```rust
+let message = move || {
+    match value() {
+        0 => "Zero",
+        1 => "One",
+        n if is_odd() => "Odd",
+        _ => "Even"
+    }
+};
+view! {
+    <p>{message}</p>
+}
+```
+
+А почему бы и нет? Живём только раз, не так ли?
+
+## Предотвращение чрезмерного рендеринга
+
+А вот и не только раз.
+
+Всё что мы только что сделали это в целом нормально. Но один нюанс, который вам стоит запомнить и обходиться с ним аккуратно.
+Каждая из функций управляющих порядком выполнения, из тех что мы создали к этому моменту, это в сущности производный сигнал:
+они будут перезапускаться при каждом изменении значения. В примерах выше, где значение меняется
+с четного на нечётное при каждом изменении, это нормально.
+
+Но рассмотрим следующий пример:
+
+```rust
+let (value, set_value) = create_signal(0);
+
+let message = move || if value() > 5 {
+    "Big"
+} else {
+    "Small"
+};
+
+view! {
+    <p>{message}</p>
+}
+```
+
+Это конечно _работает_. Но если вы добавите вывод в лог, то возможно удивитесь
+
+```rust
+let message = move || if value() > 5 {
+    logging::log!("{}: rendering Big", value());
+    "Big"
+} else {
+    logging::log!("{}: rendering Small", value());
+    "Small"
+};
+```
+
+Когда пользователь нажимает на кнопку вы увидите что-то вроде этого:
+
+```
+1: rendering Small
+2: rendering Small
+3: rendering Small
+4: rendering Small
+5: rendering Small
+6: rendering Big
+7: rendering Big
+8: rendering Big
+... и так до бесконечности
+```
+
+Каждый раз когда `value` меняется, `if` выполняется снова. Оно и понятно, учитывая как устроена реактивность. Но у этого есть недостаток.
+Для простого текстового узла повторное выполнение `if` и повторный рендеринг это пустяки. Но представьте если бы было так:
+
+```rust
+let message = move || if value() > 5 {
+    <Big/>
+} else {
+    <Small/>
+};
+```
+
+`<Small/>` перезапускается пять раз, затем `<Big/>` бесконечно. Если они подгружают ресурсы, создают сигналы или даже просто создают узлы DOM,
+это лишняя работа. 
+
+### `<Show/>`
+
+Компонент [`<Show/>`](https://docs.rs/leptos/latest/leptos/fn.Show.html) это ответ этим проблемам. Вы передаёте условную функцию `when` и `fallback` для показа в случае если `when` вернула  `false`,
+и дочерние элементы, которые будут отображаться если `when` равно `true`.
+
+```rust
+let (value, set_value) = create_signal(0);
+
+view! {
+  <Show
+    when=move || { value() > 5 }
+    fallback=|| view! { <Small/> }
+  >
+    <Big/>
+  </Show>
+}
+```
+
+`<Show/>` мемоизирует условие `when`, так что он рендерит `<Small/>` лишь раз,
+продолжая показывать тот же компонент пока  `value` не станет больше пяти;
+затем он отрендерит `<Big/>` один раз, продолжая его показывать вечно или пока `value`
+не станет меньше пяти, тогда он снова отрендерит `<Small/>`.
+
+Это полезный инструмент чтобы избежать повторного рендеринга при использовании динамических `if` выражений.
+Как обычно, есть и накладные расходы: для очень маленького узла (как обновление одного текстового узла, обновления класса или атрибута)
+конструкция `move || if ...` будет менее затратна. Но если рендеринг какой-либо ветки хоть сколько-нибудь затратен,
+используйте `<Show/>`.
+
+## Заметка: конвертация типов
+
+Это последняя вещь, о которой важно сказать в этом разделе.
+
+Макрос `view` не возвращает самый обобщенный оборачивающий тип [`View`](https://docs.rs/leptos/latest/leptos/enum.View.html).
+Вместо этого, он возвращает такие типы как `Fragment` или `HtmlElement<Input>`. Это может немного раздражать если 
+вы возвращаете разные элементы HTML из разных ветвей условия.
+
+```rust,compile_error
+view! {
+    <main>
+        {move || match is_odd() {
+            true if value() == 1 => {
+                // returns HtmlElement<Pre>
+                view! { <pre>"One"</pre> }
+            },
+            false if value() == 2 => {
+                // returns HtmlElement<P>
+                view! { <p>"Two"</p> }
+            }
+            // returns HtmlElement<Textarea>
+            _ => view! { <textarea>{value()}</textarea> }
+        }}
+    </main>
+}
+```
+
+Эта сильная типизация в самом деле мощная штука, поскольку [`HtmlElement`](https://docs.rs/leptos/0.1.3/leptos/struct.HtmlElement.html) кроме всего прочего является умным указателем:
+каждый тип `HtmlElement<T>` реализует `Deref` для подходящего внутреннего типа `web_sys`. Другими словами, в браузере ваш `view`
+возвращает настоящие DOM элементы и вы можете вызывать у них нативные методы DOM.
+
+Но это может немного раздражать в условной логике как здесь, поскольку в Rust вы не можете возвращать разные типы из разных ветвей условия.
+Есть два выхода из положения:
+
+1. Если у вас несколько `HtmlElement` типов, конвертируйте их в  `HtmlElement<AnyElement>` при помощи  [`.into_any()`](https://docs.rs/leptos/latest/leptos/struct.HtmlElement.html#method.into_any)
+2. Если у вас набор view-типов, не все из которых `HtmlElement`, конвертируйте их во 
+   `View` через [`.into_view()`](https://docs.rs/leptos/latest/leptos/trait.IntoView.html#tymethod.into_view).
+
+Вот тот же пример, с добавленной конвертацией:
+
+```rust,compile_error
+view! {
+    <main>
+        {move || match is_odd() {
+            true if value() == 1 => {
+                // returns HtmlElement<Pre>
+                view! { <pre>"One"</pre> }.into_any()
+            },
+            false if value() == 2 => {
+                // returns HtmlElement<P>
+                view! { <p>"Two"</p> }.into_any()
+            }
+            // returns HtmlElement<Textarea>
+            _ => view! { <textarea>{value()}</textarea> }.into_any()
+        }}
+    </main>
+}
+```
+
+```admonish sandbox title="Live example" collapsible=true
+
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/6-control-flow-0-5-4yn7qz?file=%2Fsrc%2Fmain.rs%3A1%2C1)
+
+<noscript>
+  Please enable JavaScript to view examples.
+</noscript>
+
+<template>
+  <iframe src="https://codesandbox.io/p/sandbox/6-control-flow-0-5-4yn7qz?file=%2Fsrc%2Fmain.rs%3A1%2C1" width="100%" height="1000px" style="max-height: 100vh"></iframe>
+</template>
+
+```
+
+<details>
+<summary>CodeSandbox Source</summary>
+
+```rust
+use leptos::*;
+
+#[component]
+fn App() -> impl IntoView {
+    let (value, set_value) = create_signal(0);
+    let is_odd = move || value() & 1 == 1;
+    let odd_text = move || if is_odd() { Some("How odd!") } else { None };
+
+    view! {
+        <h1>"Control Flow"</h1>
+
+        // Simple UI to update and show a value
+        <button on:click=move |_| set_value.update(|n| *n += 1)>
+            "+1"
+        </button>
+        <p>"Value is: " {value}</p>
+
+        <hr/>
+
+        <h2><code>"Option<T>"</code></h2>
+        // For any `T` that implements `IntoView`,
+        // so does `Option<T>`
+
+        <p>{odd_text}</p>
+        // This means you can use `Option` methods on it
+        <p>{move || odd_text().map(|text| text.len())}</p>
+
+        <h2>"Conditional Logic"</h2>
+        // You can do dynamic conditional if-then-else
+        // logic in several ways
+        //
+        // a. An "if" expression in a function
+        //    This will simply re-render every time the value
+        //    changes, which makes it good for lightweight UI
+        <p>
+            {move || if is_odd() {
+                "Odd"
+            } else {
+                "Even"
+            }}
+        </p>
+
+        // b. Toggling some kind of class
+        //    This is smart for an element that's going to
+        //    toggled often, because it doesn't destroy
+        //    it in between states
+        //    (you can find the `hidden` class in `index.html`)
+        <p class:hidden=is_odd>"Appears if even."</p>
+
+        // c. The <Show/> component
+        //    This only renders the fallback and the child
+        //    once, lazily, and toggles between them when
+        //    needed. This makes it more efficient in many cases
+        //    than a {move || if ...} block
+        <Show when=is_odd
+            fallback=|| view! { <p>"Even steven"</p> }
+        >
+            <p>"Oddment"</p>
+        </Show>
+
+        // d. Because `bool::then()` converts a `bool` to
+        //    `Option`, you can use it to create a show/hide toggled
+        {move || is_odd().then(|| view! { <p>"Oddity!"</p> })}
+
+        <h2>"Converting between Types"</h2>
+        // e. Note: if branches return different types,
+        //    you can convert between them with
+        //    `.into_any()` (for different HTML element types)
+        //    or `.into_view()` (for all view types)
+        {move || match is_odd() {
+            true if value() == 1 => {
+                // <pre> returns HtmlElement<Pre>
+                view! { <pre>"One"</pre> }.into_any()
+            },
+            false if value() == 2 => {
+                // <p> returns HtmlElement<P>
+                // so we convert into a more generic type
+                view! { <p>"Two"</p> }.into_any()
+            }
+            _ => view! { <textarea>{value()}</textarea> }.into_any()
+        }}
+    }
+}
+
+fn main() {
+    leptos::mount_to_body(App)
+}
+```
+
+</details>
+</preview>
diff --git a/src-russian/view/07_errors.md b/src-russian/view/07_errors.md
new file mode 100644
index 0000000..8e604b2
--- /dev/null
+++ b/src-russian/view/07_errors.md
@@ -0,0 +1,188 @@
+# Обработка ошибок
+
+[В предыдущей главе](./06_control_flow.md), мы рассмотрели что вы можете рендерить `Option<T>`:
+в случае `None`, ничего не будет выведено, а в случае `Some(T)`, будет отображён `T`
+(если `T` реализует `IntoView`). Вы можете очень похожим образом обойтись с `Result<T, E>`. 
+В случае `Err(_)`, ничего не будет выведено. В случае `Ok(T)` будет отображён `T`.
+
+Давайте начнем с простого компонента, осуществляющего захват числового поля ввода.
+
+```rust
+#[component]
+fn NumericInput() -> impl IntoView {
+    let (value, set_value) = create_signal(Ok(0));
+
+    // when input changes, try to parse a number from the input
+    let on_input = move |ev| set_value(event_target_value(&ev).parse::<i32>());
+
+    view! {
+        <label>
+            "Type an integer (or not!)"
+            <input type="number" on:input=on_input/>
+            <p>
+                "You entered "
+                <strong>{value}</strong>
+            </p>
+        </label>
+    }
+}
+```
+
+Каждый раз когда вы меняете значение поля ввода, `on_input` попытается превратить это значение в 32-битное число (`i32`)
+и сохранить его в наш сигнал `value` с типом `Result<i32, _>`. Если вы введёте число `42`, UI отобразит
+
+```
+You entered 42
+```
+
+Но если введете строку `foo`, он отобразит
+
+```
+You entered
+```
+
+Выглядит так себе. Это экономит нам вызов `.unwrap_or_default()` или чего-то подобного, но было бы намного лучше, если
+мы могли бы поймать эту ошибку и что-нибудь с ней сделать.
+
+Вы можете это сделать, используя компонент [`<ErrorBoundary/>`](https://docs.rs/leptos/latest/leptos/fn.ErrorBoundary.html)
+
+```admonish note
+Люди часто пытаются указать на то, что `<input type="number>` не даст вам написать строку как `foo` или что-либо ещё,
+что не является числом. Это справедливо в каких-то браузерах, но не во всех! Более того, есть множество вещей, которые
+можно напечатать в обычный числовое поле ввода и которые не являются `i32`: число с плавающей точкой, число больше
+ чем позволяют 32 бита, буква `e` и так далее. Браузеру можно сказать чтоб он поддерживал некоторые из этих инвариантов,
+ однако поведение браузера всё же вариативно: Важно парсить самостоятельно!
+```
+
+## `<ErrorBoundary/>`
+
+`<ErrorBoundary/>` немного сродни компоненту `<Show/>`, рассмотренному нами в предыдущей главе.
+Если всё окей —точнее сказать, если всё `Ok(_)`— он выводит дочерние элементы.
+Но если среди потомков будет выведен `Err(_)`, это вызовет отображение `fallback` в `<ErrorBoundary/>`.
+
+Давайте добавим `<ErrorBoundary/>` в наш пример.
+
+```rust
+#[component]
+fn NumericInput() -> impl IntoView {
+    let (value, set_value) = create_signal(Ok(0));
+
+    let on_input = move |ev| set_value(event_target_value(&ev).parse::<i32>());
+
+    view! {
+        <h1>"Error Handling"</h1>
+        <label>
+            "Type a number (or something that's not a number!)"
+            <input type="number" on:input=on_input/>
+            <ErrorBoundary
+                // the fallback receives a signal containing current errors
+                fallback=|errors| view! {
+                    <div class="error">
+                        <p>"Not a number! Errors: "</p>
+                        // we can render a list of errors as strings, if we'd like
+                        <ul>
+                            {move || errors.get()
+                                .into_iter()
+                                .map(|(_, e)| view! { <li>{e.to_string()}</li>})
+                                .collect_view()
+                            }
+                        </ul>
+                    </div>
+                }
+            >
+                <p>"You entered " <strong>{value}</strong></p>
+            </ErrorBoundary>
+        </label>
+    }
+}
+```
+
+Теперь если вы введёте `42`, `value` примет значение `Ok(42)` и вы увидите
+
+```
+You entered 42
+```
+
+Если вы введёте `foo`, `value` будет `Err(_)` и отобразится `fallback`.  Мы предпочли вывести список ошибок в виде `String`, 
+так что вы увидите что-то вроде
+
+```
+Not a number! Errors:
+- cannot parse integer from empty string
+```
+
+Если вы исправите эту ошибку, сообщение об ошибке исчезнет и контент обёрнутый в 
+ `<ErrorBoundary/>` появится снова.
+
+```admonish sandbox title="Live example" collapsible=true
+
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/7-errors-0-5-5mptv9?file=%2Fsrc%2Fmain.rs%3A1%2C1)
+
+<noscript>
+  Пожалуйста, включите Javascript для просмотра примеров.
+</noscript>
+
+<template>
+  <iframe src="https://codesandbox.io/p/sandbox/7-errors-0-5-5mptv9?file=%2Fsrc%2Fmain.rs%3A1%2C1" width="100%" height="1000px" style="max-height: 100vh"></iframe>
+</template>
+```
+
+<details>
+<summary>Код примера CodeSandbox</summary>
+
+```rust
+use leptos::*;
+
+#[component]
+fn App() -> impl IntoView {
+    let (value, set_value) = create_signal(Ok(0));
+
+    // when input changes, try to parse a number from the input
+    let on_input = move |ev| set_value(event_target_value(&ev).parse::<i32>());
+
+    view! {
+        <h1>"Error Handling"</h1>
+        <label>
+            "Type a number (or something that's not a number!)"
+            <input type="number" on:input=on_input/>
+            // If an `Err(_) had been rendered inside the <ErrorBoundary/>,
+            // the fallback will be displayed. Otherwise, the children of the
+            // <ErrorBoundary/> will be displayed.
+            <ErrorBoundary
+                // the fallback receives a signal containing current errors
+                fallback=|errors| view! {
+                    <div class="error">
+                        <p>"Not a number! Errors: "</p>
+                        // we can render a list of errors
+                        // as strings, if we'd like
+                        <ul>
+                            {move || errors.get()
+                                .into_iter()
+                                .map(|(_, e)| view! { <li>{e.to_string()}</li>})
+                                .collect::<Vec<_>>()
+                            }
+                        </ul>
+                    </div>
+                }
+            >
+                <p>
+                    "You entered "
+                    // because `value` is `Result<i32, _>`,
+                    // it will render the `i32` if it is `Ok`,
+                    // and render nothing and trigger the error boundary
+                    // if it is `Err`. It's a signal, so this will dynamically
+                    // update when `value` changes
+                    <strong>{value}</strong>
+                </p>
+            </ErrorBoundary>
+        </label>
+    }
+}
+
+fn main() {
+    leptos::mount_to_body(App)
+}
+```
+
+</details>
+</preview>
diff --git a/src-russian/view/08_parent_child.md b/src-russian/view/08_parent_child.md
new file mode 100644
index 0000000..fc7c95e
--- /dev/null
+++ b/src-russian/view/08_parent_child.md
@@ -0,0 +1,454 @@
+# Коммуникация Родитель-Ребёнок
+
+Вы можете представлять ваше приложение как вложенное дерево компонентов. Каждый компонент 
+управляется со собственным локальным состоянием и управляет разделом пользовательского интерфейса,
+так что компоненты склонны быть относительно самодостаточными.
+
+Хотя иногда вам захочется наладить коммуникацию между родительным компонентом и его дочерними компонентами.
+Представьте, например, что вы объявили компонент `<FancyButton/>`, добавляющий какие-то стили, логирование или что-то ещё к `<button/>`. 
+Вы хотите использовать `<FancyButton/>` в вашем компоненте `<App/>`. Но как вам наладить коммуникацию между ими двумя?
+
+Передать состояние из родителя в дочерний компонент легко. Мы частично рассматривали это в материале про [компоненты и свойства](./03_components.md).
+Попросту говоря если вы хотите чтобы родитель общался с дочерним компонентом, вы можете передать
+[`ReadSignal`](https://docs.rs/leptos/latest/leptos/struct.ReadSignal.html), 
+[`Signal`](https://docs.rs/leptos/latest/leptos/struct.Signal.html), или
+[`MaybeSignal`](https://docs.rs/leptos/latest/leptos/enum.MaybeSignal.html) в качестве свойства.
+
+Но как быть с обратным направлением? Как дочерний элемент может уведомлять родителя о событиях или изменениях состояния?
+
+Есть четыре простых паттерна коммуникации Родитель-Ребёнок в Leptos.
+
+## 1. Передавать [`WriteSignal`](https://docs.rs/leptos/latest/leptos/struct.WriteSignal.html)
+
+Один из подходов это просто передавать `WriteSignal` из родителя в дочерний компонент и в нём обновлять сигнал.
+Это позволяет вам управлять состоянием родителя из дочернего компонента.
+
+```rust
+#[component]
+pub fn App() -> impl IntoView {
+    let (toggled, set_toggled) = create_signal(false);
+    view! {
+        <p>"Toggled? " {toggled}</p>
+        <ButtonA setter=set_toggled/>
+    }
+}
+
+#[component]
+pub fn ButtonA(setter: WriteSignal<bool>) -> impl IntoView {
+    view! {
+        <button
+            on:click=move |_| setter.update(|value| *value = !*value)
+        >
+            "Toggle"
+        </button>
+    }
+}
+```
+
+Этот паттерн прост, но будьте с ним осторожны: передача `WriteSignal` может усложить понимание вашего кода.
+Читая `<App/>` из этого примера,  вполне ясно, что даёте возможность изменять значение `toggled`,
+но совершенно неясно когда и как это происходит. В этом простом, локальном примере это легко понять, но если вы
+видите, что передаёте сигналы `WriteSignal` как этот по всему вашему коду, вам следует всерьёз задуматься о том не
+упрощает ли этот подход донельзя написание спагетти-кода.
+
+## 2. Использовать `Callback` (функцию обратного вызова)
+
+Ещё один подход это передавать `Callback` в дочерний компонент: скажем, `on_click`.
+
+```rust
+#[component]
+pub fn App() -> impl IntoView {
+    let (toggled, set_toggled) = create_signal(false);
+    view! {
+        <p>"Toggled? " {toggled}</p>
+        <ButtonB on_click=move |_| set_toggled.update(|value| *value = !*value)/>
+    }
+}
+
+
+#[component]
+pub fn ButtonB(#[prop(into)] on_click: Callback<MouseEvent>) -> impl IntoView
+{
+    view! {
+        <button on:click=on_click>
+            "Toggle"
+        </button>
+    }
+}
+```
+
+Вы заметите что когда как `<ButtonA/>` получил `WriteSignal` и решает как его мутировать,
+`<ButtonB/>` просто порождает событие: мутация происходит в `<App/>`. Преимущество этого в том, что мы локальное состояние
+остаётся локальным, предотвращая проблему спагетти мутации. Но это также означает, что логика мутации сигнала должна находиться в 
+`<App/>`, а не в `<ButtonB/>`. Это настоящие компромиссы, а не простой выбор между правильно/неправильно.
+
+> Обратите внимание на способ, которым мы используем тип `Callback<In, Out>`. Это просто обёртка вокруг замыкания 
+> `Fn(In) -> Out`, которая реализует `Copy`, что упрощает её передачу.
+>
+> Мы также использовали атрибут `#[prop(into)]` чтобы мы могли передавать обычное замыкание в  `on_click`.
+> Пожалуйста, посмотрите [главу "Свойства с `into`"](./03_components.md#into-props) для более подробной информации.
+
+### 2.1 Использование замыкание вместо `Callback`
+
+Вы можете использовать Rust замыкание `Fn(MouseEvent)` напрямую вместо `Callback`:
+
+```rust
+#[component]
+pub fn App() -> impl IntoView {
+    let (toggled, set_toggled) = create_signal(false);
+    view! {
+        <p>"Toggled? " {toggled}</p>
+        <ButtonB on_click=move |_| set_toggled.update(|value| *value = !*value)/>
+    }
+}
+
+
+#[component]
+pub fn ButtonB<F>(on_click: F) -> impl IntoView
+where
+    F: Fn(MouseEvent) + 'static
+{
+    view! {
+        <button on:click=on_click>
+            "Toggle"
+        </button>
+    }
+}
+```
+
+В данном случае код почти не изменился. В более продвинутых случаях использование замыкания может потребовать клонирования,
+в отличие от варианта с использованием `Callback`.
+
+> Обратите внимание, что мы объявили обобщенный тип `F` ради функции обратного вызова. Если вас это смутило,
+> вернитесь к разделу [Свойства с обобщенными типами](./03_components.html#свойства-с-обобщенными-типами)
+> главы о компонентах.
+
+## 3. Использование слушателя событий _(англ. Event Listener)_
+
+По правде говоря, вы можете Вариант 2 немного другим способом. Если функция обратного вызова напрямую накладывается на нативный DOM элементом,
+вы можете добавить `on:` слушатель прямо в место где вы используете этот компонент в макрос `view` в `<App/>`.
+
+```rust
+#[component]
+pub fn App() -> impl IntoView {
+    let (toggled, set_toggled) = create_signal(false);
+    view! {
+        <p>"Toggled? " {toggled}</p>
+        // note the on:click instead of on_click
+        // this is the same syntax as an HTML element event listener
+        <ButtonC on:click=move |_| set_toggled.update(|value| *value = !*value)/>
+    }
+}
+
+
+#[component]
+pub fn ButtonC() -> impl IntoView {
+    view! {
+        <button>"Toggle"</button>
+    }
+}
+```
+
+Это позволяет вам написать намного меньше кода для `<ButtonC/>`, чем вы написали для `<ButtonB/>`, и всё даёт слушателю 
+ правильно типизированное событие. Это работает так, что  слушатель событий `on:` добавляется к каждому возвращаемому `<ButtonC/>`:
+ в данном случае только `<button>`.
+
+Конечно, это работает только для настоящих событий DOM которые вы передаёте напрямую в элементы, которые вы рендерите в компоненте.
+Для более сложной логики, которая не накладывается напрямую на элемент (скажем вы создали `<ValidatedForm/>`
+и хотите функцию обратного вызова `on_valid_form_submit`), вам следует использовать Вариант 2.
+
+## 4. Предоставление Контекста
+
+Эта версия по факту является разновидностью Варинта 1. Скажем у вас дерево компонентов глубокой вложенности:
+
+```rust
+#[component]
+pub fn App() -> impl IntoView {
+    let (toggled, set_toggled) = create_signal(false);
+    view! {
+        <p>"Toggled? " {toggled}</p>
+        <Layout/>
+    }
+}
+
+#[component]
+pub fn Layout() -> impl IntoView {
+    view! {
+        <header>
+            <h1>"My Page"</h1>
+        </header>
+        <main>
+            <Content/>
+        </main>
+    }
+}
+
+#[component]
+pub fn Content() -> impl IntoView {
+    view! {
+        <div class="content">
+            <ButtonD/>
+        </div>
+    }
+}
+
+#[component]
+pub fn ButtonD<F>() -> impl IntoView {
+    todo!()
+}
+```
+
+`<ButtonD/>` теперь уже не дочерний элемент `<App/>`, так что вы не можете просто передавать `WriteSignal` в него через свойства.
+Вы можете сделать то, что иногда называют “пробурить свойство”, добавив свойство в каждый слой между ими двумя:
+
+```rust
+#[component]
+pub fn App() -> impl IntoView {
+    let (toggled, set_toggled) = create_signal(false);
+    view! {
+        <p>"Toggled? " {toggled}</p>
+        <Layout set_toggled/>
+    }
+}
+
+#[component]
+pub fn Layout(set_toggled: WriteSignal<bool>) -> impl IntoView {
+    view! {
+        <header>
+            <h1>"My Page"</h1>
+        </header>
+        <main>
+            <Content set_toggled/>
+        </main>
+    }
+}
+
+#[component]
+pub fn Content(set_toggled: WriteSignal<bool>) -> impl IntoView {
+    view! {
+        <div class="content">
+            <ButtonD set_toggled/>
+        </div>
+    }
+}
+
+#[component]
+pub fn ButtonD<F>(set_toggled: WriteSignal<bool>) -> impl IntoView {
+    todo!()
+}
+```
+
+Ну и бардак. `set_toggled` не нужен ни`<Layout/>`, ни `<Content/>`; они просто передают его в `<ButtonD/>`. Но мне приходится 
+объявлять свойство трижды. Помимо того, что это раздражает, такое ещё и сложно поддерживать: только вообразите, если мы добавим
+"среднее положение" переключателя, тип `set_toggled` придётся поменять на `enum`. Наам придётся менять его в трёх местах!  
+
+Нет ли какого-то способа перепрыгнуть эти уровни?
+
+Есть!
+
+### 4.1 API контекстов
+
+Вы можете представлять данные, перепрыгивающие через уровни, используя [`provide_context`](https://docs.rs/leptos/latest/leptos/fn.provide_context.html) и [`use_context`](https://docs.rs/leptos/latest/leptos/fn.use_context.html). 
+Контексты идентифицируются по типу данных, которые вы предоставляете (в этом примере,  `WriteSignal<bool>`), 
+и они существуют в нисходящем дереве, которое следует контурам дерева вашего UI. В этом примере мы можем использовать 
+контекст, чтобы избежать ненужного бурения свойств.
+
+```rust
+#[component]
+pub fn App() -> impl IntoView {
+    let (toggled, set_toggled) = create_signal(false);
+
+    // share `set_toggled` with all children of this component
+    provide_context(set_toggled);
+
+    view! {
+        <p>"Toggled? " {toggled}</p>
+        <Layout/>
+    }
+}
+
+// <Layout/> and <Content/> omitted
+// To work in this version, drop their references to set_toggled
+
+#[component]
+pub fn ButtonD() -> impl IntoView {
+    // use_context searches up the context tree, hoping to
+    // find a `WriteSignal<bool>`
+    // in this case, I .expect() because I know I provided it
+    let setter = use_context::<WriteSignal<bool>>()
+        .expect("to have found the setter provided");
+
+    view! {
+        <button
+            on:click=move |_| setter.update(|value| *value = !*value)
+        >
+            "Toggle"
+        </button>
+    }
+}
+```
+
+Эти же предостережения относятся к данному коду в той же мере, что и к `<ButtonA/>`: передавать `WriteSignal` нужно с осторожностью,
+так как это позволяет мутировать состояние из произвольных мест вашего кода. Но при осторожном обращении, это одна из 
+самых эффективных техник управления глобальным состоянием в Leptos: просто предоставьте состояние на самом высоком из
+уровней, на которых вам оно требуется и используйте где нужно на уровнях ниже.
+
+Заметим, что у этого подхода нет недостатков в части производительности. Поскольку вы передаете мелкозернистый реактивный сигнал,
+_ничего не происходит_ в промежуточных компонентах  (`<Layout/>` и `<Content/>`) когда вы его обновляете.
+Вы можете наладить прямую коммуникацию между  `<ButtonD/>` и `<App/>`. 
+Фактически —и в этом состоит сила мелкозернистой реактивности— коммуникация идёт напрямую между нажатием на кнопку `<ButtonD/>`
+и единственным текстовым узлом в `<App/>`. Это как если бы самих компонентов вовсе не существовало. И, ну... в рантайме они не существуют.
+Лишь сигналы и эффекты до самого низа.
+
+```admonish sandbox title="Live example" collapsible=true
+
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/8-parent-child-0-5-7rz7qd?file=%2Fsrc%2Fmain.rs%3A1%2C2)
+
+<noscript>
+  Пожалуйста, включите Javascript для просмотра примеров.
+</noscript>
+
+<template>
+  <iframe src="https://codesandbox.io/p/sandbox/8-parent-child-0-5-7rz7qd?file=%2Fsrc%2Fmain.rs%3A1%2C2" width="100%" height="1000px" style="max-height: 100vh"></iframe>
+</template>
+
+```
+
+<details>
+<summary>Код примера CodeSandbox</summary>
+
+```rust
+use leptos::{ev::MouseEvent, *};
+
+// This highlights four different ways that child components can communicate
+// with their parent:
+// 1) <ButtonA/>: passing a WriteSignal as one of the child component props,
+//    for the child component to write into and the parent to read
+// 2) <ButtonB/>: passing a closure as one of the child component props, for
+//    the child component to call
+// 3) <ButtonC/>: adding an `on:` event listener to a component
+// 4) <ButtonD/>: providing a context that is used in the component (rather than prop drilling)
+
+#[derive(Copy, Clone)]
+struct SmallcapsContext(WriteSignal<bool>);
+
+#[component]
+pub fn App() -> impl IntoView {
+    // just some signals to toggle three classes on our <p>
+    let (red, set_red) = create_signal(false);
+    let (right, set_right) = create_signal(false);
+    let (italics, set_italics) = create_signal(false);
+    let (smallcaps, set_smallcaps) = create_signal(false);
+
+    // the newtype pattern isn't *necessary* here but is a good practice
+    // it avoids confusion with other possible future `WriteSignal<bool>` contexts
+    // and makes it easier to refer to it in ButtonC
+    provide_context(SmallcapsContext(set_smallcaps));
+
+    view! {
+        <main>
+            <p
+                // class: attributes take F: Fn() => bool, and these signals all implement Fn()
+                class:red=red
+                class:right=right
+                class:italics=italics
+                class:smallcaps=smallcaps
+            >
+                "Lorem ipsum sit dolor amet."
+            </p>
+
+            // Button A: pass the signal setter
+            <ButtonA setter=set_red/>
+
+            // Button B: pass a closure
+            <ButtonB on_click=move |_| set_right.update(|value| *value = !*value)/>
+
+            // Button B: use a regular event listener
+            // setting an event listener on a component like this applies it
+            // to each of the top-level elements the component returns
+            <ButtonC on:click=move |_| set_italics.update(|value| *value = !*value)/>
+
+            // Button D gets its setter from context rather than props
+            <ButtonD/>
+        </main>
+    }
+}
+
+/// Button A receives a signal setter and updates the signal itself
+#[component]
+pub fn ButtonA(
+    /// Signal that will be toggled when the button is clicked.
+    setter: WriteSignal<bool>,
+) -> impl IntoView {
+    view! {
+        <button
+            on:click=move |_| setter.update(|value| *value = !*value)
+        >
+            "Toggle Red"
+        </button>
+    }
+}
+
+/// Button B receives a closure
+#[component]
+pub fn ButtonB<F>(
+    /// Callback that will be invoked when the button is clicked.
+    on_click: F,
+) -> impl IntoView
+where
+    F: Fn(MouseEvent) + 'static,
+{
+    view! {
+        <button
+            on:click=on_click
+        >
+            "Toggle Right"
+        </button>
+    }
+
+    // just a note: in an ordinary function ButtonB could take on_click: impl Fn(MouseEvent) + 'static
+    // and save you from typing out the generic
+    // the component macro actually expands to define a
+    //
+    // struct ButtonBProps<F> where F: Fn(MouseEvent) + 'static {
+    //   on_click: F
+    // }
+    //
+    // this is what allows us to have named props in our component invocation,
+    // instead of an ordered list of function arguments
+    // if Rust ever had named function arguments we could drop this requirement
+}
+
+/// Button C is a dummy: it renders a button but doesn't handle
+/// its click. Instead, the parent component adds an event listener.
+#[component]
+pub fn ButtonC() -> impl IntoView {
+    view! {
+        <button>
+            "Toggle Italics"
+        </button>
+    }
+}
+
+/// Button D is very similar to Button A, but instead of passing the setter as a prop
+/// we get it from the context
+#[component]
+pub fn ButtonD() -> impl IntoView {
+    let setter = use_context::<SmallcapsContext>().unwrap().0;
+
+    view! {
+        <button
+            on:click=move |_| setter.update(|value| *value = !*value)
+        >
+            "Toggle Small Caps"
+        </button>
+    }
+}
+
+fn main() {
+    leptos::mount_to_body(App)
+}
+```
+
+</details>
+</preview>
diff --git a/src-russian/view/09_component_children.md b/src-russian/view/09_component_children.md
new file mode 100644
index 0000000..3df0695
--- /dev/null
+++ b/src-russian/view/09_component_children.md
@@ -0,0 +1,235 @@
+# Дочерние элементы компонентов
+
+Весьма часто люди хотят передавать дочерние элементы в компонент, так же как можно передавать дочерние элементы в 
+элемент HTML. Представьте, к примеру, что я хочу компонент `<FancyForm/>`, усовершенствующий `<form>`. Мне нужен какой-то способ
+передать все поля ввода.
+
+```rust
+view! {
+    <FancyForm>
+        <fieldset>
+            <label>
+                "Some Input"
+                <input type="text" name="something"/>
+            </label>
+        </fieldset>
+        <button>"Submit"</button>
+    </FancyForm>
+}
+```
+
+Как мне сделать это в Leptos? Есть два способа передать компоненты в другие компоненты:
+
+1. **render-свойства**: свойства-функции, возвращающие `view`
+2. свойство **`children`**: специальное свойство компонента, включающее всё, что вы передаёте в качестве дочерних элементов компонента.
+
+Вы фактически уже видели оба этих способа в действии в описании компонента [`<Show/>`](/view/06_control_flow.html#show):
+
+```rust
+view! {
+  <Show
+    // `when` is a normal prop
+    when=move || value() > 5
+    // `fallback` is a "render prop": a function that returns a view
+    fallback=|| view! { <Small/> }
+  >
+    // `<Big/>` (and anything else here)
+    // will be given to the `children` prop
+    <Big/>
+  </Show>
+}
+```
+
+Давайте объявим компонент, который принимает дочерние элементы и render-свойство.
+
+```rust
+#[component]
+pub fn TakesChildren<F, IV>(
+    /// Takes a function (type F) that returns anything that can be
+    /// converted into a View (type IV)
+    render_prop: F,
+    /// `children` takes the `Children` type
+    children: Children,
+) -> impl IntoView
+where
+    F: Fn() -> IV,
+    IV: IntoView,
+{
+    view! {
+        <h2>"Render Prop"</h2>
+        {render_prop()}
+
+        <h2>"Children"</h2>
+        {children()}
+    }
+}
+```
+
+И `render_prop` и `children` это функции, так что они могут быть вызываться, чтобы сгенерировать подходящие `view`
+`children`, в частности, это алиас для `Box<dyn FnOnce() -> Fragment>`. (Разве вы не рады, что мы назвали его `Children` вместо этого?)
+
+> Если вам тут понадобится `Fn` или `FnMut`, чтобы вызывать `children` больше одного раза,
+> мы также добавили алиасы `ChildrenFn` и `ChildrenMut`.
+
+Использовать этот компонент мы можем вот так:
+
+```rust
+view! {
+    <TakesChildren render_prop=|| view! { <p>"Hi, there!"</p> }>
+        // these get passed to `children`
+        "Some text"
+        <span>"A span"</span>
+    </TakesChildren>
+}
+```
+
+## Воздействие на дочерние элементы
+
+Тип  [`Fragment`](https://docs.rs/leptos/latest/leptos/struct.Fragment.html) это просто способ обернуть `Vec<View>`. Вы можете вставить его куда угодно внутри `view`.
+
+Но мы можем также получить доступ к этим внутренним `view` чтобы воздействовать на них.
+К примеру, вот компонент, принимающий дочерние элементы и превращающий их в неупорядоченный список.
+
+```rust
+#[component]
+pub fn WrapsChildren(children: Children) -> impl IntoView {
+    // Fragment has `nodes` field that contains a Vec<View>
+    let children = children()
+        .nodes
+        .into_iter()
+        .map(|child| view! { <li>{child}</li> })
+        .collect_view();
+
+    view! {
+        <ul>{children}</ul>
+    }
+}
+```
+
+Вызов его вот так создаст список:
+
+```rust
+view! {
+    <WrapsChildren>
+        "A"
+        "B"
+        "C"
+    </WrapsChildren>
+}
+```
+
+```admonish sandbox title="Live example" collapsible=true
+
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/9-component-children-0-5-m4jwhp?file=%2Fsrc%2Fmain.rs%3A1%2C1)
+
+<noscript>
+  Пожалуйста, включите Javascript для просмотра примеров.
+</noscript>
+
+<template>
+  <iframe src="https://codesandbox.io/p/sandbox/9-component-children-0-5-m4jwhp?file=%2Fsrc%2Fmain.rs%3A1%2C1" width="100%" height="1000px" style="max-height: 100vh"></iframe>
+</template>
+
+```
+
+<details>
+<summary>Код примера CodeSandbox</summary>
+
+```rust
+use leptos::*;
+
+// Often, you want to pass some kind of child view to another
+// component. There are two basic patterns for doing this:
+// - "render props": creating a component prop that takes a function
+//   that creates a view
+// - the `children` prop: a special property that contains content
+//   passed as the children of a component in your view, not as a
+//   property
+
+#[component]
+pub fn App() -> impl IntoView {
+    let (items, set_items) = create_signal(vec![0, 1, 2]);
+    let render_prop = move || {
+        // items.with(...) reacts to the value without cloning
+        // by applying a function. Here, we pass the `len` method
+        // on a `Vec<_>` directly
+        let len = move || items.with(Vec::len);
+        view! {
+            <p>"Length: " {len}</p>
+        }
+    };
+
+    view! {
+        // This component just displays the two kinds of children,
+        // embedding them in some other markup
+        <TakesChildren
+            // for component props, you can shorthand
+            // `render_prop=render_prop` => `render_prop`
+            // (this doesn't work for HTML element attributes)
+            render_prop
+        >
+            // these look just like the children of an HTML element
+            <p>"Here's a child."</p>
+            <p>"Here's another child."</p>
+        </TakesChildren>
+        <hr/>
+        // This component actually iterates over and wraps the children
+        <WrapsChildren>
+            <p>"Here's a child."</p>
+            <p>"Here's another child."</p>
+        </WrapsChildren>
+    }
+}
+
+/// Displays a `render_prop` and some children within markup.
+#[component]
+pub fn TakesChildren<F, IV>(
+    /// Takes a function (type F) that returns anything that can be
+    /// converted into a View (type IV)
+    render_prop: F,
+    /// `children` takes the `Children` type
+    /// this is an alias for `Box<dyn FnOnce() -> Fragment>`
+    /// ... aren't you glad we named it `Children` instead?
+    children: Children,
+) -> impl IntoView
+where
+    F: Fn() -> IV,
+    IV: IntoView,
+{
+    view! {
+        <h1><code>"<TakesChildren/>"</code></h1>
+        <h2>"Render Prop"</h2>
+        {render_prop()}
+        <hr/>
+        <h2>"Children"</h2>
+        {children()}
+    }
+}
+
+/// Wraps each child in an `<li>` and embeds them in a `<ul>`.
+#[component]
+pub fn WrapsChildren(children: Children) -> impl IntoView {
+    // children() returns a `Fragment`, which has a
+    // `nodes` field that contains a Vec<View>
+    // this means we can iterate over the children
+    // to create something new!
+    let children = children()
+        .nodes
+        .into_iter()
+        .map(|child| view! { <li>{child}</li> })
+        .collect::<Vec<_>>();
+
+    view! {
+        <h1><code>"<WrapsChildren/>"</code></h1>
+        // wrap our wrapped children in a UL
+        <ul>{children}</ul>
+    }
+}
+
+fn main() {
+    leptos::mount_to_body(App)
+}
+```
+
+</details>
+</preview>