diff --git a/Dockerfile b/Dockerfile
index 31fdf1ae..95e3f9bf 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,6 +1,6 @@
 FROM hexletbasics/base-image
 
-ARG PHP_VERSION=8.4
+ARG PHP_VERSION=8.5
 
 WORKDIR /exercises-php
 
diff --git a/composer.json b/composer.json
index a2cd8579..df5cbfde 100644
--- a/composer.json
+++ b/composer.json
@@ -17,9 +17,9 @@
     }
   ],
   "autoload": {
-    "files": [
-      "src/Functions.php"
-    ]
+    "psr-4": {
+      "HexletBasics\\Exercise\\": "src/"
+    }
   },
   "require-dev": {
     "friendsofphp/php-cs-fixer": "^3.0",
diff --git a/modules/10-basics/10-hello-world/index.php b/modules/10-basics/10-hello-world/Solution.php
similarity index 100%
rename from modules/10-basics/10-hello-world/index.php
rename to modules/10-basics/10-hello-world/Solution.php
diff --git a/modules/10-basics/10-hello-world/SolutionTest.php b/modules/10-basics/10-hello-world/SolutionTest.php
index 3934daad..a2377bf9 100644
--- a/modules/10-basics/10-hello-world/SolutionTest.php
+++ b/modules/10-basics/10-hello-world/SolutionTest.php
@@ -2,9 +2,7 @@
 
 namespace HexletBasics\Basics\HelloWorld;
 
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
@@ -12,6 +10,5 @@ public function test()
     {
         $expected = 'Hello, World!';
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/10-basics/10-hello-world/ru/README.md b/modules/10-basics/10-hello-world/ru/README.md
index f303ed9c..8974c7e1 100644
--- a/modules/10-basics/10-hello-world/ru/README.md
+++ b/modules/10-basics/10-hello-world/ru/README.md
@@ -1,42 +1,85 @@
-В этом уроке мы сразу напишем первую программу. Мы узнаем, какие команды понадобятся для этого и какие теги нужно использовать, чтобы программа, которая выполняет код, восприняла его. Также узнаем, зачем в коде нужны комментарии.
+Изучение нового языка программирования традиционно начинается с программы 'Hello, World!'. Это простая программа, которая выводит приветствие на экран и знакомит с синтаксисом и структурой нового языка.
 
-## Как написать простую программу
+```text
+Hello, World!
+```
+
+![Hello World](./assets/hello-world.png)
 
-Чтобы написать программу и вывести результат на экран, используют два способа:
+Этой традиции уже больше сорока лет, и мы тоже начнем с нее. В первом уроке мы напишем программу `Hello, World!`. На PHP эта программа выглядит так:
 
-* Через команду `echo`
-* Через команду `print_r()`
+```php
+<?php
 
-Разберем каждую подробнее.
+print_r('Hello, World!');
+```
 
-### Пишем программу через `echo`
+Строка `<?php` в начале — специальный тег, который сообщает, что дальше идет код на PHP. Подробнее о нем мы поговорим в следующем уроке.
 
-Напишем программу «Hello, World!». Она будет выводить на экран текст:
+Команда `print_r()` выводит на экран текст, указанный в скобках. В конце ставится точка с запятой `;` — так в PHP завершается каждая команда. Вместо примера можно написать любой другой текст.
 
 ```php
 <?php
 
-echo 'Hello, World!';
-// => Hello, World!
+print_r('Хекслет - школа программирования');
 ```
 
+Команда остается той же, меняется только содержимое скобок. Чтобы программа понимала, что это именно текст, он заключается в кавычки. Можно использовать одинарные `'...'` или двойные `"..."`, но открывающая и закрывающая кавычки должны совпадать.
 
-Вывод на экран выполняется с помощью специальной команды `echo`. После нее в одиночных кавычках указывается строка для вывода. В конце обязательно ставим точку с запятой.
+```php
+<?php
+
+print_r("Хекслет - школа программирования");
+```
 
-Для удобства мы будем показывать результат запуска строк кода так: `=> РЕЗУЛЬТАТ`.
+В PHP принято использовать одинарные кавычки для строк. Если внутри строки есть апостроф, одинарные кавычки сломают синтаксис, поэтому в таких случаях используют двойные.
 
-### Пишем программу через `print_r()`
+```php
+<?php
+
+print_r("it's PHP"); // апостроф внутри, поэтому двойные кавычки
+```
 
-Другой способ вывести строку на экран — функция `print_r()`:
+## Способы вывода на экран
+
+Кроме `print_r()`, в PHP есть еще одна команда вывода — `echo`:
 
 ```php
 <?php
 
-print_r('Hello, World!');
+echo 'Hello, World!';
 // => Hello, World!
 ```
 
+Для удобства мы будем показывать результат запуска строк кода так: `// => РЕЗУЛЬТАТ`.
+
+В простых ситуациях между `echo` и `print_r()` нет разницы — можно использовать любую команду. А там, где на экран нужно выводить не просто числа или строки, а, например, массивы, `echo` не сможет этого сделать, а `print_r()` все выведет.
 
-В этом случае строка указывается в скобках сразу после имени функции. В конце также нужно ставить `;`.
+## Значение символов
+
+Код состоит из команд, и каждая из них должна быть написана в определенной форме. Помимо букв, в коде важны кавычки `'` и `"`, скобки `()` и знаки препинания. Пропущенный или перепутанный знак приведет к тому, что программа не запустится. Попробуйте определить, какая ошибка допущена в каждой из строк?
+
+```php
+<?php
 
-В простых ситуациях между этими конструкциями нет разницы. Можно использовать любой способ. А там, где на экран нужно выводить не просто числа или строки, а, например, массивы, `echo` не сможет этого сделать, а `print_r()` все выведет.
+print_r("it's PHP"
+print_r(it's PHP")
+prin_r("it's PHP")
+print_r('it's PHP")
+print_r["it's PHP"];
+```
+
+Даже небольшое отличие, например одна лишняя буква или другой знак, может привести к тому, что программа не будет работать. Это относится и к регистру, то есть к различию между большими и маленькими буквами. Если в обычном тексте `Привет` и `привет` выглядят одинаково, то для программы это разные тексты. Имена функций PHP прощают разный регистр, но имена переменных и многие другие конструкции, с которыми мы встретимся дальше, — нет. Поэтому надежнее всего набирать код в точности так, как в примерах.
+
+## Где практиковаться
+
+Теория усваивается лучше, когда параллельно запускаешь код и видишь результат. Для этого подходит онлайн-интерпретатор PHP, где код выполняется прямо в браузере. Все, что встречается в уроке, стоит пробовать [в онлайн-интерпретаторе PHP](https://3v4l.org/).
+
+Как это работает технически? Любой написанный код передается в интерпретатор PHP, который этот код выполняет и выводит на экран результат его работы.
+
+```text
+Код               Интерпретатор        Экран
+┌────────────┐     ┌─────────────┐     ┌──────────────┐
+│ print_r(…) │ ──→ │     PHP     │ ──→ │ Hello, World!│
+└────────────┘     └─────────────┘     └──────────────┘
+```
diff --git a/modules/10-basics/10-hello-world/ru/assets/hello-world.png b/modules/10-basics/10-hello-world/ru/assets/hello-world.png
new file mode 100644
index 00000000..9bf2299f
Binary files /dev/null and b/modules/10-basics/10-hello-world/ru/assets/hello-world.png differ
diff --git a/modules/10-basics/10-hello-world/ru/data.yml b/modules/10-basics/10-hello-world/ru/data.yml
index d4c4aba6..a8ab7ad5 100644
--- a/modules/10-basics/10-hello-world/ru/data.yml
+++ b/modules/10-basics/10-hello-world/ru/data.yml
@@ -3,4 +3,4 @@ name: Привет, Мир!
 tips:
   - >
     [Немного о 'Hello,
-    World!'](https://ru.hexlet.io/blog/posts/moy-chelovek-menya-ponimaet-istoriya-frazy-hello-world-i-ee-analogov)
+    World!'](https://ru.hexlet.io/blog/posts/moy-chelovek-menya-ponimaet-istoriya-frazy-hello-world-i-ee-analogov?utm_source=code-basics&utm_medium=referral&utm_campaign=blog&utm_content=lesson)
diff --git a/modules/10-basics/20-tags/Makefile b/modules/10-basics/15-tags/Makefile
similarity index 100%
rename from modules/10-basics/20-tags/Makefile
rename to modules/10-basics/15-tags/Makefile
diff --git a/modules/10-basics/20-tags/index.php b/modules/10-basics/15-tags/Solution.php
similarity index 100%
rename from modules/10-basics/20-tags/index.php
rename to modules/10-basics/15-tags/Solution.php
diff --git a/modules/10-basics/20-tags/SolutionTest.php b/modules/10-basics/15-tags/SolutionTest.php
similarity index 68%
rename from modules/10-basics/20-tags/SolutionTest.php
rename to modules/10-basics/15-tags/SolutionTest.php
index 88089397..8d77257f 100644
--- a/modules/10-basics/20-tags/SolutionTest.php
+++ b/modules/10-basics/15-tags/SolutionTest.php
@@ -2,9 +2,7 @@
 
 namespace HexletBasics\Basics\Tags;
 
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
@@ -12,6 +10,5 @@ public function test()
     {
         $expected = 'King in the North!';
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/10-basics/20-tags/description.es.yml b/modules/10-basics/15-tags/description.es.yml
similarity index 100%
rename from modules/10-basics/20-tags/description.es.yml
rename to modules/10-basics/15-tags/description.es.yml
diff --git a/modules/10-basics/20-tags/en/EXERCISE.md b/modules/10-basics/15-tags/en/EXERCISE.md
similarity index 100%
rename from modules/10-basics/20-tags/en/EXERCISE.md
rename to modules/10-basics/15-tags/en/EXERCISE.md
diff --git a/modules/10-basics/20-tags/en/README.md b/modules/10-basics/15-tags/en/README.md
similarity index 100%
rename from modules/10-basics/20-tags/en/README.md
rename to modules/10-basics/15-tags/en/README.md
diff --git a/modules/10-basics/20-tags/en/data.yml b/modules/10-basics/15-tags/en/data.yml
similarity index 100%
rename from modules/10-basics/20-tags/en/data.yml
rename to modules/10-basics/15-tags/en/data.yml
diff --git a/modules/10-basics/20-tags/es/EXERCISE.md b/modules/10-basics/15-tags/es/EXERCISE.md
similarity index 100%
rename from modules/10-basics/20-tags/es/EXERCISE.md
rename to modules/10-basics/15-tags/es/EXERCISE.md
diff --git a/modules/10-basics/20-tags/es/README.md b/modules/10-basics/15-tags/es/README.md
similarity index 100%
rename from modules/10-basics/20-tags/es/README.md
rename to modules/10-basics/15-tags/es/README.md
diff --git a/modules/10-basics/20-tags/es/data.yml b/modules/10-basics/15-tags/es/data.yml
similarity index 100%
rename from modules/10-basics/20-tags/es/data.yml
rename to modules/10-basics/15-tags/es/data.yml
diff --git a/modules/10-basics/20-tags/ru/EXERCISE.md b/modules/10-basics/15-tags/ru/EXERCISE.md
similarity index 100%
rename from modules/10-basics/20-tags/ru/EXERCISE.md
rename to modules/10-basics/15-tags/ru/EXERCISE.md
diff --git a/modules/10-basics/20-tags/ru/README.md b/modules/10-basics/15-tags/ru/README.md
similarity index 100%
rename from modules/10-basics/20-tags/ru/README.md
rename to modules/10-basics/15-tags/ru/README.md
diff --git a/modules/10-basics/20-tags/ru/data.yml b/modules/10-basics/15-tags/ru/data.yml
similarity index 100%
rename from modules/10-basics/20-tags/ru/data.yml
rename to modules/10-basics/15-tags/ru/data.yml
diff --git a/modules/10-basics/30-comments/Makefile b/modules/10-basics/20-comments/Makefile
similarity index 100%
rename from modules/10-basics/30-comments/Makefile
rename to modules/10-basics/20-comments/Makefile
diff --git a/modules/10-basics/20-comments/Solution.php b/modules/10-basics/20-comments/Solution.php
new file mode 100644
index 00000000..ba5d44e4
--- /dev/null
+++ b/modules/10-basics/20-comments/Solution.php
@@ -0,0 +1,3 @@
+<?php
+
+// TODO: добавить функцию приветствия
diff --git a/modules/10-basics/20-comments/SolutionTest.php b/modules/10-basics/20-comments/SolutionTest.php
new file mode 100644
index 00000000..94a09e37
--- /dev/null
+++ b/modules/10-basics/20-comments/SolutionTest.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace HexletBasics\Basics\Comments;
+
+use HexletBasics\Exercise\TestCase;
+
+class SolutionTest extends TestCase
+{
+    public function test()
+    {
+        $this->expectOutputString('');
+        $content = file_get_contents('Solution.php');
+        $this->assertStringContainsString('// TODO: добавить функцию приветствия', $content);
+    }
+}
diff --git a/modules/10-basics/30-comments/description.es.yml b/modules/10-basics/20-comments/description.es.yml
similarity index 100%
rename from modules/10-basics/30-comments/description.es.yml
rename to modules/10-basics/20-comments/description.es.yml
diff --git a/modules/10-basics/30-comments/en/EXERCISE.md b/modules/10-basics/20-comments/en/EXERCISE.md
similarity index 100%
rename from modules/10-basics/30-comments/en/EXERCISE.md
rename to modules/10-basics/20-comments/en/EXERCISE.md
diff --git a/modules/10-basics/30-comments/en/README.md b/modules/10-basics/20-comments/en/README.md
similarity index 100%
rename from modules/10-basics/30-comments/en/README.md
rename to modules/10-basics/20-comments/en/README.md
diff --git a/modules/10-basics/30-comments/en/data.yml b/modules/10-basics/20-comments/en/data.yml
similarity index 100%
rename from modules/10-basics/30-comments/en/data.yml
rename to modules/10-basics/20-comments/en/data.yml
diff --git a/modules/10-basics/30-comments/es/EXERCISE.md b/modules/10-basics/20-comments/es/EXERCISE.md
similarity index 100%
rename from modules/10-basics/30-comments/es/EXERCISE.md
rename to modules/10-basics/20-comments/es/EXERCISE.md
diff --git a/modules/10-basics/30-comments/es/README.md b/modules/10-basics/20-comments/es/README.md
similarity index 100%
rename from modules/10-basics/30-comments/es/README.md
rename to modules/10-basics/20-comments/es/README.md
diff --git a/modules/10-basics/30-comments/es/data.yml b/modules/10-basics/20-comments/es/data.yml
similarity index 100%
rename from modules/10-basics/30-comments/es/data.yml
rename to modules/10-basics/20-comments/es/data.yml
diff --git a/modules/10-basics/20-comments/ru/EXERCISE.md b/modules/10-basics/20-comments/ru/EXERCISE.md
new file mode 100644
index 00000000..c86cb624
--- /dev/null
+++ b/modules/10-basics/20-comments/ru/EXERCISE.md
@@ -0,0 +1,9 @@
+Вы пишете программу и понимаете, что одну часть нужно доделать позже. Чтобы не забыть, программисты оставляют себе заметки прямо в коде — TODO-комментарии.
+
+Добавьте в файл такой комментарий:
+
+```php
+// TODO: добавить функцию приветствия
+```
+
+Когда вернётесь к этому месту позже, комментарий напомнит, что здесь ещё есть незавершённая работа.
diff --git a/modules/10-basics/20-comments/ru/README.md b/modules/10-basics/20-comments/ru/README.md
new file mode 100644
index 00000000..1805f638
--- /dev/null
+++ b/modules/10-basics/20-comments/ru/README.md
@@ -0,0 +1,77 @@
+Кроме самого кода, в исходных файлах часто можно встретить комментарии. Это строки, которые интерпретатор не обрабатывает. Программисты пишут их, чтобы пояснить, как работает код, отметить ошибки или напомнить, что нужно доделать.
+
+```php
+<?php
+
+// Удалить строку ниже после реализации задачи по регистрации
+print_r(10);
+```
+
+Однострочные комментарии в PHP начинаются с символов `//` или `#`, после которых может идти любой текст. Все, что написано после них до конца строки, интерпретатор игнорирует.
+
+```text
+// комментарий      ──→  [ пропущено интерпретатором ]
+print_r('hello');   ──→  [ выполнено → hello ]
+// еще один         ──→  [ пропущено интерпретатором ]
+```
+
+Комментарий может занимать всю строку:
+
+```php
+<?php
+
+// For Winterfell!
+// For Lanisters!
+```
+
+Или стоять в конце строки с кодом:
+
+```php
+<?php
+
+print_r('I am the King'); // For Lannisters!
+```
+
+Если нужно оставить длинное пояснение, используют несколько строк с `//`:
+
+```php
+<?php
+
+// The night is dark and
+// full of terrors.
+print_r('I am the King');
+```
+
+Для таких случаев в PHP есть и специальный вид — многострочные комментарии. Они начинаются с `/*` и заканчиваются на `*/`, а каждую строку между ними принято начинать с символа `*`:
+
+```php
+<?php
+
+/*
+ * The night is dark and
+ * full of terrors.
+ */
+print_r('I am the King');
+```
+
+Интерпретатор игнорирует комментарии. Разработчики благодаря им быстрее разбираются в чужом коде и не забывают важные детали в собственном.
+
+## Служебные комментарии
+
+В процессе работы вы будете встречаться с таким кодом в нашем редакторе:
+
+```php
+// BEGIN
+
+// END
+```
+
+*BEGIN* и *END* здесь это обычные комментарии, которые никак не влияют на работу программы. Они показывают, куда писать код задания.
+
+```php
+// BEGIN
+<здесь ваше решение>
+// END
+```
+
+Увидев *BEGIN* и *END*, пишите свой код между ними, остальное оставляйте без изменений.
diff --git a/modules/10-basics/30-comments/ru/data.yml b/modules/10-basics/20-comments/ru/data.yml
similarity index 82%
rename from modules/10-basics/30-comments/ru/data.yml
rename to modules/10-basics/20-comments/ru/data.yml
index 64f00d08..7d4f6a51 100644
--- a/modules/10-basics/30-comments/ru/data.yml
+++ b/modules/10-basics/20-comments/ru/data.yml
@@ -1,6 +1,9 @@
 ---
 name: Комментарии
-tips: []
+tips:
+  - >
+    [Подробнее о
+    комментариях](https://www.w3schools.com/php/php_comments.asp)
 definitions:
   - name: Комментарий
     description: >
diff --git a/modules/10-basics/30-comments/index.php b/modules/10-basics/30-comments/index.php
deleted file mode 100644
index d2b98262..00000000
--- a/modules/10-basics/30-comments/index.php
+++ /dev/null
@@ -1,3 +0,0 @@
-<?php
-
-// You know nothing, Jon Snow!
diff --git a/modules/10-basics/30-comments/ru/EXERCISE.md b/modules/10-basics/30-comments/ru/EXERCISE.md
deleted file mode 100644
index b326c804..00000000
--- a/modules/10-basics/30-comments/ru/EXERCISE.md
+++ /dev/null
@@ -1 +0,0 @@
-Создайте однострочный комментарий с текстом: `You know nothing, Jon Snow!`.
diff --git a/modules/10-basics/30-comments/ru/README.md b/modules/10-basics/30-comments/ru/README.md
deleted file mode 100644
index 464c8dfe..00000000
--- a/modules/10-basics/30-comments/ru/README.md
+++ /dev/null
@@ -1,28 +0,0 @@
-## Зачем нужны комментарии
-
-Кроме кода в файлах с исходным кодом могут находиться комментарии. Этот текст не является частью программы. Он нужен программистам для пометок. С их помощью добавляют пояснения, например, как работает код, какие ошибки нужно поправить или не забыть что-то позже добавить.
-
-Комментарии в PHP бывают двух видов:
-
-* **Однострочные комментарии** — начинаются с `//` или `#`. После этих символов может следовать любой текст, вся строка не будет анализироваться и исполняться:
-
-  ```php
-  <?php
-
-  // For Winterfell!
-  // For Lanisters!
-  // Комментарий может находиться на строке после какого-нибудь кода
-  print_r('I am the King'); // For Lannisters!
-  ```
-
-* **Многострочные комментарии** — начинаются с `/*` и заканчиваются на `*/`. Между ними каждая строка должна начинаться с символа `*`:
-
-  ```php
-  <?php
-
-  /*
-   * The night is dark and
-   * full of terrors.
-   */
-  print_r('I am the King');
-  ```
diff --git a/modules/10-basics/40-instructions/Makefile b/modules/10-basics/30-instructions/Makefile
similarity index 100%
rename from modules/10-basics/40-instructions/Makefile
rename to modules/10-basics/30-instructions/Makefile
diff --git a/modules/10-basics/40-instructions/index.php b/modules/10-basics/30-instructions/Solution.php
similarity index 100%
rename from modules/10-basics/40-instructions/index.php
rename to modules/10-basics/30-instructions/Solution.php
diff --git a/modules/10-basics/40-instructions/SolutionTest.php b/modules/10-basics/30-instructions/SolutionTest.php
similarity index 68%
rename from modules/10-basics/40-instructions/SolutionTest.php
rename to modules/10-basics/30-instructions/SolutionTest.php
index cb3f3aa4..aede0059 100644
--- a/modules/10-basics/40-instructions/SolutionTest.php
+++ b/modules/10-basics/30-instructions/SolutionTest.php
@@ -2,9 +2,7 @@
 
 namespace HexletBasics\Basics\Instructions;
 
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
@@ -12,6 +10,5 @@ public function test()
     {
         $expected = 'RobertStannisRenly';
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/10-basics/40-instructions/description.es.yml b/modules/10-basics/30-instructions/description.es.yml
similarity index 100%
rename from modules/10-basics/40-instructions/description.es.yml
rename to modules/10-basics/30-instructions/description.es.yml
diff --git a/modules/10-basics/40-instructions/en/EXERCISE.md b/modules/10-basics/30-instructions/en/EXERCISE.md
similarity index 100%
rename from modules/10-basics/40-instructions/en/EXERCISE.md
rename to modules/10-basics/30-instructions/en/EXERCISE.md
diff --git a/modules/10-basics/40-instructions/en/README.md b/modules/10-basics/30-instructions/en/README.md
similarity index 100%
rename from modules/10-basics/40-instructions/en/README.md
rename to modules/10-basics/30-instructions/en/README.md
diff --git a/modules/10-basics/40-instructions/en/data.yml b/modules/10-basics/30-instructions/en/data.yml
similarity index 100%
rename from modules/10-basics/40-instructions/en/data.yml
rename to modules/10-basics/30-instructions/en/data.yml
diff --git a/modules/10-basics/40-instructions/es/EXERCISE.md b/modules/10-basics/30-instructions/es/EXERCISE.md
similarity index 100%
rename from modules/10-basics/40-instructions/es/EXERCISE.md
rename to modules/10-basics/30-instructions/es/EXERCISE.md
diff --git a/modules/10-basics/40-instructions/es/README.md b/modules/10-basics/30-instructions/es/README.md
similarity index 100%
rename from modules/10-basics/40-instructions/es/README.md
rename to modules/10-basics/30-instructions/es/README.md
diff --git a/modules/10-basics/40-instructions/es/data.yml b/modules/10-basics/30-instructions/es/data.yml
similarity index 100%
rename from modules/10-basics/40-instructions/es/data.yml
rename to modules/10-basics/30-instructions/es/data.yml
diff --git a/modules/10-basics/40-instructions/ru/EXERCISE.md b/modules/10-basics/30-instructions/ru/EXERCISE.md
similarity index 100%
rename from modules/10-basics/40-instructions/ru/EXERCISE.md
rename to modules/10-basics/30-instructions/ru/EXERCISE.md
diff --git a/modules/10-basics/30-instructions/ru/README.md b/modules/10-basics/30-instructions/ru/README.md
new file mode 100644
index 00000000..a0918559
--- /dev/null
+++ b/modules/10-basics/30-instructions/ru/README.md
@@ -0,0 +1,82 @@
+Команду `print_r('Hexlet')` мы можем назвать инструкцией, она говорит интерпретатору PHP что нужно делать. Таких инструкций может быть сколько угодно. Каждая из них выполняется после того, как закончилась предыдущая и так мы из простых элементов получаем сколь угодно большую и сложную программу.
+
+```text
+Инструкция 1: print_r('Hello')   →  выполнена
+        ↓
+Инструкция 2: print_r('World')   →  выполнена
+        ↓
+Инструкция 3: print_r('!')       →  выполнена
+```
+
+Код на PHP — это набор инструкций, которые отделяются друг от друга символом `;`. Вот пример кода с двумя инструкциями. Эти строки говорят компьютеру вывести фразы на экран.
+
+```php
+<?php
+
+print_r('Mother of Dragons. '); // Первая инструкция
+print_r('Dracarys!'); // Вторая инструкция
+```
+
+Результат выполнения:
+
+```text
+Mother of Dragons. Dracarys!
+```
+
+Обратите внимание: фразы вывелись друг за другом на одной строке. Команда `print_r()` выводит текст и ничего не добавляет от себя, поэтому перевод строки не появляется.
+
+## Порядок имеет значение
+
+Интерпретатор PHP выполняет код строго в том порядке, в котором вы его написали. Если поменять строки местами:
+
+```php
+<?php
+
+print_r('Dracarys!');
+print_r('Mother of Dragons. ');
+```
+
+на экране они тоже поменяются:
+
+```text
+Dracarys!Mother of Dragons. 
+```
+
+## Альтернативная форма записи
+
+Обычно инструкции пишут на отдельных строках, но раз инструкции в PHP отделяются символом `;`, то перенос строки не обязателен. Несколько инструкций можно записать в одну строку:
+
+```php
+<?php
+
+print_r('Mother of Dragons. '); print_r('Dracarys!');
+```
+
+Обе версии работают одинаково, но второй вариант читать сложнее. Поэтому инструкции почти всегда пишут по одной на строку.
+
+## Зачем это нужно
+
+Сейчас мы пишем очень простые программы, но со временем они начнут усложняться и один из самых важных навыков, который поможет их понимать, это способность разбивать (в голове) программу на независимые инструкции. Только так можно разобраться в том, что в коде происходит. Ниже пример для привлечения внимания, понимать его пока не надо:
+
+```php
+<?php
+
+function isPrime(int $number): bool
+{
+    if ($number < 2) {
+        return false;
+    }
+
+    $divider = 2;
+
+    while ($divider <= $number / 2) {
+        if ($number % $divider == 0) {
+            return false;
+        }
+
+        $divider = $divider + 1;
+    }
+
+    return true;
+}
+```
diff --git a/modules/10-basics/40-instructions/ru/data.yml b/modules/10-basics/30-instructions/ru/data.yml
similarity index 100%
rename from modules/10-basics/40-instructions/ru/data.yml
rename to modules/10-basics/30-instructions/ru/data.yml
diff --git a/modules/10-basics/40-instructions/ru/README.md b/modules/10-basics/40-instructions/ru/README.md
deleted file mode 100644
index 9a4641be..00000000
--- a/modules/10-basics/40-instructions/ru/README.md
+++ /dev/null
@@ -1,28 +0,0 @@
-## Что такое инструкция
-
-**Инструкция** — это команда, которую исполняет интерпретатор PHP. Она написана на языке программирования. Ее можно сравнить с инструкцией или рецептом по приготовлению блюда:
-
-Код на PHP — это набор инструкций, которые отделяются друг от друга символом `;`.
-
-Вот пример кода с двумя инструкциями:
-
-```php
-<?php
-
-print_r('Mother of Dragons. ');
-print_r('Dracarys!');
-// => Mother of Dragons. Dracarys!
-```
-
-При запуске этого кода на экран последовательно выводятся два предложения: `Mother of Dragons. Dracarys!`.
-
-Инструкции можно написать последовательно друг за другом без переноса на новую строчку:
-
-```php
-<?php
-
-print_r('Mother of Dragons. '); print_r('Drakarys!');
-// => Mother of Dragons. Dracarys!
-```
-
-Результат на экране будет таким же. Но такой код неудобно читать, поэтому инструкции располагают друг под другом.
diff --git a/modules/10-basics/45-testing/Makefile b/modules/10-basics/40-testing/Makefile
similarity index 100%
rename from modules/10-basics/45-testing/Makefile
rename to modules/10-basics/40-testing/Makefile
diff --git a/modules/10-basics/45-testing/index.php b/modules/10-basics/40-testing/Solution.php
similarity index 100%
rename from modules/10-basics/45-testing/index.php
rename to modules/10-basics/40-testing/Solution.php
diff --git a/modules/10-basics/45-testing/SolutionTest.php b/modules/10-basics/40-testing/SolutionTest.php
similarity index 67%
rename from modules/10-basics/45-testing/SolutionTest.php
rename to modules/10-basics/40-testing/SolutionTest.php
index e177af65..bbf48ac1 100644
--- a/modules/10-basics/45-testing/SolutionTest.php
+++ b/modules/10-basics/40-testing/SolutionTest.php
@@ -2,9 +2,7 @@
 
 namespace HexletBasics\Basics\Testing;
 
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
@@ -12,6 +10,5 @@ public function test()
     {
         $expected = '9780262531962';
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/10-basics/45-testing/description.es.yml b/modules/10-basics/40-testing/description.es.yml
similarity index 100%
rename from modules/10-basics/45-testing/description.es.yml
rename to modules/10-basics/40-testing/description.es.yml
diff --git a/modules/10-basics/45-testing/en/EXERCISE.md b/modules/10-basics/40-testing/en/EXERCISE.md
similarity index 100%
rename from modules/10-basics/45-testing/en/EXERCISE.md
rename to modules/10-basics/40-testing/en/EXERCISE.md
diff --git a/modules/10-basics/45-testing/en/README.md b/modules/10-basics/40-testing/en/README.md
similarity index 100%
rename from modules/10-basics/45-testing/en/README.md
rename to modules/10-basics/40-testing/en/README.md
diff --git a/modules/10-basics/45-testing/en/data.yml b/modules/10-basics/40-testing/en/data.yml
similarity index 100%
rename from modules/10-basics/45-testing/en/data.yml
rename to modules/10-basics/40-testing/en/data.yml
diff --git a/modules/10-basics/45-testing/es/EXERCISE.md b/modules/10-basics/40-testing/es/EXERCISE.md
similarity index 100%
rename from modules/10-basics/45-testing/es/EXERCISE.md
rename to modules/10-basics/40-testing/es/EXERCISE.md
diff --git a/modules/10-basics/45-testing/es/README.md b/modules/10-basics/40-testing/es/README.md
similarity index 100%
rename from modules/10-basics/45-testing/es/README.md
rename to modules/10-basics/40-testing/es/README.md
diff --git a/modules/10-basics/45-testing/es/data.yml b/modules/10-basics/40-testing/es/data.yml
similarity index 100%
rename from modules/10-basics/45-testing/es/data.yml
rename to modules/10-basics/40-testing/es/data.yml
diff --git a/modules/10-basics/45-testing/ru/EXERCISE.md b/modules/10-basics/40-testing/ru/EXERCISE.md
similarity index 100%
rename from modules/10-basics/45-testing/ru/EXERCISE.md
rename to modules/10-basics/40-testing/ru/EXERCISE.md
diff --git a/modules/10-basics/40-testing/ru/README.md b/modules/10-basics/40-testing/ru/README.md
new file mode 100644
index 00000000..b5a87f02
--- /dev/null
+++ b/modules/10-basics/40-testing/ru/README.md
@@ -0,0 +1,42 @@
+Наш сайт автоматически проверяет ваши решения. Как это работает?
+
+В самом простом случае проверка запускает ваш код и сравнивает вывод на экран с ожидаемым результатом. Например, если задание звучит так: «Выведите число 10 на экран», то ваш код на PHP может выглядеть так:
+
+```php
+<?php
+
+print_r(10);
+```
+
+Проверка запустит этот код и убедится, что на экране действительно появилось `10`. Если вывод совпадает с ожидаемым, решение засчитывается. Иначе вы увидите ошибку:
+
+```text
+Failed asserting that two strings are equal.
+--- Expected
++++ Actual
+-'10'
++'9'
+
+FAILURES!
+Tests: 1, Assertions: 1, Failures: 1.
+```
+
+Строка с `+` показывает фактический результат, который вернул ваш код, а строка с `-` — ожидаемое значение.
+
+В следующих, более сложных уроках вы будете писать функции. Они принимают данные и возвращают результат. В таких задачах проверка работает немного иначе: она вызывает вашу функцию с разными аргументами и заранее знает, какой ответ должен получиться в каждом случае.
+
+Например, если нужно написать функцию сложения двух чисел, проверка будет передавать ей разные пары чисел и сравнивать результат с правильной суммой. Если во всех случаях ответы совпадут, решение считается верным.
+
+Такой подход называется тестированием, и он используется в реальной разработке. Тесты помогают проверить, правильно ли работает программа, и быстро заметить ошибку после изменений.
+
+Именно поэтому наш сайт говорит «Тесты пройдены», когда вы правильно решили задачу.
+
+## Моя ошибка или нет?
+
+Иногда в процессе решения будет казаться, что вы сделали все правильно, но проверка не принимает решение. Подобное случается крайне редко. Тесты автоматически запускаются после каждого изменения, поэтому сломанная проверка обычно не попадает на сайт.
+
+В подавляющем большинстве таких случаев ошибка содержится в коде решения. Она может быть очень незаметной: вместо английской буквы случайно ввели русскую, вместо верхнего регистра использовали нижний или забыли вывести запятую. Бывают и более сложные ситуации. Например, решение работает для одного набора входных данных, но не работает для другого.
+
+Поэтому всегда внимательно читайте условие задачи и вывод тестов. Там почти наверняка есть указание на ошибку.
+
+Если же вы уверены, что проблема в задании или нашли неточность, напишите в наше [сообщество](https://t.me/hexletcommunity), в канал _'Обратная связь'_.
diff --git a/modules/10-basics/45-testing/ru/data.yml b/modules/10-basics/40-testing/ru/data.yml
similarity index 81%
rename from modules/10-basics/45-testing/ru/data.yml
rename to modules/10-basics/40-testing/ru/data.yml
index 72d8e83f..7e4ba556 100644
--- a/modules/10-basics/45-testing/ru/data.yml
+++ b/modules/10-basics/40-testing/ru/data.yml
@@ -8,3 +8,5 @@ definitions:
 tips:
   - |
     [TDD](https://ru.wikipedia.org/wiki/Разработка_через_тестирование)
+  - |
+    [Сообщество Хекслета в Telegram](https://t.me/hexletcommunity)
diff --git a/modules/10-basics/45-testing/ru/README.md b/modules/10-basics/45-testing/ru/README.md
deleted file mode 100644
index 3fad2184..00000000
--- a/modules/10-basics/45-testing/ru/README.md
+++ /dev/null
@@ -1,30 +0,0 @@
-
-Наш сайт автоматически проверяет ваши решения. Как это работает?
-
-В самом простом случае, система просто запускает код и смотрит на то, что вывелось на экран. А потом сверяет с тем, что мы «ожидали» по заданию.
-
-В следующих, более сложных уроках, вы будете писать функции — мини-программы, принимающие информацию из внешнего мира и производящие какие-то операции. Проверка ваших решений в таких случаях выглядит немного сложнее: система запускает ваше решение и передаёт какую-то информацию. Система также знает — «ожидает» — какой именно ответ должна дать правильная функция при таких входных данных.
-
-Например, если ваша задача — написать функцию сложения двух чисел, то проверочная система будет передавать ей разные комбинации чисел и сверять ответ вашей функции с реальными суммами. Если во всех случаях ответы совпадут, то решение считается верным.
-
-Такой подход называется тестированием, и он используется в реальной повседневной разработке. Обычно программист сначала пишет тест — проверочную программу, а потом уже ту программу, которую хотел написать. В процессе он постоянно запускает тесты и смотрит, приблизился ли он к решению.
-
-Именно поэтому наш сайт говорит «Тесты пройдены», когда вы правильно решили задачу.
-
-Вот простой пример: необходимо распечатать строку `Hello, World!`. Предположим, вы допустили небольшую ошибку, и функция вывела на экран другое значение. Система ответит примерно так:
-
-```text
-  -'Hello, World!'
-  +'ello, World!'
-
-  FAILURES!
-  Tests: 1, Assertions: 1, Failures: 1.
-```
-
-На экране появляется подсказка. На ней знаком `+` обозначено то, что распечатал ваш код. Знаком `-` – то, что ожидалось. Сравнивая эти два значения, можно увидеть ошибку. В примере выше видно, что в выводе пропущена буква _H_.
-
----
-
-Иногда в процессе решения будет казаться, что вы сделали все правильно, но система «капризничает» и не принимает решение. Подобное поведение практически исключено. Нерабочие тесты просто не могут попасть на сайт, они автоматически запускаются после каждого изменения. В подавляющем большинстве таких случаев, (а все наши проекты в сумме провели миллионы проверок за много лет), ошибка содержится в коде решения. Она может быть очень незаметной, вместо английской буквы случайно ввели русскую, вместо верхнего регистра использовали нижний или забыли вывести запятую. Другие случаи сложнее. Возможно ваше решение работает для одного набора входных данных, но не работает для другого. Поэтому всегда внимательно читайте условие задачи и вывод тестов. Там почти наверняка есть указание на ошибку.
-
-Однако, если вы уверены в ошибке или нашли какую-то неточность, то вы всегда можете указать на неё. В конце каждой теории есть ссылка на содержимое урока на гитхабе (этот проект полностью открытый!). Перейдя туда, вы можете написать issue, посмотреть содержимое тестов (там видно, как вызывается ваш код) и даже отправить pullrequest. Если для вас это пока тёмный лес, то подключитесь в наше сообщество [Telegram Hexlet](https://t.me/hexletcommunity/12), там в канале Волонтеры мы всегда поможем.
diff --git a/modules/10-basics/50-syntax-errors/Solution.php b/modules/10-basics/50-syntax-errors/Solution.php
new file mode 100644
index 00000000..8bc15518
--- /dev/null
+++ b/modules/10-basics/50-syntax-errors/Solution.php
@@ -0,0 +1,3 @@
+<?php
+
+print_r('Программа успешно запущена');
diff --git a/modules/10-basics/50-syntax-errors/SolutionTest.php b/modules/10-basics/50-syntax-errors/SolutionTest.php
index 9d6bc720..915b3b9f 100644
--- a/modules/10-basics/50-syntax-errors/SolutionTest.php
+++ b/modules/10-basics/50-syntax-errors/SolutionTest.php
@@ -2,16 +2,13 @@
 
 namespace HexletBasics\Basics\SyntaxErrors;
 
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        $expected = 'What Is Dead May Never Die';
+        $expected = 'Программа успешно запущена';
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/10-basics/50-syntax-errors/index.php b/modules/10-basics/50-syntax-errors/index.php
deleted file mode 100644
index 46242713..00000000
--- a/modules/10-basics/50-syntax-errors/index.php
+++ /dev/null
@@ -1,3 +0,0 @@
-<?php
-
-print_r('What Is Dead May Never Die');
diff --git a/modules/10-basics/50-syntax-errors/ru/EXERCISE.md b/modules/10-basics/50-syntax-errors/ru/EXERCISE.md
index a7b008f0..4ff44922 100644
--- a/modules/10-basics/50-syntax-errors/ru/EXERCISE.md
+++ b/modules/10-basics/50-syntax-errors/ru/EXERCISE.md
@@ -1,4 +1,12 @@
+Программа запускается и сообщает о результате. Напишите программу, которая выводит:
 
-Это задание не связано с уроком напрямую. Но будет полезным потренироваться с выводом на экран.
+```text
+Программа успешно запущена
+```
 
-Выведите на экран `What Is Dead May Never Die`.
+После того как программа заработает, намеренно сломайте её — допустите одну из синтаксических ошибок:
+
+- уберите точку с запятой `;`;
+- уберите закрывающую кавычку или скобку.
+
+Запустите код и прочитайте сообщение PHP. Такие сообщения вы будете видеть часто — важно научиться их читать. Затем верните рабочий вариант, чтобы упражнение прошло проверку.
diff --git a/modules/10-basics/50-syntax-errors/ru/README.md b/modules/10-basics/50-syntax-errors/ru/README.md
index d1bdaa9e..37705cf8 100644
--- a/modules/10-basics/50-syntax-errors/ru/README.md
+++ b/modules/10-basics/50-syntax-errors/ru/README.md
@@ -1,16 +1,52 @@
+Если программа на PHP написана с нарушением правил, интерпретатор остановит выполнение и выведет сообщение об ошибке. В этом сообщении указывается:
 
-Если программа на PHP написана синтаксически некорректно, то интерпретатор выводит на экран соответствующее сообщение, а также указание на файл и строчку в нём, где по его мнению произошла ошибка. _Синтаксическая ошибка_ возникает в том случае, когда код был записан с нарушением грамматических правил. В человеческих языках грамматика важна, но текст с ошибками чаще всего можно понять и прочитать. В программировании всё строго. Любое мельчайшее нарушение — и программа даже не запустится. Примером может быть забытая `;`, неправильно расставленные скобки и другие детали.
+- тип ошибки,
+- файл и строка, в которой она произошла,
+- и (часто) подсказка, чего интерпретатор ожидал.
 
-Вот пример кода с синтаксической ошибкой:
+## Что такое синтаксическая ошибка?
+
+Синтаксическая ошибка (Parse error) — это нарушение правил написания кода (грамматических правил) в конкретном языке программирования. Такие ошибки возникают, если код написан с отклонением от ожидаемого формата: забыта точка с запятой `;`, не закрыта строка, пропущена скобка и т.д.
+
+В отличие от естественных языков, где текст с ошибками можно понять по контексту, в программировании даже малейшее отклонение делает код неработоспособным.
+
+```text
+Код с ошибкой          Интерпретатор        Результат
+┌────────────────┐     ┌─────────────┐     ┌─────────────────┐
+│ print_r('Hi')  │ ──→ │     PHP     │ ──→ │ Parse error:    │
+└────────────────┘     └─────────────┘     │ unexpected EOF  │
+                                           └─────────────────┘
+```
+
+Рассмотрим простой пример с синтаксической ошибкой:
 
 ```php
 <?php
 
+// Правильный вариант такой: print_r('Hodor');
 print_r('Hodor')
 ```
 
-Если запустить код выше, то мы увидим следующее сообщение: `$ PHP Parse error:  syntax error, unexpected end of file in /private/var/tmp/index.php on line 4`. Подобные синтаксические ошибки в PHP относятся к разряду "Parse error". Как видно, в конце приводится путь до файла и номер строчки.
+В этом коде забыта точка с запятой `;` в конце инструкции, что делает программу некорректной с точки зрения синтаксиса. Попробуем запустить программу, и интерпретатор выдаст ошибку:
+
+```bash
+php index.php
+PHP Parse error:  syntax error, unexpected end of file, expecting "," or ";" in /tmp/index.php on line 4
+```
+
+Текст с непривычки может быть непонятен, но это нормально — чем больше вы будете сталкиваться с такими ошибками, тем быстрее научитесь понимать, что произошло. Обратите внимание: в конце сообщения приводится путь до файла и номер строки, где по мнению интерпретатора произошла ошибка.
+
+## Почему такие ошибки считаются простыми?
+
+Синтаксические ошибки:
+
+- легко заметить: код часто подсвечивается в редакторе;
+- легко исправить: достаточно вернуть пропущенный символ или поправить структуру.
+
+Но есть ложка дёгтя. Интерпретатор не всегда указывает точно то место, где допущена ошибка. Иногда проблема находится несколькими строками выше. Например, открытая, но не закрытая скобка на одной строке может «сломать» весь следующий код.
 
-С одной стороны, ошибки "Parse error" — самые простые, потому что они связаны исключительно с грамматическими правилами написания кода, а не с самим смыслом кода. Их легко исправить: нужно лишь найти нарушение в записи.
+## Что делать при синтаксической ошибке?
 
-С другой стороны, интерпретатор не всегда может чётко указать на это нарушение. Поэтому бывает, что забытую скобку нужно поставить не туда, куда указывает сообщение об ошибке.
+- Читай сообщение об ошибке. Оно почти всегда содержит полезную информацию.
+- Проверь строку, указанную в сообщении, и строку до неё: иногда ошибка «спрятана» чуть раньше.
+- Используй [редактор с подсветкой синтаксиса](https://code.visualstudio.com/): он поможет сразу заметить проблемы (например, незакрытые кавычки или скобки).
diff --git a/modules/10-basics/50-syntax-errors/ru/data.yml b/modules/10-basics/50-syntax-errors/ru/data.yml
index 043fcbfb..eeea41f3 100644
--- a/modules/10-basics/50-syntax-errors/ru/data.yml
+++ b/modules/10-basics/50-syntax-errors/ru/data.yml
@@ -1,6 +1,9 @@
 ---
 name: Синтаксические ошибки
-tips: []
+tips:
+  - >
+    [Виды ошибок в
+    PHP](https://www.php.net/manual/ru/language.errors.basics.php)
 definitions:
   - name: Синтаксическая ошибка
     description: нарушение грамматических правил языка программирования.
diff --git a/modules/20-arithmetics/20-basic/index.php b/modules/20-arithmetics/20-basic/Solution.php
similarity index 100%
rename from modules/20-arithmetics/20-basic/index.php
rename to modules/20-arithmetics/20-basic/Solution.php
diff --git a/modules/20-arithmetics/20-basic/SolutionTest.php b/modules/20-arithmetics/20-basic/SolutionTest.php
index e393e5eb..a246685b 100644
--- a/modules/20-arithmetics/20-basic/SolutionTest.php
+++ b/modules/20-arithmetics/20-basic/SolutionTest.php
@@ -2,9 +2,7 @@
 
 namespace HexletBasics\Arithmetics\Basics;
 
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
@@ -12,6 +10,5 @@ public function test()
     {
         $expected = '9';
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/20-arithmetics/20-basic/ru/EXERCISE.md b/modules/20-arithmetics/20-basic/ru/EXERCISE.md
index 5dfef630..a8f46734 100644
--- a/modules/20-arithmetics/20-basic/ru/EXERCISE.md
+++ b/modules/20-arithmetics/20-basic/ru/EXERCISE.md
@@ -1 +1 @@
-Выведите на экран результат деления числа `81` на `9`.
+Вы зашли в оптовый магазин и увидели упаковку из 9 батареек за 81 рубль. В обычном магазине одна батарейка стоит 12 рублей. Рассчитайте и выведите цену одной батарейки в оптовой упаковке, чтобы понять, где выгоднее покупать.
diff --git a/modules/20-arithmetics/20-basic/ru/README.md b/modules/20-arithmetics/20-basic/ru/README.md
index 046cd027..88e49203 100644
--- a/modules/20-arithmetics/20-basic/ru/README.md
+++ b/modules/20-arithmetics/20-basic/ru/README.md
@@ -1,8 +1,12 @@
-На базовом уровне компьютеры оперируют только числами. Для сложения двух чисел в математике мы пишем, например, `3 + 4`. В программировании — то же самое. В этом уроке разберем, как проводить арифметические операции в коде.
+На базовом уровне компьютеры работают только с числами. Даже если вы пишете сложное приложение на современном языке программирования, внутри него всегда происходят многочисленные вычисления: сложение, вычитание, деление и т.д.
 
-## Арифметика в программировании
+![Счетные палочки](./assets/arithmetics.png)
 
-Рассмотрим пример программы, которая складывает два числа:
+К счастью, чтобы начать программировать, достаточно знать обычную школьную арифметику. С нее мы и начнем.
+
+## Сложение в PHP
+
+В математике для сложения мы пишем 3 + 4. В PHP все точно так же:
 
 ```php
 <?php
@@ -11,25 +15,145 @@
 3 + 4;
 ```
 
-Арифметика в программировании практически не отличается от школьной. Инструкция `3 + 4;` заставит интерпретатор сложить числа и узнать результат. Эта программа будет работать, но в ней нет смысла, потому что по сути мы не даем команду интерпретатору, мы просто говорим ему «смотри, сумма трех и четырех».
+Этот код действительно можно запустить: интерпретатор выполнит вычисление. Но... он не сделает с результатом ничего. То есть 7 получится, но вы его не увидите.
+
+## Чтобы увидеть результат, нужно его вывести
+
+В реальной программе просто посчитать значение недостаточно. Нужно сделать что-то с результатом, например, показать его пользователю. При создании интернет-магазина недостаточно попросить интерпретатор посчитать стоимость товаров в корзине — нужно посчитать стоимость и показать цену покупателю.
+
+Для этого используем уже привычную команду `print_r()`, которую в дальнейшем будем называть функцией:
+
+```php
+<?php
+
+print_r(3 + 4);
+```
+
+Здесь сначала вычисляется сумма, затем она передается в функцию печати.
+
+```text
+print_r(3 + 4)
+        └─┬─┘
+          7
+
+print_r(7)  →  7
+```
+
+Результат выполнения:
+
+```text
+7
+```
+
+Если записать это же выражение в виде строки, то мы получим совсем другой результат, на печать будет выведена строка «как есть»:
 
-В реальной работе недостаточно сообщать интерпретатору о математическом выражении. Например, при создании интернет-магазина недостаточно просить интерпретатор посчитать стоимость товаров в корзине. В этом случае нужно просить посчитать стоимость и показать цену покупателю.
+```php
+<?php
+
+print_r('3 + 4'); // выводит: 3 + 4
+print_r(3 + 4);   // выводит: 7
+```
+
+## Другие арифметические операции
+
+PHP поддерживает все привычные операции + несколько специфичных, связанных с тем, как хранятся и обрабатываются числа на компьютере:
+
+| Операция               | Символ | Пример       | Результат |
+|------------------------|--------|--------------|-----------|
+| Сложение               | `+`    | `2 + 3`      | `5`       |
+| Вычитание              | `-`    | `7 - 2`      | `5`       |
+| Умножение              | `*`    | `4 * 3`      | `12`      |
+| Деление                | `/`    | `8 / 2`      | `4`       |
+| Возведение в степень   | `**`   | `3 ** 2`     | `9`       |
+| Целочисленное деление  | `intdiv()` | `intdiv(7, 3)` | `2`   |
+| Остаток от деления     | `%`    | `7 % 3`      | `1`       |
+
+Эти знаки операций называют операторами. Вот как можно вывести результат деления и возведения в степень:
+
+```php
+<?php
+
+print_r(8 / 2);  // => 4
+print_r(3 ** 2); // => 9
+```
+
+## Числа с плавающей точкой
 
-Нам нужно попросить интерпретатор сложить `3 + 4` и дать команду сделать что-то с результатом. Например, вывести его на экран:
+Помимо целых чисел в PHP есть числа с плавающей точкой, которые используются для работы с дробями. Такие числа записываются через точку:
 
 ```php
 <?php
 
-// Снова не забываем точку с запятой в конце строчки
-print_r(3 + 4); // => 7
+print_r(3.5 + 1.2); // => 4.7
+print_r(10 / 4);    // => 2.5
 ```
 
-Кроме сложения доступны следующие операции:
+Иногда мы используем их сами, когда нужно работать именно с дробными значениями, например при подсчете среднего или при работе с деньгами и измерениями. Но числа с плавающей точкой могут появляться и сами, например, в результате операции деления `/`:
 
-* `*` — умножение
-* `/` — деление
-* `-` — вычитание
-* `%` — [остаток от деления](https://ru.wikipedia.org/wiki/Деление_с_остатком)
-* `**` — возведение в степень
+```php
+<?php
+
+print_r(8 / 2); // => 4
+print_r(7 / 2); // => 3.5
+```
+
+Если результат деления получился целым, PHP оставляет его целым числом, а дробный результат автоматически становится числом с плавающей точкой.
+
+Причина выделения этого в отдельный тип: компьютеру нужно хранить целые значения и дробные значения по-разному. Для целых он выделяет одни структуры в памяти, для дробных выделяет другие. Поэтому в PHP, как и в других языках программирования, существует два разных вида чисел: int (целые) и float (с плавающей точкой).
+
+На базовом уровне достаточно помнить: целые числа нужны, когда нет дробей, а числа с плавающей точкой нужны, когда дроби есть. Подробнее мы разберемся с ними дальше по курсу.
+
+## Что такое остаток от деления (`%`)
+
+Эта операция называется **взятие остатка от деления**. Она показывает, **что «остается»**, когда одно число делится на другое *не полностью*. Пример:
+
+```php
+<?php
+
+print_r(7 % 3); // => 1
+```
+
+Почему результат равен 1?
+
+- 7 делится на 3 дважды: 3 * 2 = 6
+- До 7 остается 1, и это является остатком.
+
+Другие примеры:
+
+```php
+<?php
+
+print_r(10 % 4); // => 2 (10 делится на 4 дважды: 4 * 2 = 8, остаток 2)
+print_r(15 % 5); // => 0 (делится без остатка)
+```
+
+Операция % часто используется в программировании, например:
+
+- чтобы проверить, делится ли число нацело (если остаток 0)
+- чтобы выполнять циклические действия, например, поведение по четным/нечетным индексам
+
+Мы еще неоднократно встретим % в задачах и разберем его применение на практике.
+
+## Оформление арифметических выражений
+
+С точки зрения PHP между `3+4` и `3 + 4` нет разницы. Интерпретатор поймет оба варианта одинаково и в обоих случаях выполнит сложение. Разница только в оформлении кода. В программировании принято ставить пробелы вокруг арифметических операторов, потому что так выражения проще читать:
+
+```php
+<?php
+
+3 + 4;
+8 / 2;
+7 % 3;
+```
+
+Вариант без пробелов тоже работает:
+
+```php
+<?php
+
+3+4;
+8/2;
+7%3;
+```
 
-Эти знаки операций называют операторами.
+Но такой код выглядит менее аккуратно и его сложнее быстро воспринимать. Поэтому лучше сразу привыкать писать с пробелами вокруг операторов.
diff --git a/modules/20-arithmetics/20-basic/ru/assets/arithmetics.png b/modules/20-arithmetics/20-basic/ru/assets/arithmetics.png
new file mode 100644
index 00000000..ae492022
Binary files /dev/null and b/modules/20-arithmetics/20-basic/ru/assets/arithmetics.png differ
diff --git a/modules/20-arithmetics/20-basic/ru/data.yml b/modules/20-arithmetics/20-basic/ru/data.yml
index 0333794a..73cd539e 100644
--- a/modules/20-arithmetics/20-basic/ru/data.yml
+++ b/modules/20-arithmetics/20-basic/ru/data.yml
@@ -9,6 +9,13 @@ tips:
     Деление на ноль приводит к ошибке `Division by zero`. Чтобы его не
     допустить, нужно знать про условные конструкции (о них вы узнаете в
     следующих уроках).
+  - |
+    [Деление с остатком](https://ru.wikipedia.org/wiki/Деление_с_остатком)
   - >
     Если в редакторе есть запись `// BEGIN` и `// END`, то код нужно писать
     между этими строчками.
+definitions:
+  - name: Инструкция
+    description: >
+      наименьшая автономная часть языка программирования; команда или набор
+      команд. Программа обычно представляет собой последовательность инструкций.
diff --git a/modules/20-arithmetics/25-operator/index.php b/modules/20-arithmetics/25-operator/Solution.php
similarity index 63%
rename from modules/20-arithmetics/25-operator/index.php
rename to modules/20-arithmetics/25-operator/Solution.php
index 790c3ea2..d3acae0e 100644
--- a/modules/20-arithmetics/25-operator/index.php
+++ b/modules/20-arithmetics/25-operator/Solution.php
@@ -2,4 +2,5 @@
 
 // BEGIN
 print_r(6 - -81);
+print_r((6 - -81) / 3);
 // END
diff --git a/modules/20-arithmetics/25-operator/SolutionTest.php b/modules/20-arithmetics/25-operator/SolutionTest.php
index 38121b48..a4019612 100644
--- a/modules/20-arithmetics/25-operator/SolutionTest.php
+++ b/modules/20-arithmetics/25-operator/SolutionTest.php
@@ -2,16 +2,13 @@
 
 namespace HexletBasics\Arithmetics\Operator;
 
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        $expected = '87';
+        $expected = '8729';
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/20-arithmetics/25-operator/ru/EXERCISE.md b/modules/20-arithmetics/25-operator/ru/EXERCISE.md
index 003cfc9c..ca7ca8a9 100644
--- a/modules/20-arithmetics/25-operator/ru/EXERCISE.md
+++ b/modules/20-arithmetics/25-operator/ru/EXERCISE.md
@@ -1 +1,8 @@
-Напишите программу, которая посчитает разность между числами `6` и `-81` и выведет ответ на экран.
+Подводная лодка находится на глубине -81 м. Палуба спасательного корабля расположена на высоте +6 м над уровнем воды.
+
+Рассчитайте и выведите на экран:
+
+1. Полное расстояние всплытия в метрах.
+2. Время подъема в минутах — лодка поднимается со скоростью 3 м/мин.
+
+Обратите внимание, что результаты выведутся «слепленными» в одну строчку без пробела. Мы научимся решать эту проблему в будущих уроках.
diff --git a/modules/20-arithmetics/25-operator/ru/README.md b/modules/20-arithmetics/25-operator/ru/README.md
index b7b41c59..dfc9d30b 100644
--- a/modules/20-arithmetics/25-operator/ru/README.md
+++ b/modules/20-arithmetics/25-operator/ru/README.md
@@ -1,8 +1,9 @@
-Знак операции, например, `+`, называют **оператором**. Операторы обычно представлены одним или несколькими символами, реже — словом. Обычно они соответствуют математическим операциям.
+В математике и программировании мы часто используем знаки операций, такие как `+`, `-`, `*` и другие. В программировании такие знаки называются операторами.
 
-Операторы выполняют операции над определенными значениями, которые называются **операндами**.
+- Оператор представляет собой символ или слово, которое обозначает действие.
+- Операнды являются значениями, к которым применяется оператор.
 
-Рассмотрим пример:
+Пример:
 
 ```php
 <?php
@@ -10,13 +11,24 @@
 print_r(8 + 2);
 ```
 
-Здесь `+` — это оператор, а числа `8` и `2` — это операнды.
+Здесь:
+
+- `+` является оператором
+- `8` и `2` являются операндами
+- результатом будет `10`
+
+```text
+операнд   оператор   операнд       результат
+    8         +          2       →      10
+    5         -          3       →      2
+    4         *          3       →      12
+```
 
 Операции, которые требуют наличия двух операндов, называются **бинарными**. В случае сложения у нас есть два операнда: один слева от знака `+`, другой — справа. Если пропустить хотя бы один операнд, например, `3 + ;`, то программа завершится с синтаксической ошибкой.
 
-Еще операции бывают **унарными** — с одним операндом, и тернарными — с тремя операндами. Причем операторы могут выглядеть одинаково, но обозначать разные операции.
+## Унарные операторы
 
-Символы `+` и `-` используются не только как операторы. Когда речь идет про отрицательные числа, то знак минуса становится частью числа:
+Существуют и унарные операции, которые работают с одним операндом. Пример:
 
 ```php
 <?php
@@ -24,20 +36,53 @@ print_r(8 + 2);
 print_r(-3); // => -3
 ```
 
-Выше пример применения унарной операции к числу `3`. Оператор `-` перед тройкой говорит интерпретатору взять число `3` и найти противоположное, то есть `-3`. Это может сбить с толку, потому что `-3` — это одновременно и число, и оператор с операндом. Но у языков программирования такая структура:
+В этом случае `-` является унарным оператором, а `3` является операндом. Интерпретатор получает команду: «возьми число 3 и измени его знак».
+
+Оператор `-` может использоваться по-разному. Когда он стоит **между двумя числами**, это операция вычитания:
+
+```php
+<?php
+
+print_r(5 - 2);  // => 3
+print_r(10 - 7); // => 3
+```
+
+Здесь `-` берет первое число и вычитает из него второе.
+
+Эта разница особенно заметна при работе с отрицательными числами. Например:
 
 ```php
 <?php
 
-// То же самое, что и 4 - 3
-print_r(4 + -3); // => 1
+// минус на минус дает плюс
+print_r(5 - -2); // => 7
 ```
 
+Сначала мы видим операцию вычитания: `5 - (...)`. Но справа стоит унарный минус `-2`, который превращает `2` в отрицательное число. В итоге получается: `5 - (-2) = 7`.
+
+Таким образом, значение `-` зависит от контекста: если рядом стоит другое число, это вычитание, иначе это смена знака числа.
+
 То же самое касается и плюса:
 
 ```php
 <?php
 
-print_r(+3); // => 3
+print_r(+3);     // => 3
 print_r(1 + +3); // => 4
 ```
+
+Главное, что здесь нужно помнить: поведение и даже сама запись здесь полностью соответствует тому, как мы делали это в школе.
+
+## Ошибки при вычислениях и парсинге
+
+Если воспринимать `-3` как единое число, можно не заметить, что `-` является отдельным оператором со своим приоритетом. Например:
+
+```php
+<?php
+
+print_r(-3 ** 2);
+```
+
+На первый взгляд может показаться, что в квадрат возводится `-3`, и результат должен быть `9` (любое число в квадрате становится положительным). Но результат будет `-9`.
+
+Дело в порядке вычислений: сначала выполняется возведение в степень (`**`), а только потом применяется унарный минус. То есть программа считает так: `-(3 ** 2) = -9`. Про приоритет операций мы поговорим подробнее дальше по курсу.
diff --git a/modules/20-arithmetics/25-operator/ru/data.yml b/modules/20-arithmetics/25-operator/ru/data.yml
index c1529fbb..01e30a5b 100644
--- a/modules/20-arithmetics/25-operator/ru/data.yml
+++ b/modules/20-arithmetics/25-operator/ru/data.yml
@@ -1,11 +1,20 @@
 ---
 name: Операторы
 tips:
+  - >-
+    Всегда отбивайте арифметические операторы пробелами от своих операндов – это
+    хороший стиль программирования.
   - |
     [Операторы в PHP](https://www.php.net/manual/ru/language.operators.php)
 definitions:
   - name: Арифметическая операция
     description: сложение, вычитание, умножение и деление.
+  - name: Оператор
+    description: >-
+      специальный символ, создающий операцию. Например, `+` создает операцию
+      сложения.
+  - name: Операнд
+    description: 'объект, который участвует в операции. `3 * 6`: здесь 3 и 6 — операнды.'
   - name: Унарная операция
     description: >-
       операция с одним операндом. Например, `-3` — унарная операция для
diff --git a/modules/20-arithmetics/27-commutativity/Solution.php b/modules/20-arithmetics/27-commutativity/Solution.php
new file mode 100644
index 00000000..d516da70
--- /dev/null
+++ b/modules/20-arithmetics/27-commutativity/Solution.php
@@ -0,0 +1,6 @@
+<?php
+
+// BEGIN
+print_r(2 ** 8);
+print_r(9 / 3);
+// END
diff --git a/modules/20-arithmetics/27-commutativity/SolutionTest.php b/modules/20-arithmetics/27-commutativity/SolutionTest.php
index 82d6026c..d219d54f 100644
--- a/modules/20-arithmetics/27-commutativity/SolutionTest.php
+++ b/modules/20-arithmetics/27-commutativity/SolutionTest.php
@@ -2,16 +2,13 @@
 
 namespace HexletBasics\Arithmetics\Commutativity;
 
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        $expected = '2432';
+        $expected = '2563';
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/20-arithmetics/27-commutativity/index.php b/modules/20-arithmetics/27-commutativity/index.php
deleted file mode 100644
index e38d8b77..00000000
--- a/modules/20-arithmetics/27-commutativity/index.php
+++ /dev/null
@@ -1,6 +0,0 @@
-<?php
-
-// BEGIN
-print_r(3 ** 5);
-print_r(-8 / -4);
-// END
diff --git a/modules/20-arithmetics/27-commutativity/ru/EXERCISE.md b/modules/20-arithmetics/27-commutativity/ru/EXERCISE.md
index 59f7db4b..2686bb09 100644
--- a/modules/20-arithmetics/27-commutativity/ru/EXERCISE.md
+++ b/modules/20-arithmetics/27-commutativity/ru/EXERCISE.md
@@ -1,3 +1,6 @@
-Напишите программу, которая считает и последовательно выводит на экран значения следующих математических выражений: «3 в степени 5» и «-8 разделить на -4».
+Напишите программу, которая решает две задачи и последовательно выводит ответы на экран.
+
+1. Художник хочет раскрасить 8 секций забора, каждую — в один из 2 цветов. Сколько уникальных вариантов раскраски существует? Используйте оператор возведения в степень `**`.
+2. Вы с двумя друзьями (итого 3 человека) купили 9 пирожных и хотите разделить их поровну. Сколько достанется каждому? Используйте оператор деления `/`.
 
 Обратите внимание, что результаты выведутся «слепленными» в одну строчку без пробела. Мы научимся решать эту проблему в будущих уроках.
diff --git a/modules/20-arithmetics/27-commutativity/ru/README.md b/modules/20-arithmetics/27-commutativity/ru/README.md
index bbb5b91c..262d84fa 100644
--- a/modules/20-arithmetics/27-commutativity/ru/README.md
+++ b/modules/20-arithmetics/27-commutativity/ru/README.md
@@ -1,3 +1,63 @@
-В программировании используется базовый закон арифметики: от перемены мест слагаемых сумма не меняется. Он называется **коммутативным законом**. Если поменять местами операнды в бинарной операции, и получится тот же результат, такая операция будет коммутативной. Получается, что сложение — коммутативная операция: `3 + 2 = 2 + 3`.
+Фраза «от перемены мест слагаемых сумма не меняется» знакома каждому со школы. Этот принцип называется коммутативным законом и является одним из основных законов арифметики.
 
-Вычитание не будет являться коммутативной операцией: `2 - 3 ≠ 3 - 2`. В программировании этот закон тоже работает. Большинство операций, с которыми мы будем сталкиваться в реальной жизни, не являются коммутативными. Поэтому всегда нужно обращать внимание на порядок того, с чем работаем.
+## Что такое коммутативность
+
+Операция называется коммутативной, если порядок операндов не влияет на результат: поменяв местами значения, вы получите тот же ответ. Пример коммутативной операции: сложение.
+
+```php
+<?php
+
+print_r(3 + 2); // => 5
+print_r(2 + 3); // => 5
+```
+
+Одинаковый результат подтверждает, что операция коммутативна.
+
+```text
+2 + 3 = 5     3 + 2 = 5
+└──────────┬─────────┘
+  одинаковый результат
+
+2 - 3 = -1    3 - 2 = 1
+└──────────┬─────────┘
+    разный результат
+```
+
+## Некоммутативные операции
+
+Но не все операции обладают таким свойством. Например, вычитание является некоммутативной операцией:
+
+```php
+<?php
+
+print_r(2 - 3); // => -1
+print_r(3 - 2); // => 1
+```
+
+Перестановка операндов дает другой результат.
+
+## В программировании все то же самое
+
+Коммутативность в программировании работает точно так же, как в арифметике. PHP строго следует математическим правилам.
+
+Другие некоммутативные операции:
+
+- Деление: _8 / 2 ≠ 2 / 8_
+- Возведение в степень: _2 **3 ≠ 3** 2_
+
+Примеры в коде:
+
+```php
+<?php
+
+// Деление
+print_r(8 / 2);  // 8 делить на 2 = 4
+
+// Возведение в степень
+print_r(3 ** 2); // 3 в квадрате = 9
+```
+
+Поэтому:
+
+- Всегда внимательно проверяйте порядок операндов, особенно при работе с незнакомыми операциями;
+- проверяйте коммутативность экспериментально, а не предполагайте ее заранее.
diff --git a/modules/20-arithmetics/27-commutativity/ru/data.yml b/modules/20-arithmetics/27-commutativity/ru/data.yml
index 30c686eb..6f2f1637 100644
--- a/modules/20-arithmetics/27-commutativity/ru/data.yml
+++ b/modules/20-arithmetics/27-commutativity/ru/data.yml
@@ -1,6 +1,9 @@
 ---
 name: Коммутативная операция
-tips: []
+tips:
+  - >
+    [Подробнее про
+    коммутативность](https://ru.wikipedia.org/wiki/Коммутативность)
 definitions:
   - name: Коммутативность
     description: >
diff --git a/modules/20-arithmetics/30-composition/Solution.php b/modules/20-arithmetics/30-composition/Solution.php
new file mode 100644
index 00000000..9ce7c99c
--- /dev/null
+++ b/modules/20-arithmetics/30-composition/Solution.php
@@ -0,0 +1,5 @@
+<?php
+
+// BEGIN
+print_r(3 * 200 + 2 * 30);
+// END
diff --git a/modules/20-arithmetics/30-composition/SolutionTest.php b/modules/20-arithmetics/30-composition/SolutionTest.php
index c713a965..e1df4641 100644
--- a/modules/20-arithmetics/30-composition/SolutionTest.php
+++ b/modules/20-arithmetics/30-composition/SolutionTest.php
@@ -2,16 +2,13 @@
 
 namespace HexletBasics\Arithmetics\Composition;
 
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        $expected = '10.5';
+        $expected = '660';
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/20-arithmetics/30-composition/index.php b/modules/20-arithmetics/30-composition/index.php
deleted file mode 100644
index 49c5a8d6..00000000
--- a/modules/20-arithmetics/30-composition/index.php
+++ /dev/null
@@ -1,5 +0,0 @@
-<?php
-
-// BEGIN
-print_r(8 / 2 + 5 - -3 / 2);
-// END
diff --git a/modules/20-arithmetics/30-composition/ru/EXERCISE.md b/modules/20-arithmetics/30-composition/ru/EXERCISE.md
index 256a7994..3eadd3fb 100644
--- a/modules/20-arithmetics/30-composition/ru/EXERCISE.md
+++ b/modules/20-arithmetics/30-composition/ru/EXERCISE.md
@@ -1,7 +1,9 @@
-Реализуйте программу, которая вычисляет и выводит на экран значение выражения:
+Вы идете в магазин за подарками: 3 книги по 200 рублей и 2 ручки по 30 рублей. Рассчитайте и выведите итоговую стоимость покупки.
 
 ```text
-8 / 2 + 5 - -3 / 2
+3 * 200  +  2 * 30
+    ↓           ↓
+   600    +    60    =  660
 ```
 
 Не вычисляйте ничего самостоятельно, ваша программа должна производить все вычисления сама.
diff --git a/modules/20-arithmetics/30-composition/ru/README.md b/modules/20-arithmetics/30-composition/ru/README.md
index 1acddea3..02b96b75 100644
--- a/modules/20-arithmetics/30-composition/ru/README.md
+++ b/modules/20-arithmetics/30-composition/ru/README.md
@@ -1,17 +1,86 @@
-Разберем пример композиции операций:
+В PHP, как и в математике, можно объединять несколько операций в одну строку. Такие выражения интерпретатор обрабатывает шаг за шагом, по определенным правилам. Это свойство операций называется **композицией**.
+
+Рассмотрим пример:
+
+```php
+<?php
+
+print_r(2 * 4 * 5 * 10);
+```
+
+Этот код состоит из нескольких операций умножения, объединенных в одно выражение. Чтобы понять, как интерпретатор выполняет выражение, разберем его по этапам:
+
+- Сначала вычисляется `2 * 4`: `8 * 5 * 10`
+- Затем `8 * 5`: `40 * 10`
+- И наконец `40 * 10`: `400`
+
+Итоговый результат составляет `400`.
+
+## А если разные операции?
+
+Все просто, пока используются одинаковые операторы. Но что произойдет, если объединить, например, умножение и сложение?
+
+```php
+<?php
+
+print_r(2 + 3 * 4);
+```
+
+```text
+2 + 3 * 4
+    └─┬─┘
+2 +  12
+└──┬───┘
+   14
+```
+
+Получится ли `20` или `14`? Ответ: `14`.
+
+Это объясняется тем, что в PHP, как и в математике, у операций есть приоритет. Умножение выполняется раньше сложения, если не использовать скобки. Мы разберем это подробнее в уроке про приоритеты.
+
+## Примеры с вычитанием и отрицательными числами
+
+То же правило работает и для вычитания:
+
+```php
+<?php
+
+print_r(10 - 2 * 3); // => 4
+```
+
+Сначала выполняется умножение: `10 - 6 = 4`.
+
+Если же в выражении есть отрицательные числа, унарный минус применяется уже после возведения в степень:
+
+```php
+<?php
+
+print_r(-2 ** 2); // => -4, два в степени два, затем применяется минус
+print_r(-2 * 5);  // => -10, минус два умноженное на пять
+print_r(4 + -2);  // => 2
+print_r(6 - -2);  // => 8
+```
+
+Во всех примерах, кроме первого, сначала вычисляется унарный минус (`-2`), и затем проводятся остальные операции.
+
+Рассмотрим подробнее последний пример:
 
 ```php
 <?php
 
-print_r(2 * 4 * 5 * 10); // 2 * 4 * 5 * 10 = 8 * 5 * 10 = 40 * 10 => 400
+print_r(6 - -2); // => 8
 ```
 
-Операции можно соединять друг с другом. Это дает возможность вычислять более сложные составные выражения. Такое свойство операций называется **композицией**.
+Сначала вычисляется унарный минус (`-2`), и затем операция превращается в `6 - (-2)`, что дает `8`. Это то же самое, что:
 
-Композиция арифметических операций в программировании аналогична композиции из школьной программы. Она распространяется на все операции, а не только на арифметические.
+```php
+<?php
+
+print_r(6 + 2); // => 8
+```
 
-Чтобы представить, как происходят вычисления внутри интерпретатора, разберем пример: `2 * 4 * 5 * 10`.
+## Что нужно запомнить
 
-1. Сначала вычисляется `2 * 4` и получается выражение `8 * 5 * 10`
-2. Затем `8 * 5`. В итоге имеем `40 * 10`
-3. В конце происходит последнее умножение, и получается результат `400`
+- Выражения могут состоять из нескольких операций.
+- PHP вычисляет их поэтапно: слева направо, соблюдая приоритет операций.
+- Скобки можно использовать, чтобы явно указать порядок вычислений.
diff --git a/modules/20-arithmetics/30-composition/ru/data.yml b/modules/20-arithmetics/30-composition/ru/data.yml
index bcab44d9..72350aa7 100644
--- a/modules/20-arithmetics/30-composition/ru/data.yml
+++ b/modules/20-arithmetics/30-composition/ru/data.yml
@@ -1,3 +1,7 @@
 ---
 name: Композиция операций
 tips: []
+definitions:
+  - name: Композиция
+    description: |
+      метод объединения нескольких простых операций в одну сложную.
diff --git a/modules/20-arithmetics/40-priority/Solution.php b/modules/20-arithmetics/40-priority/Solution.php
new file mode 100644
index 00000000..2a2ae3b5
--- /dev/null
+++ b/modules/20-arithmetics/40-priority/Solution.php
@@ -0,0 +1,5 @@
+<?php
+
+// BEGIN
+print_r((2 * 300 + 4 * 50) / 5);
+// END
diff --git a/modules/20-arithmetics/40-priority/SolutionTest.php b/modules/20-arithmetics/40-priority/SolutionTest.php
index 6c9c8994..aed274b5 100644
--- a/modules/20-arithmetics/40-priority/SolutionTest.php
+++ b/modules/20-arithmetics/40-priority/SolutionTest.php
@@ -2,16 +2,13 @@
 
 namespace HexletBasics\Arithmetics\Priority;
 
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        $expected = '49';
+        $expected = '160';
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/20-arithmetics/40-priority/index.php b/modules/20-arithmetics/40-priority/index.php
deleted file mode 100644
index 3ba8600b..00000000
--- a/modules/20-arithmetics/40-priority/index.php
+++ /dev/null
@@ -1,5 +0,0 @@
-<?php
-
-// BEGIN
-print_r(70 * (3 + 4) / (8 + 2));
-// END
diff --git a/modules/20-arithmetics/40-priority/ru/EXERCISE.md b/modules/20-arithmetics/40-priority/ru/EXERCISE.md
index 615f07de..b604e210 100644
--- a/modules/20-arithmetics/40-priority/ru/EXERCISE.md
+++ b/modules/20-arithmetics/40-priority/ru/EXERCISE.md
@@ -1,3 +1,8 @@
-Дано вычисление `70 * 3 + 4 / 8 + 2`.
+Вы с 4 друзьями (итого 5 человек) заказали 2 пиццы по 300 рублей и 4 напитка по 50 рублей. Нужно разделить счет поровну.
 
-Расставьте скобки так, чтобы оба сложения (`3 + 4`) и (`8 + 2`) высчитывались в первую очередь. Выведите на экран результат.
+Запишите программу из одной строки с `print_r()`, расставив скобки так, чтобы сначала посчиталась общая сумма, а затем делилась на всех:
+
+```text
+без скобок:   2 * 300 + 4 * 50 / 5  =  640  ← неверно
+со скобками:  (2 * 300 + 4 * 50) / 5  =  160  ← верно
+```
diff --git a/modules/20-arithmetics/40-priority/ru/README.md b/modules/20-arithmetics/40-priority/ru/README.md
index 97a74bd4..32613436 100644
--- a/modules/20-arithmetics/40-priority/ru/README.md
+++ b/modules/20-arithmetics/40-priority/ru/README.md
@@ -1,6 +1,4 @@
-В школьной математике есть понятие «приоритет операции». Приоритет определяет, в какой последовательности должны выполняться операции.
-
-Допустим, нам нужно вычислить такое выражение: `2 + 2 * 2`:
+Рассмотрим простое выражение:
 
 ```php
 <?php
@@ -8,19 +6,72 @@
 print_r(2 + 2 * 2); // => 6
 ```
 
-Интерпретатор производит арифметические вычисления в правильном порядке: сначала деление и умножение, потом сложение и вычитание, а приоритет возведения в степень выше всех остальных арифметических операций: `2 ** 3 * 2` вычислится в `16`.
+Результат равен 6, а не 8. Это объясняется понятием приоритета операций в математике и программировании. Он определяет порядок, в котором выполняются действия:
+
+- Умножение и деление выполняются раньше сложения и вычитания.
+- Возведение в степень (**) имеет еще более высокий приоритет.
+
+```text
+Приоритет операций (от высокого к низкому):
+
+  **         возведение в степень
+   ↓
+  * / %      умножение, деление, остаток
+   ↓
+  + -        сложение, вычитание
+```
+
+Например:
+
+```php
+<?php
+
+print_r(2 * 2 ** 3); // => 16, потому что сначала 2 ** 3 = 8, затем 8 * 2 = 16
+```
+
+Если рядом идут операции с одинаковым приоритетом, они выполняются слева направо:
+
+```php
+<?php
+
+print_r(8 / 2 * 3); // => 12, потому что сначала 8 / 2 = 4, затем 4 * 3 = 12
+```
+
+## Управление порядком действий
+
+Иногда нужно изменить порядок вычислений. Для этого используются круглые скобки. Они позволяют задать, какие действия нужно выполнить в первую очередь:
+
+```php
+<?php
+
+print_r((2 + 2) * 2); // => 8
+```
 
-Иногда вычисления должны происходить в другом порядке. В этом случае приоритет задают круглыми скобками, например: `(2 + 2) * 2`. Скобки можно ставить вокруг любой операции. Они могут вкладываться друг в друга сколько угодно раз. Вот пара примеров:
+Скобки можно ставить вокруг любой части выражения и вкладывать их друг в друга:
 
 ```php
 <?php
 
-print_r(3 ** (4 - 2)); // => 9
+print_r(3 ** (4 - 2));                   // => 9
 print_r(7 * 3 + (4 / 2) - (8 + (2 - 1))); // => 14
 ```
 
-В этом случае главное закрывать скобки в правильном порядке. Это часто становится причиной ошибок не только у новичков, но и у опытных программистов. Для удобства можно сразу ставить открывающую и закрывающую скобки, а потом писать внутреннюю часть.
+Главное правило: всегда закрывайте скобки. Непарные скобки вызывают ошибки: и новички, и опытные программисты иногда забывают про закрывающую скобку.
 
-Сейчас большинство редакторов кода делают это автоматически. Например, мы ставим открывающую скобку, а он автоматически ставит закрывающую. Это касается и других парных символов, например, кавычек. О них — в будущих уроках.
+> Пишите скобки сразу парой. Например, вводите () и потом заполняйте внутреннюю часть. Большинство редакторов кода (в том числе наш) автоматически добавляют закрывающую скобку, как только вы пишете открывающую. Это касается и других парных символов, например, кавычек.
+
+## Повышаем читаемость
+
+Иногда выражение работает правильно, но выглядит запутанно. В таких случаях скобки можно добавить просто для наглядности: они не изменят результат, но улучшат восприятие.
+
+```php
+<?php
+
+// Было
+print_r(8 / 2 + 5 - -3 / 2);       // => 10.5
+
+// Стало
+print_r(((8 / 2) + 5) - (-3 / 2)); // => 10.5
+```
 
-Иногда выражение сложно воспринимать визуально. Тогда можно расставить скобки, не повлияв на приоритет. Код пишется для людей, а машины будут только исполнять его. Для машин код — или корректный, или не корректный. Для них нет «более» понятного или «менее» понятного кода. Явная расстановка приоритетов упрощает чтение кода другими разработчиками.
+Программы пишут люди, и читают их тоже люди. Компьютеру все равно, насколько понятно написан код: достаточно, чтобы он был синтаксически правильным. Для человека понятный и аккуратный код является залогом удобства, особенно при работе в команде или разборе ошибок.
diff --git a/modules/20-arithmetics/40-priority/ru/data.yml b/modules/20-arithmetics/40-priority/ru/data.yml
index 84df3bea..f716ee70 100644
--- a/modules/20-arithmetics/40-priority/ru/data.yml
+++ b/modules/20-arithmetics/40-priority/ru/data.yml
@@ -4,3 +4,8 @@ tips:
   - >
     [Приоритет
     операторов](https://www.php.net/manual/ru/language.operators.precedence.php)
+definitions:
+  - name: Выражение
+    description: >
+      последовательность действий над данными, приводящая к каком-то результату,
+      который можно использовать.
diff --git a/modules/30-variables/14-errors/Makefile b/modules/20-arithmetics/43-float/Makefile
similarity index 100%
rename from modules/30-variables/14-errors/Makefile
rename to modules/20-arithmetics/43-float/Makefile
diff --git a/modules/20-arithmetics/43-float/Solution.php b/modules/20-arithmetics/43-float/Solution.php
new file mode 100644
index 00000000..9dcfa518
--- /dev/null
+++ b/modules/20-arithmetics/43-float/Solution.php
@@ -0,0 +1,5 @@
+<?php
+
+// BEGIN
+print_r(0.1 + 0.2 - 0.3);
+// END
diff --git a/modules/20-arithmetics/43-float/SolutionTest.php b/modules/20-arithmetics/43-float/SolutionTest.php
new file mode 100644
index 00000000..007d6b3a
--- /dev/null
+++ b/modules/20-arithmetics/43-float/SolutionTest.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace HexletBasics\Arithmetics\FloatingPointNumbers;
+
+use HexletBasics\Exercise\TestCase;
+
+class SolutionTest extends TestCase
+{
+    public function test()
+    {
+        $expected = '5.5511151231258E-17';
+        $this->expectOutputString($expected);
+    }
+}
diff --git a/modules/20-arithmetics/43-float/description.es.yml b/modules/20-arithmetics/43-float/description.es.yml
new file mode 100644
index 00000000..cc64fd90
--- /dev/null
+++ b/modules/20-arithmetics/43-float/description.es.yml
@@ -0,0 +1,73 @@
+---
+
+name: Números de punto flotante
+theory: |
+  En matemáticas hay diferentes tipos de números. Por ejemplo:
+
+  - Naturales: números enteros positivos: 1, 2, 3, etc.
+  - Racionales: números fraccionarios que se pueden representar como una división, por ejemplo: 0.5, 1.75, 3.14.
+
+  Desde el punto de vista de las matemáticas, todo es simple. Pero desde el punto de vista de la computadora, entre estos tipos de números hay un verdadero abismo. Intenta resolver mentalmente: ¿cuánto es `0.2` + `0.1`? Obviamente, `0.3`. PHP mostrará lo mismo al imprimir:
+
+  ```php
+  <?php
+
+  print_r(0.1 + 0.2); // => 0.3
+  ```
+
+  Todo parece estar bien. Pero hagamos una comprobación: restemos 0.3 de esta suma. Matemáticamente, el resultado debería ser exactamente cero. Esto es lo que dice PHP:
+
+  ```php
+  <?php
+
+  print_r(0.1 + 0.2 - 0.3); // => 5.5511151231258E-17
+  ```
+
+  En lugar de cero obtenemos una pequeña «cola»: un número en notación exponencial, aproximadamente igual a 0.000000000000000055. La cuestión es que internamente PHP no almacena exactamente 0.3, sino una aproximación de 0.30000000000000004. Al imprimir, el número se redondea a 14 dígitos significativos, por lo que el error no es visible. Pero no desaparece de los cálculos.
+
+  ## ¿Por qué sucede esto?
+
+  Este comportamiento es típico de Python, JavaScript y la mayoría de los demás lenguajes de programación.
+
+  La razón está en el funcionamiento de la computadora. Una computadora trabaja con memoria limitada, mientras que los números racionales son infinitamente precisos. Entre 0.1 y 0.2 se pueden colocar infinitos números. Pero la computadora no puede almacenar el infinito. Aproxima el número, tratando de ajustarlo a la cantidad de bits disponible.
+
+  Estos valores aproximados se llaman números de punto flotante (floating point numbers). Su almacenamiento y los cálculos con ellos siguen reglas estrictas descritas en un estándar especial, IEEE 754, en el que se basan la mayoría de los lenguajes de programación.
+
+  ## Cuándo aparecen estos números
+
+  Los números de punto flotante aparecen en los programas con más frecuencia de lo que parece. Estos son los casos principales:
+
+  - Cuando escribes explícitamente un número fraccionario, por ejemplo 0.1, 2.5, 3.14.
+  - Cuando realizas una división con resultado fraccionario:
+
+  ```php
+  <?php
+
+  print_r(1 / 2); // => 0.5
+  print_r(2 / 3); // => 0.66666666666667
+  ```
+
+  Incluso si el resultado parece «bonito», internamente sigue representado como un valor aproximado. Algunas fracciones, como 1 / 3, no pueden representarse exactamente en el sistema binario, por lo que su precisión siempre es limitada.
+
+  ## Dónde es crítico y cómo se trabaja con esto
+
+  Normalmente, un pequeño error no molesta. Pero en cálculos financieros, tareas científicas y de ingeniería, así como en la comparación exacta de resultados, puede convertirse en un problema. En los programas reales, el dinero a menudo se almacena en unidades mínimas, por ejemplo en centavos, es decir, se usan números enteros en lugar de fraccionarios. En otros casos, el resultado se redondea a la cantidad necesaria de dígitos, los números se comparan con un margen de error aceptable o se usan tipos de datos y bibliotecas especiales para cálculos exactos.
+
+  ## Qué hay que recordar
+
+  Las operaciones con números de punto flotante no siempre son exactas, y esto es normal. PHP redondea los números al imprimir, por lo que el error no siempre es visible en la pantalla, pero está presente en los cálculos. La precisión se puede controlar, por ejemplo, mediante el redondeo o la comparación de números con un margen de error dado. Al trabajar con dinero, mediciones precisas o cálculos científicos, es mejor usar tipos de datos especiales que proporcionen control sobre la precisión.
+
+instructions: |
+  Estás pagando dos productos en una tienda en línea: el primero cuesta 0.1 rublos, el segundo — 0.2 rublos. El programa de caja debe verificar la precisión de los cálculos: restar los 0.3 rublos esperados del total.
+
+  Calcula e imprime esta diferencia. Esperas ver cero, pero PHP mostrará algo interesante.
+
+tips:
+  - >
+    [Lo que todo informático debe saber sobre la aritmética de punto
+    flotante](https://www.validlab.com/goldberg/paper.pdf)
+
+definitions:
+  - name: Número racional
+    description: |
+      un número que se puede representar como una fracción común.
diff --git a/modules/20-arithmetics/43-float/en/EXERCISE.md b/modules/20-arithmetics/43-float/en/EXERCISE.md
new file mode 100644
index 00000000..d40ef1f6
--- /dev/null
+++ b/modules/20-arithmetics/43-float/en/EXERCISE.md
@@ -0,0 +1,3 @@
+You are paying for two items in an online store: the first one costs 0.1 rubles, the second one costs 0.2 rubles. The checkout program must verify the accuracy of the calculations: subtract the expected 0.3 rubles from the total.
+
+Calculate and print this difference. You expect to see zero — but PHP will show something interesting.
diff --git a/modules/20-arithmetics/43-float/en/README.md b/modules/20-arithmetics/43-float/en/README.md
new file mode 100644
index 00000000..b0292b4f
--- /dev/null
+++ b/modules/20-arithmetics/43-float/en/README.md
@@ -0,0 +1,54 @@
+In mathematics there are different types of numbers. For example:
+
+- Natural numbers: positive integers: 1, 2, 3, and so on.
+- Rational numbers: fractional numbers that can be represented as a division, for example: 0.5, 1.75, 3.14.
+
+From the point of view of mathematics, everything is simple. But from the computer's point of view, there is a real chasm between these types of numbers. Try to solve mentally: what is `0.2` + `0.1`? Obviously, `0.3`. PHP will show the same when printing:
+
+```php
+<?php
+
+print_r(0.1 + 0.2); // => 0.3
+```
+
+Everything seems fine. But let's check: subtract 0.3 from this sum. Mathematically, the result should be exactly zero. Here is what PHP says:
+
+```php
+<?php
+
+print_r(0.1 + 0.2 - 0.3); // => 5.5511151231258E-17
+```
+
+Instead of zero, we get a tiny "tail" — a number in exponential notation, approximately equal to 0.000000000000000055. The thing is that internally PHP stores not exactly 0.3, but an approximation of 0.30000000000000004. When printing, the number is rounded to 14 significant digits, so the error is not visible. But it does not disappear from the calculations themselves.
+
+## Why does this happen?
+
+This behavior is typical for Python, JavaScript, and most other programming languages.
+
+The reason lies in how computers work. A computer operates with limited memory, while rational numbers are infinitely precise. Infinitely many other numbers can fit between 0.1 and 0.2. But a computer cannot store infinity. It approximates the number, trying to fit it into the available number of bits.
+
+Such approximate values are called floating point numbers. Their storage and calculations follow strict rules described in a special standard, IEEE 754, which most programming languages rely on.
+
+## When such numbers appear
+
+Floating point numbers appear in programs more often than it may seem. Here are the main cases:
+
+- When you explicitly write a fractional number, for example 0.1, 2.5, 3.14.
+- When you perform division with a fractional result:
+
+```php
+<?php
+
+print_r(1 / 2); // => 0.5
+print_r(2 / 3); // => 0.66666666666667
+```
+
+Even if the result looks "nice", internally it is still represented as an approximate value. Some fractions, such as 1 / 3, cannot be exactly represented in the binary system at all, so their precision is always limited.
+
+## Where it is critical and how to deal with it
+
+Usually a small error does not interfere. But in financial calculations, scientific and engineering tasks, as well as in exact comparison of results, it can become a problem. In real programs, money is often stored in minimal units, such as cents, that is, integers are used instead of fractions. In other cases, the result is rounded to the required number of digits, numbers are compared with an acceptable error margin, or special data types and libraries for exact calculations are used.
+
+## What to remember
+
+Operations with floating point numbers are not always exact, and this is normal. PHP rounds numbers when printing, so the error is not always visible on the screen — but it is present in the calculations. Precision can be controlled, for example, by rounding or comparing numbers with a given error margin. When working with money, precise measurements, or scientific calculations, it is better to use special data types that provide control over precision.
diff --git a/modules/20-arithmetics/43-float/en/data.yml b/modules/20-arithmetics/43-float/en/data.yml
new file mode 100644
index 00000000..397451b0
--- /dev/null
+++ b/modules/20-arithmetics/43-float/en/data.yml
@@ -0,0 +1,10 @@
+---
+name: Floating point numbers
+tips:
+  - >
+    [What every computer scientist should know about floating-point
+    arithmetic](https://www.validlab.com/goldberg/paper.pdf)
+definitions:
+  - name: Rational number
+    description: |
+      a number that can be represented as a common fraction.
diff --git a/modules/20-arithmetics/43-float/es/EXERCISE.md b/modules/20-arithmetics/43-float/es/EXERCISE.md
new file mode 100644
index 00000000..a73e3298
--- /dev/null
+++ b/modules/20-arithmetics/43-float/es/EXERCISE.md
@@ -0,0 +1,3 @@
+Estás pagando dos productos en una tienda en línea: el primero cuesta 0.1 rublos, el segundo — 0.2 rublos. El programa de caja debe verificar la precisión de los cálculos: restar los 0.3 rublos esperados del total.
+
+Calcula e imprime esta diferencia. Esperas ver cero, pero PHP mostrará algo interesante.
diff --git a/modules/20-arithmetics/43-float/es/README.md b/modules/20-arithmetics/43-float/es/README.md
new file mode 100644
index 00000000..987069ea
--- /dev/null
+++ b/modules/20-arithmetics/43-float/es/README.md
@@ -0,0 +1,54 @@
+En matemáticas hay diferentes tipos de números. Por ejemplo:
+
+- Naturales: números enteros positivos: 1, 2, 3, etc.
+- Racionales: números fraccionarios que se pueden representar como una división, por ejemplo: 0.5, 1.75, 3.14.
+
+Desde el punto de vista de las matemáticas, todo es simple. Pero desde el punto de vista de la computadora, entre estos tipos de números hay un verdadero abismo. Intenta resolver mentalmente: ¿cuánto es `0.2` + `0.1`? Obviamente, `0.3`. PHP mostrará lo mismo al imprimir:
+
+```php
+<?php
+
+print_r(0.1 + 0.2); // => 0.3
+```
+
+Todo parece estar bien. Pero hagamos una comprobación: restemos 0.3 de esta suma. Matemáticamente, el resultado debería ser exactamente cero. Esto es lo que dice PHP:
+
+```php
+<?php
+
+print_r(0.1 + 0.2 - 0.3); // => 5.5511151231258E-17
+```
+
+En lugar de cero obtenemos una pequeña «cola»: un número en notación exponencial, aproximadamente igual a 0.000000000000000055. La cuestión es que internamente PHP no almacena exactamente 0.3, sino una aproximación de 0.30000000000000004. Al imprimir, el número se redondea a 14 dígitos significativos, por lo que el error no es visible. Pero no desaparece de los cálculos.
+
+## ¿Por qué sucede esto?
+
+Este comportamiento es típico de Python, JavaScript y la mayoría de los demás lenguajes de programación.
+
+La razón está en el funcionamiento de la computadora. Una computadora trabaja con memoria limitada, mientras que los números racionales son infinitamente precisos. Entre 0.1 y 0.2 se pueden colocar infinitos números. Pero la computadora no puede almacenar el infinito. Aproxima el número, tratando de ajustarlo a la cantidad de bits disponible.
+
+Estos valores aproximados se llaman números de punto flotante (floating point numbers). Su almacenamiento y los cálculos con ellos siguen reglas estrictas descritas en un estándar especial, IEEE 754, en el que se basan la mayoría de los lenguajes de programación.
+
+## Cuándo aparecen estos números
+
+Los números de punto flotante aparecen en los programas con más frecuencia de lo que parece. Estos son los casos principales:
+
+- Cuando escribes explícitamente un número fraccionario, por ejemplo 0.1, 2.5, 3.14.
+- Cuando realizas una división con resultado fraccionario:
+
+```php
+<?php
+
+print_r(1 / 2); // => 0.5
+print_r(2 / 3); // => 0.66666666666667
+```
+
+Incluso si el resultado parece «bonito», internamente sigue representado como un valor aproximado. Algunas fracciones, como 1 / 3, no pueden representarse exactamente en el sistema binario, por lo que su precisión siempre es limitada.
+
+## Dónde es crítico y cómo se trabaja con esto
+
+Normalmente, un pequeño error no molesta. Pero en cálculos financieros, tareas científicas y de ingeniería, así como en la comparación exacta de resultados, puede convertirse en un problema. En los programas reales, el dinero a menudo se almacena en unidades mínimas, por ejemplo en centavos, es decir, se usan números enteros en lugar de fraccionarios. En otros casos, el resultado se redondea a la cantidad necesaria de dígitos, los números se comparan con un margen de error aceptable o se usan tipos de datos y bibliotecas especiales para cálculos exactos.
+
+## Qué hay que recordar
+
+Las operaciones con números de punto flotante no siempre son exactas, y esto es normal. PHP redondea los números al imprimir, por lo que el error no siempre es visible en la pantalla, pero está presente en los cálculos. La precisión se puede controlar, por ejemplo, mediante el redondeo o la comparación de números con un margen de error dado. Al trabajar con dinero, mediciones precisas o cálculos científicos, es mejor usar tipos de datos especiales que proporcionen control sobre la precisión.
diff --git a/modules/20-arithmetics/43-float/es/data.yml b/modules/20-arithmetics/43-float/es/data.yml
new file mode 100644
index 00000000..a54d5e6e
--- /dev/null
+++ b/modules/20-arithmetics/43-float/es/data.yml
@@ -0,0 +1,10 @@
+---
+name: Números de punto flotante
+tips:
+  - >
+    [Lo que todo informático debe saber sobre la aritmética de punto
+    flotante](https://www.validlab.com/goldberg/paper.pdf)
+definitions:
+  - name: Número racional
+    description: |
+      un número que se puede representar como una fracción común.
diff --git a/modules/20-arithmetics/43-float/ru/EXERCISE.md b/modules/20-arithmetics/43-float/ru/EXERCISE.md
new file mode 100644
index 00000000..21d2431a
--- /dev/null
+++ b/modules/20-arithmetics/43-float/ru/EXERCISE.md
@@ -0,0 +1,3 @@
+Вы оплачиваете два товара в интернет-магазине: первый стоит 0.1 рубля, второй — 0.2 рубля. Кассовая программа должна проверить точность расчетов: вычесть из итоговой суммы ожидаемые 0.3 рубля.
+
+Рассчитайте и выведите эту разницу. Ожидаете увидеть ноль — но PHP выдаст кое-что интересное.
diff --git a/modules/20-arithmetics/43-float/ru/README.md b/modules/20-arithmetics/43-float/ru/README.md
new file mode 100644
index 00000000..9e268c21
--- /dev/null
+++ b/modules/20-arithmetics/43-float/ru/README.md
@@ -0,0 +1,63 @@
+В математике есть разные типы чисел. Например:
+
+- Натуральные: целые положительные числа: 1, 2, 3 и т.д.
+- Рациональные: дробные числа, которые можно представить в виде деления, например: 0.5, 1.75, 3.14.
+
+С точки зрения математики все просто. Но с точки зрения компьютера между этими типами чисел лежит настоящая пропасть. Попробуйте мысленно решить: сколько будет `0.2` + `0.1`? Очевидно, `0.3`. PHP при выводе покажет то же самое:
+
+```php
+<?php
+
+print_r(0.1 + 0.2); // => 0.3
+```
+
+Кажется, все в порядке. Но проведем проверку: вычтем из этой суммы 0.3. Математически должен получиться ровно ноль. А вот что скажет PHP:
+
+```php
+<?php
+
+print_r(0.1 + 0.2 - 0.3); // => 5.5511151231258E-17
+```
+
+Вместо нуля мы получаем крошечный «хвостик» — число в экспоненциальной записи, равное примерно 0.000000000000000055. Дело в том, что внутри PHP хранит не ровно 0.3, а приближение 0.30000000000000004. При выводе число округляется до 14 значащих цифр, поэтому погрешность не видна. Но в самих вычислениях она никуда не девается.
+
+```text
+Ожидание:   0.1 + 0.2        →  0.3
+Реальность: 0.1 + 0.2        →  0.30000000000000004
+                                    └── погрешность хранения
+Проверка:   0.1 + 0.2 - 0.3  →  5.5511151231258E-17 (а не 0)
+```
+
+## Почему так происходит?
+
+Такое поведение характерно для Python, JavaScript и большинства других языков программирования.
+
+Причина в устройстве компьютера. Компьютер работает с ограниченной памятью, тогда как рациональные числа бесконечно точны. Между 0.1 и 0.2 можно поместить бесконечно много других чисел. Но компьютер не может хранить бесконечность. Он приближает число, стараясь уместить его в доступное количество бит.
+
+Такие приближенные значения называются числами с плавающей точкой (floating point numbers). Хранение и вычисления с ними подчиняются строгим правилам, описанным в специальном стандарте IEEE 754, на который ориентируются большинство языков программирования.
+
+## Когда появляются такие числа
+
+Числа с плавающей точкой появляются в программах чаще, чем может показаться. Вот основные случаи:
+
+- Когда вы явно пишете дробное число, например 0.1, 2.5, 3.14.
+- Когда выполняете деление с дробным результатом:
+
+```php
+<?php
+
+print_r(1 / 2); // => 0.5
+print_r(2 / 3); // => 0.66666666666667
+```
+
+Даже если результат кажется «красивым», внутри он все равно представлен в виде приближенного значения. Некоторые дроби, такие как 1 / 3, вообще не могут быть точно представлены в двоичной системе, поэтому их точность всегда ограничена.
+
+## Где это критично и как с этим работают
+
+Обычно небольшая погрешность не мешает. Но в финансовых расчетах, научных и инженерных задачах, а также при точном сравнении результатов она может стать проблемой. Например, ошибка в доли копейки способна дать неправильную итоговую сумму, а длинная цепочка вычислений может постепенно накапливать неточность.
+
+В реальных программах с этим работают по-разному. Деньги часто хранят в минимальных единицах, например в копейках, то есть используют целые числа вместо дробных. В других случаях результат округляют до нужного количества знаков, сравнивают числа с допустимой погрешностью или используют специальные типы данных и библиотеки для точных вычислений.
+
+## Что нужно запомнить
+
+Операции с числами с плавающей точкой не всегда точны, и это нормально. Такое поведение характерно для большинства языков программирования и объясняется устройством компьютерной памяти. PHP при выводе округляет числа, поэтому погрешность не всегда видна на экране — но в вычислениях она присутствует. Точность можно контролировать, например с помощью округления или сравнения чисел с заданной погрешностью. А при работе с деньгами, точными измерениями или научными расчетами лучше использовать специальные типы данных, которые обеспечивают контроль над точностью.
diff --git a/modules/20-arithmetics/43-float/ru/data.yml b/modules/20-arithmetics/43-float/ru/data.yml
new file mode 100644
index 00000000..5886c55a
--- /dev/null
+++ b/modules/20-arithmetics/43-float/ru/data.yml
@@ -0,0 +1,10 @@
+---
+name: Числа с плавающей точкой
+tips:
+  - >
+    [Что нужно знать про арифметику с плавающей
+    запятой](https://habr.com/ru/articles/112953/)
+definitions:
+  - name: Рациональное число
+    description: |
+      число, которое можно представить в виде обыкновенной дроби.
diff --git a/modules/20-arithmetics/45-linting/index.php b/modules/20-arithmetics/45-linting/Solution.php
similarity index 100%
rename from modules/20-arithmetics/45-linting/index.php
rename to modules/20-arithmetics/45-linting/Solution.php
diff --git a/modules/20-arithmetics/45-linting/SolutionTest.php b/modules/20-arithmetics/45-linting/SolutionTest.php
index 9a51fb7e..b8bfb7bd 100644
--- a/modules/20-arithmetics/45-linting/SolutionTest.php
+++ b/modules/20-arithmetics/45-linting/SolutionTest.php
@@ -2,9 +2,7 @@
 
 namespace HexletBasics\Arithmetics\Linting;
 
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
@@ -12,6 +10,5 @@ public function test()
     {
         $expected = '4';
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/20-arithmetics/45-linting/ru/EXERCISE.md b/modules/20-arithmetics/45-linting/ru/EXERCISE.md
index 953edd5c..aff6d004 100644
--- a/modules/20-arithmetics/45-linting/ru/EXERCISE.md
+++ b/modules/20-arithmetics/45-linting/ru/EXERCISE.md
@@ -1 +1,9 @@
-Выведите на экран результат следующего вычисления: «разница между пятью в квадрате и произведением трёх и семи». Напишите код так, чтобы каждый оператор отделялся от операндов пробелами.
+Вы получили код от коллеги — он работает правильно, но нарушает стандарт оформления PSR-12. Исправьте пробелы вокруг операторов, не меняя логику:
+
+```php
+<?php
+
+print_r(    (5  **2)-(3*  7));
+```
+
+Результат должен остаться `4`.
diff --git a/modules/20-arithmetics/45-linting/ru/README.md b/modules/20-arithmetics/45-linting/ru/README.md
index 6b52622b..acb541ab 100644
--- a/modules/20-arithmetics/45-linting/ru/README.md
+++ b/modules/20-arithmetics/45-linting/ru/README.md
@@ -1,8 +1,8 @@
-В этом уроке мы узнаем, что такое стандарты по написанию кода. Они облегчают разработку и делают код более понятным. Мы подробнее разберем две основные рекомендации по PHP, которые содержат правила по написанию кода.
+Когда разные разработчики пишут код в разном стиле, код становится трудночитаемым: где-то пробел лишний, где-то отступы разные. Чтобы избежать разногласий, программисты договорились соблюдать единый стиль кодирования. Этот свод правил описывает, как должен выглядеть код: расстановку пробелов, оформление функций и названия переменных.
 
-## Стандарты по написанию кода в PHP
+Единый стиль означает код, одинаково понятный всем членам команды, независимо от того, кто его написал. Это экономит время, снижает количество ошибок и упрощает совместную работу.
 
-Код нужно оформлять так, чтобы он был понятным и простым в поддержке. Для этого существуют специальные наборы правил — **стандарты**. Они описывают различные аспекты написания кода.
+## Стандарты кодирования
 
 В PHP самыми распространенными являются стандарты **PSR** — PHP Standards Recommendations или стандартные рекомендации PHP от [PHP-FIG](https://www.php-fig.org/psr/). Это набор правил, которые облегчают разработку и решают определенную проблему.
 
@@ -12,11 +12,49 @@
 * PSR-1. [Basic Coding Standard](https://www.php-fig.org/psr/psr-1/) — базовый стандарт написания кода. Это набор правил, которые определяют, как следует оформлять программный код: как писать теги PHP, по каким правилам именовать классы, методы и константы классов. Он также затрагивает вопросы кодировки, автозагрузки, пространства имен и разделения ответственности между файлами
 * PSR-12. [Extended Coding Style](https://www.php-fig.org/psr/psr-12/) — расширенный стандарт стиля кодирования, заменяет и дополняет устаревший PSR-2. Этот стандарт требует выполнения правил PSR-1. Также он добавляет множество новых требований: к отступам, файлам, строкам, ключевым словам, классам, управляющим конструкциям, области видимости и другим элементам
 
-## Линтеры в PHP
+Эти стандарты знают и используют все PHP-разработчики. Новичкам полезно время от времени заглядывать в них и вырабатывать правильные привычки с самого начала. Однако запоминать все сразу нет необходимости.
 
-В любом языке программирования существуют специальные инструменты — **линтеры**. Они проверяют код на соответствие стандартам. Повсеместно используемым линтером в PHP является [PHP_CodeSniffer](https://github.com/PHPCSStandards/PHP_CodeSniffer).
+## Линтеры: автоматическая проверка кода
 
-Допустим, у нас есть файл с таким PHP-кодом:
+Запоминать все правила вручную не нужно. Существуют специальные программы, которые делают это за вас. Они называются линтеры.
+
+Линтер представляет собой инструмент, который анализирует ваш код и сообщает о нарушениях стандартов. Он помогает:
+
+- Избавиться от лишних пробелов
+- Соблюдать отступы
+- Писать читаемые и красивые выражения
+
+В мире PHP широко используются два инструмента: [PHP_CodeSniffer](https://github.com/PHPCSStandards/PHP_CodeSniffer), который проверяет код на соответствие стандартам, и [PHP CS Fixer](https://github.com/PHP-CS-Fixer/PHP-CS-Fixer), который умеет не только находить нарушения, но и исправлять их автоматически. В этом курсе используется PHP CS Fixer.
+
+Рассмотрим пример:
+
+```php
+<?php
+
+print_r(1+ 3);
+```
+
+Такой код выглядит неаккуратно, и линтер справедливо укажет на ошибку. Вот как выглядит процесс проверки:
+
+```text
+Код               Линтер             Результат
+┌────────────┐    ┌──────────────┐    ┌──────────────────────┐
+│ print_r(   │ →  │ PHP CS Fixer │ →  │ binary_operator_     │
+│   1+ 3)    │    │              │    │ spaces               │
+└────────────┘    └──────────────┘    └──────────────────────┘
+```
+
+Это значит, что перед и после `+` не хватает пробелов. Согласно стандарту, должно быть так:
+
+```php
+<?php
+
+print_r(1 + 3);
+```
+
+## Правила и их смысл
+
+Каждое сообщение линтера связано с конкретным правилом. Допустим, у нас есть файл с таким PHP-кодом:
 
 ```php
 <?php
@@ -41,4 +79,8 @@
 print_r(((8 / 2) + 5) - (-3 / 2)); // => 10.5
 ```
 
-Этот вариант уже не нарушает правил, и линтер будет «молчать».
+Этот вариант уже не нарушает правил, и линтер будет «молчать». Когда вы только начинаете, такие мелочи могут казаться неважными. Но со временем становится понятно, что именно они формируют единый читаемый стиль.
+
+## Использование линтера в своих проектах
+
+Когда вы начнете писать собственные проекты за пределами учебной платформы, линтер будет незаменимым помощником. Его можно настроить в любом редакторе кода, запустить в терминале или подключить к сборке проекта. Линтер показывает ошибки, а PHP CS Fixer умеет и исправлять их автоматически.
diff --git a/modules/20-arithmetics/45-linting/ru/data.yml b/modules/20-arithmetics/45-linting/ru/data.yml
index 2dd0d71d..9725e2e8 100644
--- a/modules/20-arithmetics/45-linting/ru/data.yml
+++ b/modules/20-arithmetics/45-linting/ru/data.yml
@@ -1,3 +1,7 @@
 ---
 name: Линтер
-tips: []
+tips:
+  - |
+    [PSR-12](https://www.php-fig.org/psr/psr-12/)
+  - |
+    [PHP CS Fixer](https://github.com/PHP-CS-Fixer/PHP-CS-Fixer)
diff --git a/modules/25-strings/10-quotes/Solution.php b/modules/25-strings/10-quotes/Solution.php
new file mode 100644
index 00000000..ed6e6303
--- /dev/null
+++ b/modules/25-strings/10-quotes/Solution.php
@@ -0,0 +1,5 @@
+<?php
+
+// BEGIN
+print_r('The file "user\'s_config.json" was not found.');
+// END
diff --git a/modules/25-strings/10-quotes/SolutionTest.php b/modules/25-strings/10-quotes/SolutionTest.php
index ba54f2d0..5aaa69b7 100644
--- a/modules/25-strings/10-quotes/SolutionTest.php
+++ b/modules/25-strings/10-quotes/SolutionTest.php
@@ -2,16 +2,13 @@
 
 namespace HexletBasics\Strings\Quotes;
 
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        $expected = "\"Khal Drogo's favorite word is \"athjahakar\"\"";
+        $expected = 'The file "user\'s_config.json" was not found.';
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/25-strings/10-quotes/index.php b/modules/25-strings/10-quotes/index.php
deleted file mode 100644
index 12b5a98a..00000000
--- a/modules/25-strings/10-quotes/index.php
+++ /dev/null
@@ -1,5 +0,0 @@
-<?php
-
-// BEGIN
-print_r('"Khal Drogo\'s favorite word is "athjahakar""');
-// END
diff --git a/modules/25-strings/10-quotes/ru/EXERCISE.md b/modules/25-strings/10-quotes/ru/EXERCISE.md
index 55fcb568..0ad2855a 100644
--- a/modules/25-strings/10-quotes/ru/EXERCISE.md
+++ b/modules/25-strings/10-quotes/ru/EXERCISE.md
@@ -1,11 +1,7 @@
-Напишите программу, которая выведет на экран:
+Программа не нашла нужный файл и вывела сообщение с его названием. Напишите программу, которая выводит то же самое сообщение:
 
 ```text
-"Khal Drogo's favorite word is "athjahakar""
+The file "user's_config.json" was not found.
 ```
 
-Программа должна вывести на экран эту фразу в точности. Обратите внимание на кавычки в начале и в конце фразы:
-
-```text
-"Khal Drogo's favorite word is "athjahakar""
-```
+Строка содержит и апостроф, и двойные кавычки — выберите подходящий способ их записи.
diff --git a/modules/25-strings/10-quotes/ru/README.md b/modules/25-strings/10-quotes/ru/README.md
index 8d2321d5..ee87503b 100644
--- a/modules/25-strings/10-quotes/ru/README.md
+++ b/modules/25-strings/10-quotes/ru/README.md
@@ -1,8 +1,8 @@
-В этом уроке мы разберем, что такое строки, зачем для них нужны одинарные и двойные кавычки. Также узнаем, что такое экранирующие последовательности и конкатенация.
+Строки в программировании используются очень часто и в самых разных ситуациях. С их помощью мы работаем с текстом, выводим сообщения на экран, обрабатываем пользовательский ввод и взаимодействуем с внешними системами.
 
-## Что такое строка
+![Строки](./assets/strings.png)
 
-Любой одиночный символ в кавычках — это **строка**. Например:
+С точки зрения PHP строка представляет собой просто набор символов, заключенный в кавычки. Посмотрим на примеры:
 
 ```php
 <?php
@@ -14,21 +14,61 @@
 ''
 ```
 
-Пустая строка `''` — это тоже строка. То есть строкой мы считаем все, что находится внутри кавычек, даже если это пробел, один символ или вообще отсутствие символов.
+Все эти варианты являются строками.
 
-Ранее в уроках мы записывали строки в одинарных кавычках, но можно использовать и двойные:
+- `'Hello'`, `'Goodbye'` и `'G'` представляют собой строки из нескольких или одного символа
+- `' '` является строкой, состоящей из одного пробела
+- `''` является пустой строкой, в ней нет ни одного символа. Играет такую же роль, как 0 в математике
+
+То есть все, что находится внутри кавычек, считается строкой, даже если там только пробел или вообще ничего нет.
+
+Если вывести строки на экран, то `'Hello'` и `'Goodbye'` будут хорошо заметны. Но `' '` и `''` могут сбивать с толку, потому что вывод пустой строки выглядит как полное отсутствие, а строка с пробелом покажет «пустое место», которое визуально сложно отличить. При этом PHP четко различает их. Пустая строка означает отсутствие символов, тогда как строка с пробелом содержит конкретный символ пробела.
+
+Контрольный вопрос. Это одинаковые строки или нет?
 
 ```php
 <?php
 
-print_r("Dracarys!");
+'хекслет'
+' хекслет'
 ```
 
-Разберем, почему у обозначения строки есть два способа.
+## Терминология. Строка или строчка?
 
-## Зачем нужны двойные кавычки
+В программировании есть терминологическая ловушка.
 
-Представим, что нам нужно напечатать строчку ``dragon's mother``. Апостроф перед буквой **s** — это такой же символ, как одинарная кавычка. Попробуем:
+- Строка (string) является типом данных (то что разбирали выше), например `'hello'`.
+- Строчка (line) является строкой текста в файле или в коде.
+
+Например, в коде ниже есть строчка, но не строка.
+
+```php
+<?php
+
+print_r(5);
+```
+
+Чтобы избежать путаницы, в этом курсе мы будем использовать такие формулировки.
+
+- Строка, когда говорим о типе данных.
+- Строчка, когда речь идет о строках кода.
+
+## Одинарные и двойные кавычки
+
+В PHP строки можно записывать как в одинарных, так и в двойных кавычках:
+
+```php
+<?php
+
+print_r('Hello');
+print_r("Hello");
+```
+
+По умолчанию принято использовать одинарные кавычки `'`, если внутри строки не нужны возможности двойных. Этого стиля придерживаются многие стандарты оформления PHP-кода.
+
+## Проблема с кавычками внутри строки
+
+Представьте, что вы хотите напечатать строку *Dragon's mother*. В ней есть апостроф (*'s*), совпадающий с символом одинарной кавычки. Попробуем так:
 
 ```php
 <?php
@@ -37,9 +77,7 @@ print_r('Dragon's mother');
 // PHP Parse error: syntax error, unexpected 's' (T_STRING), expecting ',' or ')'
 ```
 
-Такая программа не будет работать. С точки зрения PHP строчка началась с одинарной кавычки, а потом закончилась после буквы **n**. Дальше были символы `s mother` без кавычек — значит, это не строка. А потом была одна открывающая строку кавычка, которая так и не закрылась: `');`. Этот код синтаксически некорректен.
-
-Здесь помогут двойные кавычки. Такой вариант программы отработает корректно:
+PHP решит, что строка заканчивается после слова 'Dragon', а остальное не распознает как валидный код, что вызовет синтаксическую ошибку. Чтобы избежать этого, обернем строку в двойные кавычки:
 
 ```php
 <?php
@@ -47,41 +85,47 @@ print_r('Dragon's mother');
 print_r("Dragon's mother");
 ```
 
-Теперь интерпретатор знает, что строка началась с двойной кавычки, значит, завершиться должна на двойной кавычке. А одинарная кавычка внутри стала частью строки.
+Теперь PHP понимает, что одинарная кавычка внутри строки является обычным символом, а сама строка начинается и заканчивается двойными кавычками.
+
+Если внутри строки нужны двойные кавычки, а снаружи одинарные, проблем тоже не будет:
+
+```php
+<?php
 
-Верно и обратное. Если внутри строки мы хотим использовать двойные кавычки, то саму строку надо делать в одинарных. Причем количество кавычек внутри самой строки неважно.
+print_r('He said "No"');
+```
 
-Теперь представим, что мы хотим создать такую строку:
+Иногда в строке встречаются оба типа кавычек:
 
 ```text
 Dragon's mother said "No"
 ```
 
-В ней есть и одинарные, и двойные кавычки. В этой ситуации нужно указать интерпретатору, что нужно считать каждую кавычку частью строки, а не началом или концом.
-
-Для этого **экранируют** специальные символы. В нашем случае это символ, который является признаком конца и начала строки, — либо одинарная кавычка, либо двойная, в зависимости от ситуации. Для экранирования используется обратный слеш `\`.
+В этом случае чтобы PHP не спутал кавычки внутри строки с внешними, используют символ экранирования, обратный слеш `\`. Он говорит интерпретатору, что следующий за ним символ является частью строки, а не управляющим символом:
 
 ```php
 <?php
 
-// Экранируется только ", так как в этой ситуации
-// двойные кавычки имеют специальное значение
 print_r("Dragon's mother said \"No\"");
 // => Dragon's mother said "No"
 ```
 
-Нам нужно было добавить `\` для двойных кавычек, но не для апострофа, потому что сама строка создана с двойными кавычками. Если бы строка создавалась с одинарными кавычками, то символ экранирования нужен был бы перед апострофом, но не перед двойными кавычками.
+Здесь мы экранируем двойные кавычки внутри строки, заключенной в двойные кавычки.
+
+Обратите внимание, PHP воспринимает `\"` как один символ-кавычку, а не два символа. То же самое касается `\'`, `\\` и других подобных последовательностей. Они выглядят как два символа в коде, но в строке считаются за один.
+
+То же самое работает и в обратном случае:
 
 ```php
 <?php
 
-// \ выводится, если после него идет обычный,
-// а не специальный символ
-print_r("Death is \so terribly final");
-// => Death is \so terribly final
+print_r('Dragon\'s mother said "No"');
+// => Dragon's mother said "No"
 ```
 
-Также нам может понадобиться вывести сам обратный слеш:
+## Как вывести обратный слеш
+
+Чтобы вывести сам обратный слеш, его тоже нужно экранировать:
 
 ```php
 <?php
@@ -89,5 +133,3 @@ print_r("Death is \so terribly final");
 print_r("\\");
 // => \
 ```
-
-Это тоже можно сделать через экранирование, но уже самого себя.
diff --git a/modules/25-strings/10-quotes/ru/assets/strings.png b/modules/25-strings/10-quotes/ru/assets/strings.png
new file mode 100644
index 00000000..4cce3286
Binary files /dev/null and b/modules/25-strings/10-quotes/ru/assets/strings.png differ
diff --git a/modules/25-strings/10-quotes/ru/data.yml b/modules/25-strings/10-quotes/ru/data.yml
index e8d8642b..05a961ab 100644
--- a/modules/25-strings/10-quotes/ru/data.yml
+++ b/modules/25-strings/10-quotes/ru/data.yml
@@ -1,3 +1,5 @@
 ---
 name: Кавычки
-tips: []
+tips:
+  - >
+    [Строки в PHP](https://www.php.net/manual/ru/language.types.string.php)
diff --git a/modules/25-strings/15-escape-characters/Solution.php b/modules/25-strings/15-escape-characters/Solution.php
new file mode 100644
index 00000000..24c8ea71
--- /dev/null
+++ b/modules/25-strings/15-escape-characters/Solution.php
@@ -0,0 +1,5 @@
+<?php
+
+// BEGIN
+print_r("Для разделения строк используйте \"\\n\"\nПример: print_r(\"строка1\\nстрока2\")");
+// END
diff --git a/modules/25-strings/15-escape-characters/SolutionTest.php b/modules/25-strings/15-escape-characters/SolutionTest.php
index 50646bec..c7993076 100644
--- a/modules/25-strings/15-escape-characters/SolutionTest.php
+++ b/modules/25-strings/15-escape-characters/SolutionTest.php
@@ -1,17 +1,14 @@
 <?php
 
-namespace HexletBasics\Arithmetics\EscapeCharacters;
+namespace HexletBasics\Strings\EscapeCharacters;
 
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        $expected = "- Did Joffrey agree?\n- He did. He also said \"I love using \\n\".";
+        $expected = "Для разделения строк используйте \"\\n\"\nПример: print_r(\"строка1\\nстрока2\")";
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/25-strings/15-escape-characters/index.php b/modules/25-strings/15-escape-characters/index.php
deleted file mode 100644
index 7087d669..00000000
--- a/modules/25-strings/15-escape-characters/index.php
+++ /dev/null
@@ -1,5 +0,0 @@
-<?php
-
-// BEGIN
-print_r("- Did Joffrey agree?\n- He did. He also said \"I love using \\n\".");
-// END
diff --git a/modules/25-strings/15-escape-characters/ru/EXERCISE.md b/modules/25-strings/15-escape-characters/ru/EXERCISE.md
index 04d13cf4..919f88b2 100644
--- a/modules/25-strings/15-escape-characters/ru/EXERCISE.md
+++ b/modules/25-strings/15-escape-characters/ru/EXERCISE.md
@@ -1,5 +1,8 @@
-Напишите программу, которая выводит на экран:
+Вы пишете программу, которая показывает пользователю подсказку о том, как разбить текст на строки. Выведите подсказку одним вызовом `print_r()`:
 
-    - Did Joffrey agree?
-    - He did. He also said "I love using \n".
-При этом программа использует только один `print_r()`, но результат на экране должен выглядеть в точности как показано выше.
+```text
+Для разделения строк используйте "\n"
+Пример: print_r("строка1\nстрока2")
+```
+
+Обратите внимание: `\n` в первой строке — это буквальный текст, а не перевод строки.
diff --git a/modules/25-strings/15-escape-characters/ru/README.md b/modules/25-strings/15-escape-characters/ru/README.md
index 91c28914..f7a433bf 100644
--- a/modules/25-strings/15-escape-characters/ru/README.md
+++ b/modules/25-strings/15-escape-characters/ru/README.md
@@ -1,41 +1,143 @@
-Иногда нам необходимо расположить несколько строк друг за другом. Для этого нужно сказать интерпретатору «нажать на энтер» — сделать перевод строки после вопросительного знака. Это можно сделать с помощью символа перевода строки — `\n`:
+Допустим, мы хотим вывести текст ниже в две строчки:
+
+```text
+- Are you hungry?
+- Aaaarrrgh!
+```
+
+Если мы просто передадим этот текст в `print_r()`, то PHP напечатает все в одну строчку. Технически можно написать два подряд идущих `print_r()`, но представим, что мы хотим это сделать с помощью одного:
 
 ```php
 <?php
 
-print_r("- Are you hungry?\n- Aaaarrrgh!");
+print_r("- Are you hungry?- Aaaarrrgh!");
+// => - Are you hungry?- Aaaarrrgh!
 ```
 
+Чтобы каждая из них начиналась с новой строки, нужно добавить перевод строки, то есть «нажать Enter». В программировании это реализуется через добавление специальных символов, в данном случае `\n`. Да, это не опечатка. Несмотря на то, что мы видим здесь два символа, с точки зрения PHP это один символ:
 
-Результат:
+```php
+<?php
+
+print_r("- Are you hungry?\n- Aaaarrrgh!");
+```
+
+Результат будет таким:
 
 ```text
 - Are you hungry?
 - Aaaarrrgh!
 ```
 
-`\n` — это специальный символ. В литературе его часто обозначают как *LF* (Line Feed). С точки зрения компьютера — это один невидимый символ перевода строки:
+## Что такое `\n`?
+
+`\n` является управляющей последовательностью (англ. escape sequence, иногда говорят «экранированная последовательность»). Она обозначает перевод строки, но не отображается напрямую. Вы не увидите `\n` в выводе программы, так как она влияет только на расположение текста.
+
+В текстовых редакторах при нажатии Enter добавляется невидимый символ LF (Line Feed). Именно его и означает `\n`. Иногда такие символы можно увидеть, если включить отображение спецсимволов:
+
+```text
+- Привет!¶
+- О, привет!¶
+- Как дела?
+```
+
+Принтеры, редакторы и интерпретатор PHP понимают `\n` как команду начать текст с новой строки.
+
+Важная особенность PHP: управляющие последовательности вроде `\n` работают только внутри двойных кавычек. В одинарных кавычках `\n` — это просто два обычных символа, `\` и `n`:
+
+```php
+<?php
+
+print_r("Hello\nWorld");
+// Hello
+// World
+
+print_r('Hello\nWorld');
+// => Hello\nWorld
+```
+
+## Примеры использования `\n`
+
+Вот как PHP обрабатывает управляющую последовательность `\n`:
+
+```text
+В коде       "Hello\nWorld"
+                   ↓
+На экране    Hello
+             World
+```
+
+Местоположение `\n` меняет итоговый вывод:
 
 ```php
 <?php
 
-// Мы это не изучали, но вы должны знать правду
-// Ниже код, который возвращает длину строки
-strlen("a");    // 1
-strlen("\n");   // 1 !!!
-strlen("\n\n"); // 2 !!!
+print_r("Hello\nWorld");
+// Hello
+// World
+
+print_r("Hello \nWorld");
+// Hello
+// World  (в конце первой строки есть пробел)
+
+print_r("Hello\n World");
+// Hello
+//  World  (во второй строке в начале пробел)
+
+print_r("Hello\n\nWorld");
+// Hello
+//
+// World  (пустая строка между ними)
 ```
 
-`\n` — это способ записать символ перевода строки, но сам перевод строки — это один невидимый символ. Так как количество знаков на клавиатуре ограничено и отдано под самые важные, то все специальные символы реализуются в виде таких обозначений.
+Пробелы до или после `\n` также учитываются. PHP воспринимает их как обычные символы и отображает в выводе.
+
+Вы также можете вставлять `\n` в любую часть строки — до, после или даже использовать отдельно:
+
+```php
+<?php
+
+print_r("First line\n");
+print_r("\n"); // Просто пустая строчка
+print_r("Second line");
+```
+
+Результат будет таким:
+
+```text
+First line
+
+Second line
+```
+
+## Как вывести сам символ `\n`
+
+`\n` в PHP является управляющей последовательностью. Она управляет расположением текста и не выводится на экран как обычные символы. Если вам нужно вывести именно символы `\` и `n`, а не перевод строки, их нужно экранировать. Для этого перед обратным слешем добавляют еще один слеш:
+
+```php
+<?php
+
+print_r("Hello\\nWorld");
+// => Hello\nWorld
+
+// Если забыть указать второй слеш
+print_r("Hello\nWorld");
+// Hello
+// World
+```
 
-Символ перевода строки не является специфичным для программирования. Во многих редакторах есть опция, которая позволяет включить отображение невидимых символов. С ее помощью можно понять, где они находятся. Хотя это всего лишь схематичное отображение, у этих символов нет графического представления, они невидимые.
+В этом случае PHP понимает `\\` как обычный обратный слеш и показывает строку без перевода строки.
 
-`\n` — это пример **экранирующей последовательности** (escape sequence). Их еще называют управляющими конструкциями. Таких символов не один десяток, но в программировании часто встречаются всего несколько. Программистам часто нужно использовать перевод строки `\n` для правильного форматирования текста.
+## Другие управляющие последовательности
 
-Экранирующие последовательности вроде `\n` работают только внутри двойных кавычек.
+Кроме `\n`, в PHP есть и другие управляющие последовательности:
 
-Если нам понадобится вывести `\n` именно как текст, то можно воспользоваться уже известным нам способом экранирования — добавить еще один `\` в начале. В итоге последовательность `\\n` отобразится как символы `\` и `n`, которые идут друг за другом.
+- `\t` обозначает табуляцию (эквивалент клавиши Tab)
+- `\r` обозначает возврат каретки (используется в Windows, но редко применяется в PHP-коде)
+- В программировании чаще всего используют именно `\n`, его достаточно для большинства задач
 
-В Windows для перевода строк по умолчанию используется `\r\n`. Такая комбинация хорошо работает только в Windows, но создает проблемы при переносе в другие системы. Например, когда в команде разработчиков есть пользователи как Windows, так и Linux.
+## Важные детали
 
-Последовательность `\r\n` имеет разную трактовку в зависимости от выбранной кодировки. Это мы рассмотрим позже. По этой причине в среде разработчиков принято всегда использовать `\n` без `\r`, так как LF всегда трактуется одинаково и отлично работает в любой системе. Поэтому нужно настроить свой редактор на использование `\n`.
+- `\n` является одним символом, несмотря на то, что в коде он записан как два (`\` и `n`)
+- Управляющие последовательности в PHP работают только внутри двойных кавычек
+- На Windows по умолчанию используется комбинация `\r\n`, но в кроссплатформенной разработке принято использовать только `\n`, чтобы избежать проблем при переносе кода между системами. Поэтому стоит настроить свой редактор на использование `\n`
diff --git a/modules/25-strings/20-strings-concatenation/Makefile b/modules/25-strings/20-string-concatenation/Makefile
similarity index 100%
rename from modules/25-strings/20-strings-concatenation/Makefile
rename to modules/25-strings/20-string-concatenation/Makefile
diff --git a/modules/25-strings/20-string-concatenation/Solution.php b/modules/25-strings/20-string-concatenation/Solution.php
new file mode 100644
index 00000000..7cb12677
--- /dev/null
+++ b/modules/25-strings/20-string-concatenation/Solution.php
@@ -0,0 +1,5 @@
+<?php
+
+// BEGIN
+print_r('https://' . 'github.com' . '/' . 'hexlet' . '/' . 'exercises-php');
+// END
diff --git a/modules/25-strings/20-strings-concatenation/SolutionTest.php b/modules/25-strings/20-string-concatenation/SolutionTest.php
similarity index 53%
rename from modules/25-strings/20-strings-concatenation/SolutionTest.php
rename to modules/25-strings/20-string-concatenation/SolutionTest.php
index fbe2674b..a4ac3688 100644
--- a/modules/25-strings/20-strings-concatenation/SolutionTest.php
+++ b/modules/25-strings/20-string-concatenation/SolutionTest.php
@@ -2,16 +2,13 @@
 
 namespace HexletBasics\Strings\Concatenation;
 
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        $expected = 'Winter came for the House of Frey.';
+        $expected = 'https://github.com/hexlet/exercises-php';
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/25-strings/20-strings-concatenation/description.es.yml b/modules/25-strings/20-string-concatenation/description.es.yml
similarity index 100%
rename from modules/25-strings/20-strings-concatenation/description.es.yml
rename to modules/25-strings/20-string-concatenation/description.es.yml
diff --git a/modules/25-strings/20-strings-concatenation/en/EXERCISE.md b/modules/25-strings/20-string-concatenation/en/EXERCISE.md
similarity index 100%
rename from modules/25-strings/20-strings-concatenation/en/EXERCISE.md
rename to modules/25-strings/20-string-concatenation/en/EXERCISE.md
diff --git a/modules/25-strings/20-strings-concatenation/en/README.md b/modules/25-strings/20-string-concatenation/en/README.md
similarity index 100%
rename from modules/25-strings/20-strings-concatenation/en/README.md
rename to modules/25-strings/20-string-concatenation/en/README.md
diff --git a/modules/25-strings/20-strings-concatenation/en/data.yml b/modules/25-strings/20-string-concatenation/en/data.yml
similarity index 100%
rename from modules/25-strings/20-strings-concatenation/en/data.yml
rename to modules/25-strings/20-string-concatenation/en/data.yml
diff --git a/modules/25-strings/20-strings-concatenation/es/EXERCISE.md b/modules/25-strings/20-string-concatenation/es/EXERCISE.md
similarity index 100%
rename from modules/25-strings/20-strings-concatenation/es/EXERCISE.md
rename to modules/25-strings/20-string-concatenation/es/EXERCISE.md
diff --git a/modules/25-strings/20-strings-concatenation/es/README.md b/modules/25-strings/20-string-concatenation/es/README.md
similarity index 100%
rename from modules/25-strings/20-strings-concatenation/es/README.md
rename to modules/25-strings/20-string-concatenation/es/README.md
diff --git a/modules/25-strings/20-strings-concatenation/es/data.yml b/modules/25-strings/20-string-concatenation/es/data.yml
similarity index 100%
rename from modules/25-strings/20-strings-concatenation/es/data.yml
rename to modules/25-strings/20-string-concatenation/es/data.yml
diff --git a/modules/25-strings/20-string-concatenation/ru/EXERCISE.md b/modules/25-strings/20-string-concatenation/ru/EXERCISE.md
new file mode 100644
index 00000000..23290a99
--- /dev/null
+++ b/modules/25-strings/20-string-concatenation/ru/EXERCISE.md
@@ -0,0 +1,7 @@
+Сайт автоматически формирует ссылки на страницы пользователей, собирая их из отдельных частей. Соберите ссылку с помощью конкатенации и выведите на экран:
+
+```text
+https://github.com/hexlet/exercises-php
+```
+
+Каждый компонент URL — отдельная строка: протокол, домен, имя владельца, имя репозитория.
diff --git a/modules/25-strings/20-string-concatenation/ru/README.md b/modules/25-strings/20-string-concatenation/ru/README.md
new file mode 100644
index 00000000..7c977b6a
--- /dev/null
+++ b/modules/25-strings/20-string-concatenation/ru/README.md
@@ -0,0 +1,85 @@
+Часто строки нужно собирать из нескольких частей, например объединить имя и фамилию, добавить единицу измерения или составить текст из шаблона. Для этого используется операция конкатенации, то есть склеивания строк.
+
+## Как объединять строки
+
+В PHP строки объединяются с помощью оператора `.` (точка). Для сложения чисел используется оператор `+`, а для объединения строк в PHP существует отдельный бинарный оператор, который означает склеивание содержимого:
+
+```php
+<?php
+
+print_r('Dragon' . 'stone');
+// => Dragonstone
+```
+
+Порядок имеет значение. Сначала идет левая часть (`'Dragon'`), потом правая (`'stone'`). Результат получается в том порядке, в котором указаны операнды.
+
+Вот как работает объединение нескольких строк. Код:
+
+```php
+<?php
+
+print_r('Hello' . ', ' . 'World!');
+```
+
+Выполнение:
+
+```text
+'Hello' . ', ' . 'World!'
+└──┬──┘   └┬┘   └──┬───┘
+   └────┬───┘       │
+  'Hello, '    .  'World!'
+     └──────┬───────┘
+      'Hello, World!'
+```
+
+Примеры:
+
+```php
+<?php
+
+print_r('Kings' . 'wood');     // => Kingswood
+print_r('Kings' . 'road');     // => Kingsroad
+// Здесь снаружи двойные кавычки, потому что внутри есть одиночная
+print_r("King's" . 'Landing'); // => King'sLanding
+```
+
+PHP позволяет объединять строки, даже если они записаны в разных кавычках. Главное, чтобы обе части были строками.
+
+## Пробел тоже является символом
+
+При объединении PHP не вставляет пробелы автоматически. Если между частями должен быть пробел, его нужно указать вручную:
+
+```php
+<?php
+
+// Пробел в конце первой строки
+print_r("King's " . 'Landing'); // => King's Landing
+
+// Пробел в начале второй строки
+print_r("King's" . ' Landing'); // => King's Landing
+```
+
+Результат будет одинаковый. Но если пробел не добавить, то слова склеятся.
+
+## Управляющие последовательности
+
+В строках можно использовать управляющие последовательности, например `\n` для переноса строки или `\t` для табуляции. Не забывайте, что в PHP они работают только внутри двойных кавычек. При конкатенации они ведут себя так же, как и любые другие символы:
+
+```php
+<?php
+
+print_r('Hello,' . "\n" . 'World!');
+// =>
+// Hello,
+// World!
+
+print_r('A' . "\t" . 'B');
+// => A	B
+```
+
+## Заключение
+
+Конкатенация представляет собой объединение строк через оператор `.`, и строки можно объединять независимо от типа кавычек.
+
+- Склеивание происходит строго в порядке слева направо
+- Пробелы не добавляются автоматически, их нужно включать в строки вручную
diff --git a/modules/25-strings/20-strings-concatenation/ru/data.yml b/modules/25-strings/20-string-concatenation/ru/data.yml
similarity index 56%
rename from modules/25-strings/20-strings-concatenation/ru/data.yml
rename to modules/25-strings/20-string-concatenation/ru/data.yml
index 5b4c15a7..88fe3b7d 100644
--- a/modules/25-strings/20-strings-concatenation/ru/data.yml
+++ b/modules/25-strings/20-string-concatenation/ru/data.yml
@@ -1,5 +1,9 @@
 ---
 name: Конкатенация
+tips:
+  - >
+    Если в редакторе есть запись `// BEGIN` и `// END`, то код нужно писать
+    между этими строчками.
 definitions:
   - name: Конкатенация
     description: >
diff --git a/modules/25-strings/20-strings-concatenation/index.php b/modules/25-strings/20-strings-concatenation/index.php
deleted file mode 100644
index d3d4ee8c..00000000
--- a/modules/25-strings/20-strings-concatenation/index.php
+++ /dev/null
@@ -1,5 +0,0 @@
-<?php
-
-// BEGIN
-print_r('Winter ' . 'came ' . 'for ' . 'the ' . 'House ' . 'of ' . 'Frey.');
-// END
diff --git a/modules/25-strings/20-strings-concatenation/ru/EXERCISE.md b/modules/25-strings/20-strings-concatenation/ru/EXERCISE.md
deleted file mode 100644
index 0754bcfd..00000000
--- a/modules/25-strings/20-strings-concatenation/ru/EXERCISE.md
+++ /dev/null
@@ -1,7 +0,0 @@
-Выведите на экран
-
-```text
-Winter came for the House of Frey.
-```
-
-используя конкатенацию слов.
diff --git a/modules/25-strings/20-strings-concatenation/ru/README.md b/modules/25-strings/20-strings-concatenation/ru/README.md
deleted file mode 100644
index 62cb0633..00000000
--- a/modules/25-strings/20-strings-concatenation/ru/README.md
+++ /dev/null
@@ -1,44 +0,0 @@
-В веб-разработке программы постоянно оперируют строками. Все, что мы видим на сайтах, так или иначе представлено в виде текста. Этот текст чаще всего динамический — полученный из разных частей, которые соединяются вместе. Операция соединения строк в программировании называется **конкатенацией**.
-
-Мы уже знаем о математической операции сложения:
-
-```php
-<?php
-
-print_r(5 + 3); // => 8
-```
-
-Такая программа выведет на экран `8` — результат работы бинарного оператора `+` с операндами `5` и `3`.
-
-Можно также «сложить» две строки. Такая программа выведет на экран `Dragonstone` — результат работы бинарного оператора `.` с операндами 'Dragon' и 'stone':
-
-```php
-<?php
-
-print_r('Dragon' . 'stone'); // => Dragonstone
-```
-
-
-Склеивание строк всегда происходит в том же порядке, в котором записаны операнды. Левый операнд становится левой частью строки, а правый — правой. Вот еще несколько примеров:
-
-```php
-<?php
-
-print_r('Kings' . 'wood');     // => Kingswood
-print_r('Kings' . 'road');     // => Kingsroad
-print_r("King's" . 'Landing'); // => King'sLanding
-```
-
-Строки можно склеивать, даже если они записаны с разными кавычками.
-
-Пробел — такой же символ, как и другие, поэтому сколько пробелов поставить в строке — столько и получится в итоговой строке:
-
-```php
-<?php
-
-// Ставим пробел в левой части
-print_r("King's " . 'Landing'); // => King's Landing
-
-// Ставим пробел в правой части
-print_r("King's" . ' Landing'); // => King's Landing
-```
diff --git a/modules/25-strings/30-encoding/Solution.php b/modules/25-strings/30-encoding/Solution.php
new file mode 100644
index 00000000..d0d9d3c4
--- /dev/null
+++ b/modules/25-strings/30-encoding/Solution.php
@@ -0,0 +1,7 @@
+<?php
+
+// BEGIN
+print_r(chr(126) . "\n");
+print_r(chr(94) . "\n");
+print_r(chr(37) . "\n");
+// END
diff --git a/modules/25-strings/30-encoding/SolutionTest.php b/modules/25-strings/30-encoding/SolutionTest.php
index 47f53872..a19cfb88 100644
--- a/modules/25-strings/30-encoding/SolutionTest.php
+++ b/modules/25-strings/30-encoding/SolutionTest.php
@@ -2,16 +2,13 @@
 
 namespace HexletBasics\Strings\Encoding;
 
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        $expected = "~^%";
+        $expected = "~\n^\n%\n";
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/25-strings/30-encoding/index.php b/modules/25-strings/30-encoding/index.php
deleted file mode 100644
index 00a36996..00000000
--- a/modules/25-strings/30-encoding/index.php
+++ /dev/null
@@ -1,7 +0,0 @@
-<?php
-
-// BEGIN
-print_r(chr(126));
-print_r(chr(94));
-print_r(chr(37));
-// END
diff --git a/modules/25-strings/30-encoding/ru/EXERCISE.md b/modules/25-strings/30-encoding/ru/EXERCISE.md
index 518dd4c4..aee4d7f9 100644
--- a/modules/25-strings/30-encoding/ru/EXERCISE.md
+++ b/modules/25-strings/30-encoding/ru/EXERCISE.md
@@ -1,16 +1,13 @@
-
-В PHP можно «запросить» и вывести на экран любой символ из кодировки ASCII. Например:
+Программа получает числовые коды символов и выводит их на экран — это удобно, когда символ сложно набрать с клавиатуры. Найдите символы с кодами 126, 94 и 37 в [таблице ASCII](https://www.ascii-code.com) (нас интересует десятичный код — *dec* или *decimal*) и выведите каждый на отдельной строке с помощью функции `chr()` и перевода строки:
 
 ```php
-<?php
-
-print_r(chr(63));
+print_r(chr(...) . "\n");
+print_r(chr(...) . "\n");
+print_r(chr(...) . "\n");
 ```
 
-На экран выведется символ с номером 63 — вопросительный знак `?`. Таким способом можно выводить любой символ.
-
-Воспользуйтесь [таблицей кодов ASCII](https://www.ascii-code.com). В этой таблице нас интересует десятичный код (*dec* или *decimal*), которыми кодируются символы.
+Например, символ `?` имеет код 63:
 
-Используя пример выше и найденную таблицу, выведите на экран `~^%`.
-
-(Конечно, можно «обмануть» тесты и просто сделать `print_r('~^%')`, но так будет совсем неинтересно :)
+```php
+print_r(chr(63)); // вывод: ?
+```
diff --git a/modules/25-strings/30-encoding/ru/README.md b/modules/25-strings/30-encoding/ru/README.md
index dd47bb40..3c2a9ba3 100644
--- a/modules/25-strings/30-encoding/ru/README.md
+++ b/modules/25-strings/30-encoding/ru/README.md
@@ -1,40 +1,77 @@
+На самом базовом уровне компьютер работает только с нулями и единицами, что составляет так называемый двоичный код. Каждую единицу или ноль называют битом (от binary digit, «двоичная цифра»).
 
-На самом глубоком уровне компьютер оперирует исключительно цифрами `0` и `1`. Это так называемый [двоичный код](https://ru.wikipedia.org/wiki/Двоичный_код), а единички и нули называются битами, от "binary digit" — «двоичная цифра».
+Любые данные в компьютере представлены просто как последовательность битов, например изображения, музыка и текст. Привычные нам числа из десятичной системы тоже можно представить в двоичной форме.
 
-Обычные, привычные нам числа в десятичной системе счисления, закодированы с помощью двоичных чисел:
+- 0 → `0`
+- 1 → `1`
+- 2 → `10`
 
-- 0 ← 0
-- 1 ← 1
-- 2 ← 10
-- 3 ← 11
-- 4 ← 100
-- 5 ← 101
+## Как закодировать текст?
 
-Но как быть с текстом? Компьютер на самом деле не знает ничего о буквах, знаках пунктуации и прочих текстовых символах. Все эти символы также закодированы числами.
+Компьютер не «понимает» текст. Чтобы работать с буквами и другими символами, их тоже нужно превратить в числа. Это делают с помощью кодировок, то есть таблиц, в которых каждому символу соответствует определенное число.
 
-Можно взять английский алфавит и дать каждой букве число, начиная с единицы по порядку:
+Самый простой способ состоит в том, чтобы пронумеровать буквы, начиная с 1.
 
-- a ← 1
-- b ← 2
-- c ← 3
-- d ← 4
-- ...
-- z ← 26
+- `a` → `1`
+- `b` → `2`
+- ...и так до `z` → `26`
 
-В этом заключается суть **кодировок**.
+Теперь мы можем представить слово hello как набор чисел.
 
-Далее можно научить компьютер понимать эту таблицу и переводить текст в числа и наоборот — числа в текст:
+```text
+h e l l o
+↓ ↓ ↓ ↓ ↓
+8 5 12 12 15
+```
 
+А *good* превращается в такую последовательность.
 
-- `hello` → `8` `5` `12` `12` `15`
-- `7` `15` `15` `4` → `good`
+```text
+g o o d
+↓ ↓ ↓ ↓
+7 15 15 4
+```
 
-Подобные таблицы, в которых сопоставляются буквы и числа, называются кодировками. Кроме букв алфавита, в таблицы кодировок входят знаки препинания и другие полезные символы. Вы наверняка сталкивались с кодировками, например, [ASCII](https://ru.wikipedia.org/wiki/ASCII) или [UTF-8](https://ru.wikipedia.org/wiki/UTF-8).
+Программа не знает, что это слово. Она просто видит инструкцию «нужно отобразить символ с кодом 8, потом с кодом 5 и т. д.».
 
-Разные кодировки содержат разное количество символов. Изначально небольших таблиц вроде ASCII было достаточно для большинства задач. Но в ней есть только латинские буквы, несколько простых символов вроде `%` и `?`, и специальные управляющие символы типа перевода строки.
+## ASCII. Первая массовая кодировка
 
-С распространением компьютеров разным странам понадобились свои, более широкие таблицы. В том числе для кириллических букв, восточных иероглифов, арабской вязи, дополнительных математических и типографских символов, а впоследствии даже для эмодзи-смайликов.
+Первые компьютеры работали в основном с английским языком. Для него в 1960-х годах придумали таблицу ASCII, включавшую 128 символов, в том числе латинский алфавит, цифры, знаки препинания, спецсимволы (@, #, !, \n) и управляющие коды.
 
-Сегодня в большинстве случаев используется один из вариантов [юникода](https://ru.wikipedia.org/wiki/Юникод) – *utf-8*. Он включает в себя знаки почти всех письменных языков мира. Благодаря этому письмо, сформированное человеком в Китае на китайском, без проблем можно открыть и увидеть в первозданном виде на компьютере в Финляндии (поймет он его или нет, это уже другой вопрос).
+Этого хватало для первых программ, но не для всего мира.
 
-С кодированием текста и кодировками программисты встречаются в своей жизни регулярно. Поддержка юникода у разных языков программирования выполнена на разном уровне. Кроме того, кодировки нужно явно указывать при работе и с базами данных, и с файлами.
+Когда компьютеры начали использовать в других странах, возникла проблема. В ASCII нет кириллицы, иероглифов, арабского письма, ударений, валютных символов и т. д.
+
+Каждая страна или компания начала делать свою кодировку на основе ASCII.
+
+- Windows придумала Windows-1251 для русского
+- Apple создала Mac Roman
+- Страны Восточной Европы, Азии и Ближнего Востока разработали свои варианты
+
+Все эти кодировки были несовместимы между собой. Код 226 в одной кодировке мог быть буквой é, в другой буквой и, в третьей вообще техническим символом. Это приводило к настоящему хаосу.
+
+## Как выглядели проблемы с кодировками
+
+Если вы видите в тексте вот это.
+
+```text
+ÐÑивеÑ!
+```
+
+Это означает, что программа неправильно определила кодировку текста. Она получила последовательность байтов, но прочитала их не той таблицей.
+
+Это было нормой в 1990-х и 2000-х. Одна программа писала текст в Windows-1251, другая читала его как ISO-8859-1, и в результате получался мусор.
+
+## Unicode и UTF-8. Конец бардака
+
+Чтобы все починить, в 1990-х начали создавать универсальную таблицу Unicode, которая содержит символы всех письменных систем мира, в том числе латинский алфавит и кириллицу, китайское и арабское письмо, математические знаки, древнеегипетское письмо и даже эмодзи.
+
+Внутри Unicode есть несколько форматов хранения. Наиболее распространенным из них является UTF-8. Он компактно кодирует английские символы, но может расширяться под любые другие.
+
+Сегодня UTF-8 является стандартом по умолчанию в интернете, Linux, базах данных и редакторах кода. Исходный код PHP и строки в современных проектах тоже принято хранить в UTF-8.
+
+## Зачем это знать программисту?
+
+- Вы будете работать с текстом, и ошибки кодировки по-прежнему случаются, особенно при чтении файлов, обработке данных, взаимодействии с API и базами данных.
+- PHP хранит строку как последовательность байтов, поэтому при работе с файлами и базами данных кодировку иногда приходится указывать явно.
+- Нужно уметь диагностировать проблемы. Например, если видите «кракозябры», это почти наверняка ошибка кодировки.
diff --git a/modules/25-strings/30-encoding/ru/data.yml b/modules/25-strings/30-encoding/ru/data.yml
index d0e24fe7..e78d95cf 100644
--- a/modules/25-strings/30-encoding/ru/data.yml
+++ b/modules/25-strings/30-encoding/ru/data.yml
@@ -1,6 +1,10 @@
 ---
 name: Кодировка
-tips: []
+tips:
+  - |
+    [Таблица ASCII кодов](https://www.ascii-code.com/)
+  - |
+    [Что такое кодировки?](https://ru.hexlet.io/blog/posts/encoding)
 definitions:
   - name: Кодировка
     description: >-
diff --git a/modules/27-data-types/40-primitive-data-types/index.php b/modules/27-data-types/40-primitive-data-types/index.php
deleted file mode 100644
index 482c3c63..00000000
--- a/modules/27-data-types/40-primitive-data-types/index.php
+++ /dev/null
@@ -1,5 +0,0 @@
-<?php
-
-// BEGIN
-print_r(-0.304);
-// END
diff --git a/modules/27-data-types/40-primitive-data-types/ru/EXERCISE.md b/modules/27-data-types/40-primitive-data-types/ru/EXERCISE.md
deleted file mode 100644
index f795f618..00000000
--- a/modules/27-data-types/40-primitive-data-types/ru/EXERCISE.md
+++ /dev/null
@@ -1 +0,0 @@
-Выведите на экран число `-0.304`.
diff --git a/modules/27-data-types/40-primitive-data-types/ru/README.md b/modules/27-data-types/40-primitive-data-types/ru/README.md
deleted file mode 100644
index 22682b01..00000000
--- a/modules/27-data-types/40-primitive-data-types/ru/README.md
+++ /dev/null
@@ -1,40 +0,0 @@
-## Какие бывают типы данных
-
-Существуют разные способы представлять данные в программах:
-
-* **Строки** — наборы символов в кавычках, вроде `"Hello, World!"`
-* **Целые числа** — например, `7`, `-198`, `0`
-
-Это две разные категории информации — два разных **типа данных**.
-
-Операция умножения имеет смысл для целых чисел, но не имеет смысла для строк. Умножать слово «мама» на слово «блокнот» — бессмыслица. Тип данных определяет, что можно делать с элементами конкретного множества элементов.
-
-Язык программирования распознает типы. Поэтому PHP не позволит нам умножать текст на текст. Но позволит умножать целое число на другое целое число. Наличие типов и таких ограничений в языке защищает программы от случайных ошибок.
-
-В отличие от строк, числа оборачивать в кавычки не нужно. Чтобы напечатать число 5, достаточно написать:
-
-```php
-<?php
-
-print_r(5);
-```
-
-Число `5` и строка `'5'` — разные вещи, хотя вывод у `print_r()` для этих данных идентичный.
-
-Целые числа, например, `1`, `34`, `-19`, и рациональные числа, например, `1.3`, `1.0`, `-14.324`, — это два отдельных типа данных. Такое разделение связано с особенностями устройства компьютеров. Есть и другие типы, с ними мы познакомимся позже.
-
-Пример с рациональным числом:
-
-```php
-<?php
-
-print_r(10.234);
-```
-
-Типы данных «строка», «целое число» и «рациональное число» — это примитивные типы. Они встроены в сам язык PHP.
-
-В язык также встроены и некоторые составные типы данных, но пока мы будем работать только с примитивными. Программисты также могут создавать собственные типы данных.
-
-По-английски строки в программировании называются **strings**, а строчки текстовых файлов — **lines**. Например, в коде выше есть три lines, и нет strings.
-
-В русском языке может быть путаница, поэтому во всех уроках мы будем говорить «строка» для обозначения типа данных «строка», и «строчка» — для lines в файлах.
diff --git a/modules/27-data-types/50-data-types-weak-typing/ru/EXERCISE.md b/modules/27-data-types/50-data-types-weak-typing/ru/EXERCISE.md
deleted file mode 100644
index d6cb0377..00000000
--- a/modules/27-data-types/50-data-types-weak-typing/ru/EXERCISE.md
+++ /dev/null
@@ -1 +0,0 @@
-Выведите на экран результат выражения: `7 - (-8 - -2)`. Попробуйте сделать число 7 не числом, а строкой. Поэкспериментируйте с другими числами тоже.
diff --git a/modules/27-data-types/50-data-types-weak-typing/ru/README.md b/modules/27-data-types/50-data-types-weak-typing/ru/README.md
deleted file mode 100644
index 5f9a04bf..00000000
--- a/modules/27-data-types/50-data-types-weak-typing/ru/README.md
+++ /dev/null
@@ -1,19 +0,0 @@
-Мы могли складывать числа, потому что операция сложения — это операция для типа «числа». А если применить эту операцию к числу и строке:
-
-```php
-<?php
-
-print_r(1 + '7'); // => 8
-```
-
-`'7'` — это строка, а не число, при этом интерпретатор PHP выдал ответ `8`, как если бы мы складывали два числа. Когда PHP видит несоответствие типов, он сам пытается преобразовать информацию. В данном случае он преобразовал строку `'7'` в число `7`, а потом сложил `1` и `7`.
-
-Не все языки так делают. PHP — это язык со **слабой типизацией**. Он знает о существовании разных типов, но относится к их использованию не строго. Он пытается преобразовывать информацию, когда это кажется разумным.
-
-В языках со **строгой типизацией** сложить число со строкой не получится.
-
-PHP был создан для интернета, а в интернете вся информация — это строки. Даже когда мы вводим на сайте номер телефона или год рождения, на сервер эта информация поступает не как числа, а как строки. Поэтому авторы языка решили, что автоматически преобразовывать типы — правильно и удобно.
-
-Такое автоматическое неявное преобразование типов с одной стороны и правда удобно. Но на практике это свойство языка создает множество ошибок и проблем, которые трудно найти. Код может иногда работать, а иногда не работать. Это зависит от того, «повезло» ли в конкретном случае с автоматическим преобразованием. Программист это заметит не сразу.
-
-В дальнейших заданиях мы будем встречаться с таким поведением не раз. Часто будет возникать вопрос «почему мой код работает не так, как я ожидаю?».
diff --git a/modules/27-data-types/50-data-types-weak-typing/ru/data.yml b/modules/27-data-types/50-data-types-weak-typing/ru/data.yml
deleted file mode 100644
index 9253e728..00000000
--- a/modules/27-data-types/50-data-types-weak-typing/ru/data.yml
+++ /dev/null
@@ -1,3 +0,0 @@
----
-name: Слабая типизация
-tips: []
diff --git a/modules/27-data-types/55-type-conversion/SolutionTest.php b/modules/27-data-types/55-type-conversion/SolutionTest.php
deleted file mode 100644
index 2344e7ed..00000000
--- a/modules/27-data-types/55-type-conversion/SolutionTest.php
+++ /dev/null
@@ -1,17 +0,0 @@
-<?php
-
-namespace HexletBasics\DataTypes\TypeConversion;
-
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        $expected = '2 times';
-        $this->expectOutputString($expected);
-        require 'index.php';
-    }
-}
diff --git a/modules/27-data-types/55-type-conversion/index.php b/modules/27-data-types/55-type-conversion/index.php
deleted file mode 100644
index 009febdb..00000000
--- a/modules/27-data-types/55-type-conversion/index.php
+++ /dev/null
@@ -1,5 +0,0 @@
-<?php
-
-// BEGIN
-print_r((string) ((int) 2.9) . ' times');
-// END
diff --git a/modules/27-data-types/55-type-conversion/ru/EXERCISE.md b/modules/27-data-types/55-type-conversion/ru/EXERCISE.md
deleted file mode 100644
index ed451bc9..00000000
--- a/modules/27-data-types/55-type-conversion/ru/EXERCISE.md
+++ /dev/null
@@ -1 +0,0 @@
-Выведите на экран строку `2 times`, полученную из числа 2.9 и строки `times`, используя преобразования типов и конкатенацию. Для этого нужно выполнить два преобразования: сначала в целое число, а затем в строку
diff --git a/modules/27-data-types/55-type-conversion/ru/README.md b/modules/27-data-types/55-type-conversion/ru/README.md
deleted file mode 100644
index 027f2c8a..00000000
--- a/modules/27-data-types/55-type-conversion/ru/README.md
+++ /dev/null
@@ -1,27 +0,0 @@
-Преобразование типов — частая операция в веб-разработке. Для ее выполнения можно полагаться на слабую типизацию. Но во многих ситуациях лучше делать преобразование явно с помощью специального синтаксиса. Такой код понятнее и предсказуемее.
-
-Пример явного преобразования типов:
-
-```php
-<?php
-
-// Примеры немного искусственные
-// В реальности этот механизм становится полезен при использовании переменных
-print_r((string) 5);
-print_r((int) '345');
-
-// Преобразование типов можно использовать внутри составных выражений
-print_r('Это ' . ((string) 5)); // => 'Это 5'
-```
-
-Явное преобразование типа работает так: перед значением в скобках указывается желаемый тип. В результате значение справа преобразуется в значение другого типа, указанного слева в скобках. На текущий момент мы знакомы только с двумя типами, но преобразование работает для любого типа.
-
-В более сложных ситуациях при использовании функций, которые будем проходить позже, встречаются множественные преобразования: `(string) (5 + ((int) '4'))`. Порядок вычисления этого выражения следующий:
-
-```php
-<?php
-
-(int) '4';  // 4
-5 + 4;      // 9
-(string) 9; // '9'
-```
diff --git a/modules/27-data-types/55-type-conversion/ru/data.yml b/modules/27-data-types/55-type-conversion/ru/data.yml
deleted file mode 100644
index 7491a4f1..00000000
--- a/modules/27-data-types/55-type-conversion/ru/data.yml
+++ /dev/null
@@ -1,4 +0,0 @@
----
-name: Явное преобразование типов
-definitions: []
-tips: []
diff --git a/modules/30-variables/10-definition/Solution.php b/modules/30-variables/10-definition/Solution.php
new file mode 100644
index 00000000..2cb5df49
--- /dev/null
+++ b/modules/30-variables/10-definition/Solution.php
@@ -0,0 +1,8 @@
+<?php
+
+// BEGIN
+$url = 'https://hexlet.io';
+print_r($url);
+print_r("\n");
+print_r($url);
+// END
diff --git a/modules/30-variables/10-definition/SolutionTest.php b/modules/30-variables/10-definition/SolutionTest.php
index be4ef46d..5ae87dbd 100644
--- a/modules/30-variables/10-definition/SolutionTest.php
+++ b/modules/30-variables/10-definition/SolutionTest.php
@@ -2,16 +2,13 @@
 
 namespace HexletBasics\Variables\Definition;
 
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        $expected = 'What Is Dead May Never Die!';
+        $expected = "https://hexlet.io\nhttps://hexlet.io";
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/30-variables/10-definition/index.php b/modules/30-variables/10-definition/index.php
deleted file mode 100644
index ff5bbc77..00000000
--- a/modules/30-variables/10-definition/index.php
+++ /dev/null
@@ -1,6 +0,0 @@
-<?php
-
-// BEGIN
-$motto = 'What Is Dead May Never Die!';
-print_r($motto);
-// END
diff --git a/modules/30-variables/10-definition/ru/EXERCISE.md b/modules/30-variables/10-definition/ru/EXERCISE.md
index 1b7393ae..af284c6c 100644
--- a/modules/30-variables/10-definition/ru/EXERCISE.md
+++ b/modules/30-variables/10-definition/ru/EXERCISE.md
@@ -1 +1,3 @@
-Создайте переменную с именем `$motto` и содержимым `What Is Dead May Never Die!`. Распечатайте содержимое переменной.
+URL сайта используется в программе в нескольких местах. Чтобы не дублировать строку, сохраним ее в переменную.
+
+Создайте переменную `$url` со значением `https://hexlet.io` и выведите ее на экран дважды — каждое значение на своей строке. Для перевода строки используйте `\n`.
diff --git a/modules/30-variables/10-definition/ru/README.md b/modules/30-variables/10-definition/ru/README.md
index 981b89d3..53e371f0 100644
--- a/modules/30-variables/10-definition/ru/README.md
+++ b/modules/30-variables/10-definition/ru/README.md
@@ -1,34 +1,127 @@
-Допустим, нам нужно напечатать на экран слово «Father!» два раза или даже пять раз. Эту задачу можно решить так:
+Представьте, что нужно напечатать фразу Father! два раза:
 
 ```php
 <?php
 
 print_r('Father!');
+print_r("\n");
 print_r('Father!');
 ```
 
-В простом случае так и стоит поступить, но если слово «Father!» начнет использоваться чаще и в разных частях программы, то придется его везде повторять. Если нам понадобится изменить слово, то придется найти все места, где оно использовалось и выполнить необходимую замену. А можно поступить по-другому. Вместо копирования выражения достаточно создать переменную с этой фразой:
+Такой способ вполне подойдет, если фраза встречается всего пару раз. Но что, если она будет использоваться часто, в разных частях программы? Тогда придется копировать одно и то же выражение снова и снова.
+
+А что будет, если фразу нужно изменить, например заменить _Father!_ на _Mother!_? Придется искать и исправлять все вхождения вручную. Это неудобно и приводит к ошибкам.
+
+## Переменные
+
+Чтобы не дублировать одну и ту же строку, ее можно сохранить в переменной и распечатывать ее содержимое:
 
 ```php
 <?php
 
-// greeting - переводится как приветствие
 $greeting = 'Father!';
+
 print_r($greeting);
 print_r("\n");
 print_r($greeting);
-// => Father!
-// => Father!
 ```
 
-В строчке `$greeting = 'Father!'` значение `'Father!'` присваивается переменной с именем `$greeting`. В PHP имена переменных начинаются со знака *$*. В итоге переменная указывает на данные, которые были в нее записаны.
+Результат:
+
+```text
+Father!
+Father!
+```
+
+**Переменная** представляет собой имя, за которым хранится значение. В нашем примере мы создали переменную с именем `$greeting` и записали в нее строку `'Father!'`.
+
+```text
+$greeting = 'Father!';
+
+Переменная       Значение
+┌───────────┐    ┌──────────┐
+│ $greeting │ ──→│ 'Father!'│
+└───────────┘    └──────────┘
+```
+
+Строчка `$greeting = 'Father!'` читается так: "возьми значение `'Father!'` и присвой его переменной с именем `$greeting`". Знак `=` здесь является оператором присваивания, а не обозначением равенства как в математике. Он кладет значение в переменную.
 
-Когда переменная создана, можно начать ее использовать.
+Когда мы пишем `print_r($greeting)`, интерпретатор подставляет вместо имени `$greeting` то значение, которое в ней хранится. В результате на экран выводится строка `'Father!'`.
 
-## Использование переменной
+```text
+print_r($greeting)
+        |
+        v
+print_r('Father!')
+```
+
+## Имена переменных
+
+Имена переменных придумывает сам программист. В PHP имя переменной всегда начинается со знака `$`, а дальше можно использовать:
+
+- Латинские буквы (a-z, A-Z),
+- цифры (но не в начале),
+- нижнее подчеркивание _.
+
+Примеры допустимых имен: `$greeting`, `$name1`, `$helloWorld`. PHP различает строчные и заглавные буквы. Переменные `$greeting`, `$Greeting` и `$GREETING` являются тремя разными переменными.
+
+## Переменные и литералы
+
+В коде важно различать, где мы используем переменную, а где записываем значение напрямую. Это особенно заметно на примере с `print_r()`:
+
+```php
+<?php
+
+$greeting = 'Mother!';
+print_r($greeting);  // => Mother!
+print_r('greeting'); // => greeting
+```
+
+В первом случае используется **переменная** `$greeting`, и программа подставляет ее значение. Во втором случае `'greeting'` заключено в кавычки, поэтому это **строковый литерал**, то есть готовое значение, написанное прямо в коде. Здесь различить их помогает знак `$`, но с точки зрения интерпретатора это в любом случае абсолютно разные вещи.
+
+Литералы представляют собой данные, записанные явно (например, `'Hello'`, `42`, `3.14`). Идентификаторы являются именами переменных и функций (например, `$greeting`, `print_r`), которые указывают на уже существующие значения или команды.
+
+## Порядок использования
+
+Переменную нужно сначала создать (присвоить ей значение), а уже потом использовать. Если попытаться обратиться к переменной до ее создания, программа выдаст предупреждение, а вместо значения подставит "пустоту" — `null`:
+
+```php
+<?php
+
+print_r($name); // Предупреждение: переменная еще не определена
+// Warning: Undefined variable $name
+$name = 'Alice';
+```
+
+Такая ошибка называется "обращение к необъявленной переменной". Ее достаточно легко исправить, потому что текст предупреждения однозначно говорит о том, какая переменная используется до объявления. К таким же предупреждениям приводят и опечатки в имени переменной — правильно настроенный редактор подсвечивает имена, которые используются без объявления.
+
+А в правильном порядке все работает:
+
+```php
+<?php
+
+$name = 'Alice';
+print_r($name); // => Alice
+```
+
+## Несколько переменных в программе
+
+В одной программе можно создать сколько угодно переменных. Каждая хранит свои данные и не мешает другим:
+
+```php
+<?php
+
+$greeting1 = 'Father!';
+print_r($greeting1);
+print_r($greeting1);
+
+$greeting2 = 'Mother!';
+print_r($greeting2);
+print_r($greeting2);
+```
 
-Переменная подставляется в те места, где раньше стояло наше слово. Во время выполнения интерпретатор доходит до строчки `print_r($greeting);` и подставляет вместо переменной ее содержимое, а затем выполняет код.
+Как понять, когда нужно несколько переменных? Количество переменных зависит от логики программы. Эта тема подробно раскрывается позже, когда мы столкнемся с функциями и условными конструкциями.
 
-Для имени переменной используется любой набор допустимых символов, к которым относятся буквы английского алфавита, цифры, знак `_`. При этом цифру нельзя ставить в начале. Имена переменных регистрозависимы, то есть имя `hello` и имя `heLLo` — это два разных имени, значит, это две переменные. Регистр в PHP имеет важное значение, не стоит забывать про него.
+## Где создавать переменные
 
-Количество создаваемых переменных не ограничено, большие программы содержат десятки и сотни тысяч имен переменных. Для удобства анализа программы переменные принято создавать как можно ближе к тому месту, где они используются.
+Программисты стараются создавать переменные ближе к месту, где они используются. Это делает код более читаемым. Особенно важно это в больших программах, где переменных может быть десятки и сотни тысяч.
diff --git a/modules/30-variables/10-definition/ru/data.yml b/modules/30-variables/10-definition/ru/data.yml
index 1f1965c9..783a00b5 100644
--- a/modules/30-variables/10-definition/ru/data.yml
+++ b/modules/30-variables/10-definition/ru/data.yml
@@ -1,6 +1,9 @@
 ---
 name: Что такое переменная
-tips: []
+tips:
+  - >
+    [Именование в
+    программировании](https://ru.hexlet.io/blog/posts/naming-in-programming?utm_source=code-basics&utm_medium=referral&utm_campaign=blog&utm_content=lesson)
 definitions:
   - name: Переменная
     description: >-
diff --git a/modules/30-variables/12-change/Solution.php b/modules/30-variables/12-change/Solution.php
new file mode 100644
index 00000000..340dea2a
--- /dev/null
+++ b/modules/30-variables/12-change/Solution.php
@@ -0,0 +1,9 @@
+<?php
+
+$deliveryStatus = 'в пути';
+
+// BEGIN
+$deliveryStatus = 'доставлен';
+// END
+
+print_r($deliveryStatus);
diff --git a/modules/30-variables/12-change/SolutionTest.php b/modules/30-variables/12-change/SolutionTest.php
index d60ed6be..1cb89bd0 100644
--- a/modules/30-variables/12-change/SolutionTest.php
+++ b/modules/30-variables/12-change/SolutionTest.php
@@ -2,16 +2,13 @@
 
 namespace HexletBasics\Variables\Change;
 
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        $expected = 'anneirB';
+        $expected = 'доставлен';
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/30-variables/12-change/index.php b/modules/30-variables/12-change/index.php
deleted file mode 100644
index 4409669e..00000000
--- a/modules/30-variables/12-change/index.php
+++ /dev/null
@@ -1,9 +0,0 @@
-<?php
-
-$name = 'Brienna';
-
-// BEGIN
-$name = 'anneirB';
-// END
-
-print_r($name);
diff --git a/modules/30-variables/12-change/ru/EXERCISE.md b/modules/30-variables/12-change/ru/EXERCISE.md
index b503e50d..3388f1e1 100644
--- a/modules/30-variables/12-change/ru/EXERCISE.md
+++ b/modules/30-variables/12-change/ru/EXERCISE.md
@@ -1 +1,13 @@
-В упражнении определена переменная, внутри которой строка. Переопределите значение этой переменной и присвойте ей строку, в которой расположите символы первоначальной строки в обратном порядке.
+Статус заказа обновляется по мере его продвижения. В начале заказ находится «в пути», затем переходит в статус «доставлен».
+
+В упражнении определена переменная `$deliveryStatus` со значением `'в пути'`. Переопределите ее значение на `'доставлен'` и выведите на экран.
+
+Пример переопределения переменной:
+
+```php
+<?php
+
+$someVar = 'старое значение';
+$someVar = 'новое значение';
+print_r($someVar); // => новое значение
+```
diff --git a/modules/30-variables/12-change/ru/README.md b/modules/30-variables/12-change/ru/README.md
index 50bbb1fb..36f0468c 100644
--- a/modules/30-variables/12-change/ru/README.md
+++ b/modules/30-variables/12-change/ru/README.md
@@ -1,9 +1,11 @@
-Со временем внутри программы значения переменных могут изменяться:
+Само слово "переменная" подсказывает, что ее значение может меняться. Это одна из главных причин, почему переменные вообще существуют.
+
+Вот простой пример:
 
 ```php
 <?php
 
-// greeting - переводится как приветствие
+// greeting переводится как приветствие
 $greeting = 'Father!';
 print_r($greeting); // => Father!
 
@@ -11,8 +13,38 @@ $greeting = 'Mother!';
 print_r($greeting); // => Mother!
 ```
 
-Имя осталось тем же, но внутри другие данные. Переменные в PHP не требуют специального объявления. Вместо этого переменная объявляется при первом ее использовании в программе.
+Здесь мы сначала записали в переменную одну строку (_Father!_), потом другую (_Mother!_). Имя переменной не изменилось, но значение внутри стало другим.
+
+```text
+До:    $greeting ──→ 'Father!'
+                      ╳
+После: $greeting ──→ 'Mother!'
+```
+
+## Зачем вообще менять значение?
+
+В реальных программах переменные меняются постоянно. Вот несколько причин:
+
+- Программа реагирует на действия пользователя. Например, пока вы вводите какие-то данные, в формы на сайте, они, в этот момент, вполне вероятно, постоянно меняют переменные, которые эти данные содержат
+- Промежуточные результаты. Часто данные проходят через серию преобразований, и на каждом этапе переменная обновляется новым значением. Подобный механизм даже есть в калькуляторах, когда промежуточные значения сохраняются с помощью клавиш `m+` или `m-`.
+- Хранение состояния. Если вы пишете игру, то положение персонажа, его здоровье, счет и текущий уровень являются переменными, которые постоянно меняются.
+
+## Переменные создаются по мере использования
+
+В PHP переменную не нужно "объявлять заранее": она появляется в момент, когда вы впервые записываете в нее значение:
+
+```php
+<?php
+
+$name = 'Arya'; // переменная создается здесь
+```
+
+Если потом вы снова напишете `$name = ...`, это перезапишет старое значение. Так работает большинство современных языков программирования.
+
+## Почему это важно
+
+Переменные представляют собой гибкий способ хранить данные, которые могут изменяться в процессе выполнения программы. Благодаря этому можно писать программы, которые ведут себя по-разному в зависимости от условий, действий пользователя или результатов вычислений.
 
-Никогда нельзя быть точно уверенным, что записано внутри переменной. Чтобы быть спокойным, нужно проанализировать код, который находится перед переменной. Этим занимаются разработчики во время отладки, когда пытаются разобраться, почему программа не работает или работает не так, как задумано.
+Но у гибкости есть и обратная сторона. Иногда сложно сразу понять, что именно записано в переменную в тот или иной момент времени. Разработчику приходится отслеживать, где и как она изменилась, особенно если код длинный.
 
-Переменные меняются нечасто. Обычно их используют, чтобы хранить.
+Именно это делают во время отладки: пытаются разобраться, почему программа работает иначе, чем задумано. Проверяют значения переменных, отслеживают порядок выполнения кода, ищут, где что-то пошло не так.
diff --git a/modules/30-variables/12-change/ru/data.yml b/modules/30-variables/12-change/ru/data.yml
index f405fc24..15da5a73 100644
--- a/modules/30-variables/12-change/ru/data.yml
+++ b/modules/30-variables/12-change/ru/data.yml
@@ -1,9 +1,6 @@
 ---
 name: Изменение переменной
-tips:
-  - >
-    Если в редакторе есть запись `// BEGIN` и `// END`, то код нужно писать
-    между этими строчками.
+tips: []
 definitions:
   - name: Переменная
     description: >-
diff --git a/modules/30-variables/13-variables-naming/index.php b/modules/30-variables/13-variables-naming/Solution.php
similarity index 100%
rename from modules/30-variables/13-variables-naming/index.php
rename to modules/30-variables/13-variables-naming/Solution.php
diff --git a/modules/30-variables/13-variables-naming/SolutionTest.php b/modules/30-variables/13-variables-naming/SolutionTest.php
index 7657c077..0621225e 100644
--- a/modules/30-variables/13-variables-naming/SolutionTest.php
+++ b/modules/30-variables/13-variables-naming/SolutionTest.php
@@ -2,9 +2,7 @@
 
 namespace HexletBasics\Variables\Naming;
 
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
@@ -12,6 +10,5 @@ public function test()
     {
         $expected = "2";
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/30-variables/13-variables-naming/ru/README.md b/modules/30-variables/13-variables-naming/ru/README.md
index 21792a4c..c175296b 100644
--- a/modules/30-variables/13-variables-naming/ru/README.md
+++ b/modules/30-variables/13-variables-naming/ru/README.md
@@ -1,17 +1,47 @@
-В этом уроке мы поговорим об именовании. Изучать эту тему мы начнем с примера. Посмотрим на такую программу:
+Представьте, что у нас есть такая программа:
 
 ```php
 <?php
 
 $x = 'Father!';
 print_r($x);
-print_r($x);
 ```
 
-Она работает, но в ней странное имя переменной — `$x`. Компьютеру без разницы, как мы называем переменные, но вот программистам — нет. Мы гораздо реже пишем код, чем его читаем. Причем часто приходится читать не свой код, а написанный другими людьми. От качества и понятности имен переменных зависит половина успеха в анализе кода.
+С технической точки зрения все работает. Мы уже видели похожие примеры, но здесь используется переменная с названием `$x`. Плохие имена мешают читать и понимать код. Вот несколько примеров неудачных переменных:
+
+```php
+<?php
+
+$a = "John";
+$n = 42;
+$ddr = "New York";
+```
+
+Что это за переменные? Что в них хранится? Чтобы это понять, нужно читать весь остальной код и догадываться по контексту.
+
+![Именование](./assets/naming.png)
+
+Компьютеру все равно, как называется переменная. Для него `$x`, `$abc`, `$message` или `$elephantInTheRoom` являются просто метками для хранения данных. Людям важно другое. Программисты читают код гораздо чаще, чем пишут. Поэтому имена переменных являются важной частью общения через код.
+
+## Хорошие примеры
+
+```php
+<?php
+
+$userName = "Arya Stark";
+$unpaidOrdersCount = 3;
+$maxAttempts = 5;
+```
+
+Хорошее имя переменной помогает понять, что делает программа, не вчитываясь в каждую строчку.
+Особенно важно давать такие имена, смысл которых понятен без контекста, без необходимости читать весь код вокруг.
+
+Вот несколько советов:
 
-Лучше посидеть и придумать название, которое хорошо описывает суть переменной, чем назвать ее как попало и в будущем переделывать. Постарайтесь давать им такие имена, чтобы они были максимально понятны без контекста и без изучения окружающего кода.
+- Используйте английский язык. Это международный стандарт. Лучше писать `$ordersCount` вместо `$kolvoZakazov`. Если с английским пока сложно, используйте переводчик, это нормально. Со временем станет проще.
+- Старайтесь, чтобы имя отражало смысл переменной. Пусть оно будет чуть длиннее, но понятное.
+- Не бойтесь тратить время на подбор хорошего названия. Это инвестиция в читаемость и поддержку кода.
 
-Среди разработчиков есть шутка: «самое сложное в программировании — названия переменных и инвалидация кеша». Придумывать названия и правда сложно. Например, какое бы название вы бы выбрали для переменной, в которой хранится количество неоплаченных заказов от клиентов, имеющих задолженность в предыдущем квартале?
+Среди программистов даже есть шутка: "Одними из самых трудных задач в программировании являются кэширование и придумывание имен переменным." Иногда придумать подходящее имя действительно сложно. Вот пример: как бы вы назвали переменную, в которой хранится количество неоплаченных заказов от клиентов с задолженностью за предыдущий квартал?
 
-Чтобы глубже погрузиться в тему, попробуйте выполнить дополнительное задание — придумайте название для переменной, в которой хранится «количество братьев и сестер короля». Запишите его в блокноте или отправьте себе на почту. Не указывайте там ничего, кроме названия переменной. А через несколько уроков мы вернемся к этой теме.
+А теперь небольшое упражнение: Придумайте название для переменной, в которой будет храниться "количество братьев и сестер короля". Запишите его в блокноте или отправьте себе на почту. Только название, без объяснений. Мы вернемся к этому заданию через несколько уроков.
diff --git a/modules/30-variables/13-variables-naming/ru/assets/naming.png b/modules/30-variables/13-variables-naming/ru/assets/naming.png
new file mode 100644
index 00000000..a1380ac9
Binary files /dev/null and b/modules/30-variables/13-variables-naming/ru/assets/naming.png differ
diff --git a/modules/30-variables/13-variables-naming/ru/data.yml b/modules/30-variables/13-variables-naming/ru/data.yml
index 6b30966e..b19c1c4a 100644
--- a/modules/30-variables/13-variables-naming/ru/data.yml
+++ b/modules/30-variables/13-variables-naming/ru/data.yml
@@ -3,8 +3,12 @@ name: Выбор имени переменной
 tips:
   - >
     [Именование в
-    программировании](https://ru.hexlet.io/blog/posts/naming-in-programming)
+    программировании](https://ru.hexlet.io/blog/posts/naming-in-programming?utm_source=code-basics&utm_medium=referral&utm_campaign=blog&utm_content=lesson)
   - >
     [Ошибки в именовании
-    переменных](https://ru.hexlet.io/blog/posts/naming-errors-1)
-definitions: []
+    переменных](https://ru.hexlet.io/blog/posts/naming-errors-1?utm_source=code-basics&utm_medium=referral&utm_campaign=blog&utm_content=lesson)
+definitions:
+  - name: Переменная
+    description: >-
+      способ сохранить информацию и дать ей имя для последующего использования в
+      коде.
diff --git a/modules/30-variables/14-errors/SolutionTest.php b/modules/30-variables/14-errors/SolutionTest.php
deleted file mode 100644
index 83cd81d5..00000000
--- a/modules/30-variables/14-errors/SolutionTest.php
+++ /dev/null
@@ -1,17 +0,0 @@
-<?php
-
-namespace HexletBasics\Variables\Errors;
-
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        $expected = 'Targaryen and Dragon';
-        $this->expectOutputString($expected);
-        require 'index.php';
-    }
-}
diff --git a/modules/30-variables/14-errors/description.es.yml b/modules/30-variables/14-errors/description.es.yml
deleted file mode 100644
index 66cf5aa3..00000000
--- a/modules/30-variables/14-errors/description.es.yml
+++ /dev/null
@@ -1,30 +0,0 @@
----
-
-name: Errores al trabajar con variables
-theory: |
-  Es necesario declarar una variable antes de utilizarla. Si se hace después, el programa no funcionará:
-
-  ```php
-  <?php
-
-  print_r($greeting);
-  $greeting = '¡Padre!';
-  // PHP Notice:  Undefined variable: greeting in /private/var/tmp/index.php on line 3
-  ```
-
-  La ejecución del programa anterior termina con el error `PHP Notice`_ - este es un error de referencia. Significa que se está utilizando un nombre (identificador) en el código que no está definido. En el propio error se indica el identificador de la variable: `greeting`.
-
-  Los errores también pueden ser causados por errores tipográficos al utilizar una variable y al declararla. La cantidad de estos errores se reduce mediante el uso de un editor correctamente configurado. Este editor resalta los nombres que se utilizan sin ser declarados y advierte sobre posibles problemas.
-
-instructions: |
-  Encuentra la variable no declarada en el programa y declárala asignándole el valor `'Dragon'`.
-
-  Después de ejecutar el programa, el resultado en la pantalla debería verse así:
-
-  <pre class='hexlet-basics-output'>
-  Targaryen and Dragon
-  </pre>
-
-tips: []
-
-definitions: []
diff --git a/modules/30-variables/14-errors/en/EXERCISE.md b/modules/30-variables/14-errors/en/EXERCISE.md
deleted file mode 100644
index ec8d9933..00000000
--- a/modules/30-variables/14-errors/en/EXERCISE.md
+++ /dev/null
@@ -1,8 +0,0 @@
-
-Find an undeclared variable in the program and declare it by assigning the value `'Dragon'` to it.
-
-After running the program, the result on the screen should look like this:
-
-```text
-Targaryen and Dragon
-```
diff --git a/modules/30-variables/14-errors/en/README.md b/modules/30-variables/14-errors/en/README.md
deleted file mode 100644
index c24131df..00000000
--- a/modules/30-variables/14-errors/en/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
-
-The main rule is that a variable must be declared before it can be used. If you do it later, the program simply won't work.
-
-```php
-<?php
-
-print_r($greeting);
-$greeting = 'Father!';
-```
-
-Running the program above ends with an error _PHP Notice:  Undefined variable: greeting_. _Undefined variable_ It means that the code uses a name (the proper term is 'identifier') that hasn't been defined. And in the error itself, the variable identifier is explicitly specified: _greeting_. In addition to defining things in the wrong order, there are other, more trivial errors that can occur in PHP, for example, typos, both when using a variable and declaring one
-
-The number of these errors can be reduced by using a properly configured editor. An editor like this highlights names that are used without announcement and warns of possible problems.
diff --git a/modules/30-variables/14-errors/en/data.yml b/modules/30-variables/14-errors/en/data.yml
deleted file mode 100644
index 98889009..00000000
--- a/modules/30-variables/14-errors/en/data.yml
+++ /dev/null
@@ -1,2 +0,0 @@
----
-name: Errors when handling variables
diff --git a/modules/30-variables/14-errors/es/EXERCISE.md b/modules/30-variables/14-errors/es/EXERCISE.md
deleted file mode 100644
index d9afd212..00000000
--- a/modules/30-variables/14-errors/es/EXERCISE.md
+++ /dev/null
@@ -1,7 +0,0 @@
-Encuentra la variable no declarada en el programa y declárala asignándole el valor `'Dragon'`.
-
-Después de ejecutar el programa, el resultado en la pantalla debería verse así:
-
-```text
-Targaryen and Dragon
-```
diff --git a/modules/30-variables/14-errors/es/README.md b/modules/30-variables/14-errors/es/README.md
deleted file mode 100644
index 1a98d9ab..00000000
--- a/modules/30-variables/14-errors/es/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
-Es necesario declarar una variable antes de utilizarla. Si se hace después, el programa no funcionará:
-
-```php
-<?php
-
-print_r($greeting);
-$greeting = '¡Padre!';
-// PHP Notice:  Undefined variable: greeting in /private/var/tmp/index.php on line 3
-```
-
-La ejecución del programa anterior termina con el error `PHP Notice`_ - este es un error de referencia. Significa que se está utilizando un nombre (identificador) en el código que no está definido. En el propio error se indica el identificador de la variable: `greeting`.
-
-Los errores también pueden ser causados por errores tipográficos al utilizar una variable y al declararla. La cantidad de estos errores se reduce mediante el uso de un editor correctamente configurado. Este editor resalta los nombres que se utilizan sin ser declarados y advierte sobre posibles problemas.
diff --git a/modules/30-variables/14-errors/es/data.yml b/modules/30-variables/14-errors/es/data.yml
deleted file mode 100644
index daf7214b..00000000
--- a/modules/30-variables/14-errors/es/data.yml
+++ /dev/null
@@ -1,4 +0,0 @@
----
-name: Errores al trabajar con variables
-tips: []
-definitions: []
diff --git a/modules/30-variables/14-errors/index.php b/modules/30-variables/14-errors/index.php
deleted file mode 100644
index daedfa0b..00000000
--- a/modules/30-variables/14-errors/index.php
+++ /dev/null
@@ -1,11 +0,0 @@
-<?php
-
-$family = 'Targaryen';
-
-// BEGIN
-$pet = 'Dragon';
-// END
-
-print_r($family);
-print_r(' and ');
-print_r($pet);
diff --git a/modules/30-variables/14-errors/ru/EXERCISE.md b/modules/30-variables/14-errors/ru/EXERCISE.md
deleted file mode 100644
index 02e6744a..00000000
--- a/modules/30-variables/14-errors/ru/EXERCISE.md
+++ /dev/null
@@ -1,7 +0,0 @@
-Найдите в программе необъявленную переменную и объявите её, присвоив ей значение `'Dragon'`.
-
-После выполнения программы результат на экране должен выглядеть так:
-
-```text
-Targaryen and Dragon
-```
diff --git a/modules/30-variables/14-errors/ru/README.md b/modules/30-variables/14-errors/ru/README.md
deleted file mode 100644
index ee476413..00000000
--- a/modules/30-variables/14-errors/ru/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
-Переменную нужно объявить до ее использования. Если сделать это позже, то программа не заработает:
-
-```php
-<?php
-
-print_r($greeting);
-$greeting = 'Father!';
-// PHP Notice:  Undefined variable: greeting in /private/var/tmp/index.php on line 3
-```
-
-Запуск программы выше завершается с ошибкой `PHP Notice`_ — это ошибка обращения. Она означает, что в коде используется имя (идентификатор), которое не определено. При этом в самой ошибке указан идентификатор переменой: `greeting`.
-
-Также к ошибке могут привести опечатки при использовании переменной и во время ее объявления. Количество подобных ошибок уменьшается за счет использования правильно настроенного редактора. Такой редактор подсвечивает имена, которые используются без объявления, и предупреждает о возможных проблемах.
diff --git a/modules/30-variables/14-errors/ru/data.yml b/modules/30-variables/14-errors/ru/data.yml
deleted file mode 100644
index bd74fad5..00000000
--- a/modules/30-variables/14-errors/ru/data.yml
+++ /dev/null
@@ -1,4 +0,0 @@
----
-name: Ошибки при работе с переменными
-tips: []
-definitions: []
diff --git a/modules/30-variables/15-expressions/ru/README.md b/modules/30-variables/15-expressions/ru/README.md
deleted file mode 100644
index 87d34d00..00000000
--- a/modules/30-variables/15-expressions/ru/README.md
+++ /dev/null
@@ -1,69 +0,0 @@
-Переменные полезны не только для хранения и переиспользования информации. Также они нужны, чтобы упрощать сложные вычисления. В этом уроке мы научимся делать это.
-
-## Используем выражение
-
-Допустим, нам нужно перевести евро в юани через доллары. Подобные конвертации через промежуточную валюту часто делают банки при покупках за рубежом.
-
-Для начала переведем 50 евро в доллары. Допустим, один евро равен 1.25 доллара:
-
-```php
-<?php
-
-$dollarsCount = 50 * 1.25;
-print_r($dollarsCount);
-```
-
-Ранее мы записывали в переменную конкретное значение. А здесь в `$dollarsCount = 50 * 1.25;` справа от знака равно находится **выражение**. Интерпретатор вычислит результат — `62.5` — и запишет его в переменную.
-
-Для интерпретатора неважно, что перед ним: `62.5` или `50 * 1.25`. Для него оба варианта — выражения, которые надо вычислить. И они вычисляются в одно и то же значение — `62.5`.
-
-Любая строка — это выражение. Конкатенация строк — тоже выражение. Когда интерпретатор видит выражение, он обрабатывает его и генерирует результат — **значение выражения**.
-
-Вот несколько примеров выражений, а в комментариях справа от каждого выражения — итоговое значение:
-
-```php
-<?php
-
-62.5             // 62.5
-50 * 1.25        // 62.5
-120 / 10 * 2     // 24
-(int) '100'      // 100
-
-"hello"          // "hello"
-"Good" . "will"  // "Goodwill"
-```
-
-Теперь запишем стоимость доллара в юанях как отдельную переменную. Вычислим цену 50 евро в долларах, умножив их на `1.25`. Допустим, что 1 доллар — 6.91 юаней:
-
-```php
-<?php
-
-$yuansPerDollar = 6.91;
-$dollarsCount = 50 * 1.25; // 62.5
-$yuansCount = $dollarsCount * $yuansPerDollar; // 431.875
-
-print_r($yuansCount);
-```
-
-Любая переменная может быть частью любого выражения. В момент вычисления вместо имени переменной подставляется ее значение. Интерпретатор вычисляет значение `$dollarsCount` до того, как эта переменная начнет использоваться в других выражениях. Когда подходит момент использования переменной, PHP знает значение, потому что уже вычислил его.
-
-## Используем переменные с конкатенацией
-
-Использовать переменные можно и с конкатенацией. Синтаксически ничего не меняется: мы умеем конкатенировать (склеивать) две строки:
-
-```php
-<?php
-
-$what = "Kings" . "road";
-print_r($what); // => "Kingsroad"
-
-// Конкатенируем строку и переменную, в которой записана строка
-$first = "Kings";
-$what = $first . "road";
-print_r($what); // => "Kingsroad"
-
-// Конкатенируем две переменные, в которых записаны строки
-$last = 'road';
-$what = $first . $last;
-print_r($what); // => "Kingsroad"
-```
diff --git a/modules/30-variables/15-expressions/ru/data.yml b/modules/30-variables/15-expressions/ru/data.yml
deleted file mode 100644
index 5de10e09..00000000
--- a/modules/30-variables/15-expressions/ru/data.yml
+++ /dev/null
@@ -1,5 +0,0 @@
----
-name: Выражения в определениях
-tips:
-  - |
-    Для перевода строчки можно использовать `\n` между выводом долларов и юаней.
diff --git a/modules/30-variables/15-expressions/Makefile b/modules/30-variables/15-variables-expressions/Makefile
similarity index 100%
rename from modules/30-variables/15-expressions/Makefile
rename to modules/30-variables/15-variables-expressions/Makefile
diff --git a/modules/30-variables/15-expressions/index.php b/modules/30-variables/15-variables-expressions/Solution.php
similarity index 100%
rename from modules/30-variables/15-expressions/index.php
rename to modules/30-variables/15-variables-expressions/Solution.php
diff --git a/modules/30-variables/15-expressions/SolutionTest.php b/modules/30-variables/15-variables-expressions/SolutionTest.php
similarity index 68%
rename from modules/30-variables/15-expressions/SolutionTest.php
rename to modules/30-variables/15-variables-expressions/SolutionTest.php
index 0be31001..61bcaae1 100644
--- a/modules/30-variables/15-expressions/SolutionTest.php
+++ b/modules/30-variables/15-variables-expressions/SolutionTest.php
@@ -2,9 +2,7 @@
 
 namespace HexletBasics\Variables\Expressions;
 
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
@@ -12,6 +10,5 @@ public function test()
     {
         $expected = "125\n863.75";
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/30-variables/15-expressions/description.es.yml b/modules/30-variables/15-variables-expressions/description.es.yml
similarity index 100%
rename from modules/30-variables/15-expressions/description.es.yml
rename to modules/30-variables/15-variables-expressions/description.es.yml
diff --git a/modules/30-variables/15-expressions/en/EXERCISE.md b/modules/30-variables/15-variables-expressions/en/EXERCISE.md
similarity index 100%
rename from modules/30-variables/15-expressions/en/EXERCISE.md
rename to modules/30-variables/15-variables-expressions/en/EXERCISE.md
diff --git a/modules/30-variables/15-expressions/en/README.md b/modules/30-variables/15-variables-expressions/en/README.md
similarity index 100%
rename from modules/30-variables/15-expressions/en/README.md
rename to modules/30-variables/15-variables-expressions/en/README.md
diff --git a/modules/30-variables/15-expressions/en/data.yml b/modules/30-variables/15-variables-expressions/en/data.yml
similarity index 100%
rename from modules/30-variables/15-expressions/en/data.yml
rename to modules/30-variables/15-variables-expressions/en/data.yml
diff --git a/modules/30-variables/15-expressions/es/EXERCISE.md b/modules/30-variables/15-variables-expressions/es/EXERCISE.md
similarity index 100%
rename from modules/30-variables/15-expressions/es/EXERCISE.md
rename to modules/30-variables/15-variables-expressions/es/EXERCISE.md
diff --git a/modules/30-variables/15-expressions/es/README.md b/modules/30-variables/15-variables-expressions/es/README.md
similarity index 100%
rename from modules/30-variables/15-expressions/es/README.md
rename to modules/30-variables/15-variables-expressions/es/README.md
diff --git a/modules/30-variables/15-expressions/es/data.yml b/modules/30-variables/15-variables-expressions/es/data.yml
similarity index 100%
rename from modules/30-variables/15-expressions/es/data.yml
rename to modules/30-variables/15-variables-expressions/es/data.yml
diff --git a/modules/30-variables/15-expressions/ru/EXERCISE.md b/modules/30-variables/15-variables-expressions/ru/EXERCISE.md
similarity index 100%
rename from modules/30-variables/15-expressions/ru/EXERCISE.md
rename to modules/30-variables/15-variables-expressions/ru/EXERCISE.md
diff --git a/modules/30-variables/15-variables-expressions/ru/README.md b/modules/30-variables/15-variables-expressions/ru/README.md
new file mode 100644
index 00000000..fe116859
--- /dev/null
+++ b/modules/30-variables/15-variables-expressions/ru/README.md
@@ -0,0 +1,82 @@
+Мы уже знаем, что выражения можно составлять из нескольких операций. Но если записать все вычисление в одну длинную строку, код быстро становится трудным для чтения.
+
+Например, вот такая запись работает:
+
+```php
+<?php
+
+$yuansCount = 50 * 1.25 * 6.91;
+print_r($yuansCount); // => 431.875
+```
+
+PHP легко вычислит это выражение. Но человеку читать такой код уже не так удобно. Сразу возникают вопросы:
+
+- Что означает `1.25`?
+- Что означает `6.91`?
+- Где заканчивается один шаг вычисления и начинается следующий?
+
+Чтобы сделать такие вычисления понятнее, переменные можно использовать внутри других выражений. Сначала программа сохраняет промежуточный результат в переменную, а затем подставляет значение этой переменной в следующее вычисление.
+
+Переменные помогают разбивать сложные вычисления на понятные части и сохранять промежуточные результаты.
+
+## Конвертация валют через промежуточную валюту
+
+Представим, что нужно перевести евро в юани, но напрямую такой курс нам недоступен. Тогда сделаем это в два шага: **евро -> доллары -> юани**. Так часто работают банки при оплате покупок за рубежом.
+
+## Шаг 1. Евро -> Доллары
+
+Допустим, курс: 1 евро = 1.25 доллара. Хотим перевести 50 евро:
+
+```php
+<?php
+
+$dollarsPerEuro = 1.25;
+$dollarsCount = 50 * $dollarsPerEuro;
+print_r($dollarsCount); // => 62.5
+```
+
+В этой строке `50 * $dollarsPerEuro` является выражением, а `$dollarsCount` представляет собой переменную, в которую записывается результат. PHP сначала вычисляет выражение, а уже потом сохраняет результат в переменную.
+
+Интерпретатору все равно, как записано выражение:
+
+```php
+$dollarsCount = 62.5;
+```
+
+или
+
+```php
+$dollarsCount = 50 * $dollarsPerEuro;
+```
+
+Результат будет один и тот же. Но для человека второй вариант полезнее: по имени `$dollarsCount` сразу видно, что на этом шаге мы получили сумму в долларах.
+
+## Шаг 2. Доллары -> Юани
+
+Теперь переведем 50 евро в юани, используя доллар как промежуточную валюту. Допустим, курсы валют: 1 доллар = 6.91 юаней, 1 евро = 1.25 долларов.
+
+```php
+<?php
+
+$dollarsPerEuro = 1.25;
+$yuansPerDollar = 6.91;
+
+$dollarsCount = 50 * $dollarsPerEuro;
+$yuansCount = $dollarsCount * $yuansPerDollar;
+
+print_r($yuansCount);
+```
+
+Этот код длиннее, чем одна строка `50 * 1.25 * 6.91`, но читать его проще:
+
+- видно, что `1.25` это курс евро к доллару
+- видно, что `6.91` это курс доллара к юаню
+- видно, что `$dollarsCount` является промежуточным результатом
+
+Особенно это станет заметно, если не возвращаться к коду хотя бы неделю. А теперь представьте что в проекте сотни тысяч строк кода. Если бы в таких проектах не было промежуточных переменных и вычислений, в них бы было невозможно разобраться.
+
+## Что нужно запомнить
+
+- Если выражение получается слишком длинным, его лучше разбить на несколько шагов.
+- Переменные помогают сохранять промежуточные результаты и делают вычисления понятнее.
+- Когда переменная используется в выражении, PHP подставляет ее значение и продолжает вычисление.
diff --git a/modules/30-variables/15-variables-expressions/ru/data.yml b/modules/30-variables/15-variables-expressions/ru/data.yml
new file mode 100644
index 00000000..0b209214
--- /dev/null
+++ b/modules/30-variables/15-variables-expressions/ru/data.yml
@@ -0,0 +1,12 @@
+---
+name: Выражения в определениях
+tips:
+  - |
+    [Выражение](https://ru.wikipedia.org/wiki/Выражение_(информатика))
+  - |
+    Для перевода строчки можно использовать `\n` между выводом долларов и юаней.
+definitions:
+  - name: Переменная
+    description: >-
+      способ сохранить информацию и дать ей имя для последующего использования в
+      коде.
diff --git a/modules/30-variables/18-concatenation/SolutionTest.php b/modules/30-variables/18-concatenation/SolutionTest.php
deleted file mode 100644
index 69a3e0e3..00000000
--- a/modules/30-variables/18-concatenation/SolutionTest.php
+++ /dev/null
@@ -1,22 +0,0 @@
-<?php
-
-namespace HexletBasics\Variables\Concatenation;
-
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        $expected = <<<HERE
-Hello, Joffrey!
-Here is important information about your account security.
-We couldn't verify you mother's maiden name.
-HERE;
-
-        $this->expectOutputString($expected);
-        require 'index.php';
-    }
-}
diff --git a/modules/30-variables/18-concatenation/index.php b/modules/30-variables/18-concatenation/index.php
deleted file mode 100644
index 234fef87..00000000
--- a/modules/30-variables/18-concatenation/index.php
+++ /dev/null
@@ -1,12 +0,0 @@
-<?php
-
-$info = "We couldn't verify you mother's maiden name.";
-$intro = "\nHere is important information about your account security.";
-
-$firstName = 'Joffrey';
-$greeting = 'Hello';
-
-// BEGIN
-print_r($greeting . ", " . $firstName . "!");
-print_r($intro . "\n" . $info);
-// END
diff --git a/modules/30-variables/18-concatenation/ru/EXERCISE.md b/modules/30-variables/18-concatenation/ru/EXERCISE.md
deleted file mode 100644
index 2040390f..00000000
--- a/modules/30-variables/18-concatenation/ru/EXERCISE.md
+++ /dev/null
@@ -1,18 +0,0 @@
-
-Сайты постоянно посылают письма своим пользователям. Типичная задача — сделать автоматическую отправку персонального письма, где в заголовке будет имя пользователя. Если где-то в базе сайта хранится имя человека в виде строки, то задача генерации заголовка сводится к конкатенации: например, нужно склеить строку `Здравствуйте` со строкой, где записано имя.
-
-Напишите программу, которая будет генерировать заголовок и тело письма, используя уже готовые переменные, и выводить получившиеся строки на экран.
-
-Для заголовка используйте переменные `$firstName` и `$greeting`, запятую и восклицательный знак. Выведите это на экран в правильном порядке.
-
-Для тела письма используйте переменные `$info` и `$intro`, при этом второе предложение должно быть на новой строке.
-
-Результат на экране будет выглядеть так:
-
-```text
-Hello, Joffrey!
-Here is important information about your account security.
-We couldn't verify you mother's maiden name.
-```
-
-Выполните задание, используя только два `print_r()`.
diff --git a/modules/30-variables/18-concatenation/ru/README.md b/modules/30-variables/18-concatenation/ru/README.md
deleted file mode 100644
index 43250d3c..00000000
--- a/modules/30-variables/18-concatenation/ru/README.md
+++ /dev/null
@@ -1,32 +0,0 @@
-
-Для закрепления предыдущей темы попробуем использовать переменные с конкатенацией. Синтаксически ничего не меняется: мы умеем конкатенировать (склеивать) две строки:
-
-```php
-<?php
-
-$what = "Kings" . "road";
-print_r($what); // => "Kingsroad"
-```
-
-… а значит сумеем конкатенировать строку и одну переменную, в которой записана строка:
-
-```php
-<?php
-
-$first = "Kings";
-$what = $first . "road";
-
-print_r($what); // => "Kingsroad"
-```
-
-… и даже конкатенировать две переменные, в которых записаны строки:
-
-```php
-<?php
-
-$first = "Kings";
-$last = 'road';
-
-$what = $first . $last;
-print_r($what); // => "Kingsroad"
-```
diff --git a/modules/30-variables/18-concatenation/Makefile b/modules/30-variables/18-variable-concatenation/Makefile
similarity index 100%
rename from modules/30-variables/18-concatenation/Makefile
rename to modules/30-variables/18-variable-concatenation/Makefile
diff --git a/modules/30-variables/18-variable-concatenation/Solution.php b/modules/30-variables/18-variable-concatenation/Solution.php
new file mode 100644
index 00000000..daba7cd5
--- /dev/null
+++ b/modules/30-variables/18-variable-concatenation/Solution.php
@@ -0,0 +1,11 @@
+<?php
+
+$firstName = 'Анна';
+$greeting = 'Здравствуйте';
+$intro = 'Спасибо за ваш заказ.';
+$info = 'Ожидаемая дата доставки — 3 рабочих дня.';
+
+// BEGIN
+print_r($greeting . ', ' . $firstName . "!\n");
+print_r($intro . "\n" . $info);
+// END
diff --git a/modules/30-variables/18-variable-concatenation/SolutionTest.php b/modules/30-variables/18-variable-concatenation/SolutionTest.php
new file mode 100644
index 00000000..fc4b6d51
--- /dev/null
+++ b/modules/30-variables/18-variable-concatenation/SolutionTest.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace HexletBasics\Variables\Concatenation;
+
+use HexletBasics\Exercise\TestCase;
+
+class SolutionTest extends TestCase
+{
+    public function test()
+    {
+        $expected = <<<HERE
+Здравствуйте, Анна!
+Спасибо за ваш заказ.
+Ожидаемая дата доставки — 3 рабочих дня.
+HERE;
+
+        $this->expectOutputString($expected);
+    }
+}
diff --git a/modules/30-variables/18-concatenation/description.es.yml b/modules/30-variables/18-variable-concatenation/description.es.yml
similarity index 100%
rename from modules/30-variables/18-concatenation/description.es.yml
rename to modules/30-variables/18-variable-concatenation/description.es.yml
diff --git a/modules/30-variables/18-concatenation/en/EXERCISE.md b/modules/30-variables/18-variable-concatenation/en/EXERCISE.md
similarity index 100%
rename from modules/30-variables/18-concatenation/en/EXERCISE.md
rename to modules/30-variables/18-variable-concatenation/en/EXERCISE.md
diff --git a/modules/30-variables/18-concatenation/en/README.md b/modules/30-variables/18-variable-concatenation/en/README.md
similarity index 100%
rename from modules/30-variables/18-concatenation/en/README.md
rename to modules/30-variables/18-variable-concatenation/en/README.md
diff --git a/modules/30-variables/18-concatenation/en/data.yml b/modules/30-variables/18-variable-concatenation/en/data.yml
similarity index 100%
rename from modules/30-variables/18-concatenation/en/data.yml
rename to modules/30-variables/18-variable-concatenation/en/data.yml
diff --git a/modules/30-variables/18-concatenation/es/EXERCISE.md b/modules/30-variables/18-variable-concatenation/es/EXERCISE.md
similarity index 100%
rename from modules/30-variables/18-concatenation/es/EXERCISE.md
rename to modules/30-variables/18-variable-concatenation/es/EXERCISE.md
diff --git a/modules/30-variables/18-concatenation/es/README.md b/modules/30-variables/18-variable-concatenation/es/README.md
similarity index 100%
rename from modules/30-variables/18-concatenation/es/README.md
rename to modules/30-variables/18-variable-concatenation/es/README.md
diff --git a/modules/30-variables/18-concatenation/es/data.yml b/modules/30-variables/18-variable-concatenation/es/data.yml
similarity index 100%
rename from modules/30-variables/18-concatenation/es/data.yml
rename to modules/30-variables/18-variable-concatenation/es/data.yml
diff --git a/modules/30-variables/18-variable-concatenation/ru/EXERCISE.md b/modules/30-variables/18-variable-concatenation/ru/EXERCISE.md
new file mode 100644
index 00000000..e92e8b04
--- /dev/null
+++ b/modules/30-variables/18-variable-concatenation/ru/EXERCISE.md
@@ -0,0 +1,15 @@
+Интернет-магазин отправляет покупателю письмо после оформления заказа. Письмо генерируется автоматически на основе данных о клиенте.
+
+Напишите программу, которая генерирует приветствие и тело письма, используя уже готовые переменные, и выводит строки на экран.
+
+Для приветствия используйте переменные `$firstName` и `$greeting`, запятую и восклицательный знак. Для тела письма используйте переменные `$intro` и `$info` — второе предложение должно быть на новой строке.
+
+Результат на экране:
+
+```text
+Здравствуйте, Анна!
+Спасибо за ваш заказ.
+Ожидаемая дата доставки — 3 рабочих дня.
+```
+
+Выполните задание, используя только два `print_r()`. Не забудьте, что `print_r()` не переводит строку сам — перенос `\n` нужно добавить в нужные места самостоятельно.
diff --git a/modules/30-variables/18-variable-concatenation/ru/README.md b/modules/30-variables/18-variable-concatenation/ru/README.md
new file mode 100644
index 00000000..20288da1
--- /dev/null
+++ b/modules/30-variables/18-variable-concatenation/ru/README.md
@@ -0,0 +1,81 @@
+Ранее мы уже склеивали строки напрямую, используя конкатенацию. Теперь сделаем то же самое, но с использованием переменных. Хорошая новость: синтаксис остается тем же. Просто подставляются значения переменных.
+
+## Склеиваем две строки напрямую
+
+```php
+<?php
+
+$what = 'Kings' . 'road';
+print_r($what); // => Kingsroad
+```
+
+Здесь все просто: две строки соединяются в одну. Так работает конкатенация: оператор `.` складывает строки, создавая новую строку.
+
+## Склеиваем строку и переменную
+
+Если в переменной `$first` лежит строка "Kings", мы можем спокойно склеить ее с другой строкой:
+
+```php
+<?php
+
+$first = 'Kings';
+$what = $first . 'road';
+print_r($what); // => Kingsroad
+```
+
+PHP подставит значение переменной, выполнит операцию и создаст итоговую строку.
+
+## Склеиваем две переменные
+
+Точно так же можно объединить значения двух переменных, если обе содержат строки:
+
+```php
+<?php
+
+$first = 'Kings';
+$last = 'road';
+$what = $first . $last;
+print_r($what); // => Kingsroad
+```
+
+Можно добавлять и пробелы:
+
+```php
+$full = $first . ' ' . $last;
+print_r($full); // => Kings road
+```
+
+```text
+$first = 'Kings'
+$last  = 'road'
+
+$first  .  ' '  .  $last
+└─┬──┘            └──┬─┘
+'Kings' .  ' '  .  'road'
+└─────────┬────────────┘
+     'Kings road'
+```
+
+## А что если переменная содержит число?
+
+Попробуем так:
+
+```php
+<?php
+
+$age = 42;
+print_r('Age: ' . $age); // => Age: 42
+```
+
+В PHP такой код работает: оператор `.` всегда склеивает строки, поэтому число автоматически преобразуется в строку. Не во всех языках так — например, в Python склеивание строки и числа приводит к ошибке, и число приходится преобразовывать явно.
+
+То же самое касается переменных с результатами вычислений:
+
+```php
+<?php
+
+$price = 50 * 1.25 * 6.91; // => 431.875
+print_r('Price in yuans: ' . $price); // => Price in yuans: 431.875
+```
+
+Автоматическое преобразование удобно, но требует внимательности: иногда в строку превращается не то, что вы ожидали. Подробнее о таком поведении мы поговорим в уроках про типы данных.
diff --git a/modules/30-variables/18-concatenation/ru/data.yml b/modules/30-variables/18-variable-concatenation/ru/data.yml
similarity index 52%
rename from modules/30-variables/18-concatenation/ru/data.yml
rename to modules/30-variables/18-variable-concatenation/ru/data.yml
index 53c10189..925260ef 100644
--- a/modules/30-variables/18-concatenation/ru/data.yml
+++ b/modules/30-variables/18-variable-concatenation/ru/data.yml
@@ -6,4 +6,9 @@ tips:
     чтобы получить такой двухстрочный вывод тела письма.
   - >
     Помните, что можно создать строку, которая содержит только управляющую
-    последовательность `\n`.
+    последовательность `\n`. Вы можете конкатенировать эту строку с переменными
+    для правильного форматирования текста.
+definitions:
+  - name: Конкатенация
+    description: >
+      операция соединения двух строк. Например, `print_r("King's " . ' Landing')`
diff --git a/modules/30-variables/19-naming-style/Solution.php b/modules/30-variables/19-naming-style/Solution.php
new file mode 100644
index 00000000..b7131ef6
--- /dev/null
+++ b/modules/30-variables/19-naming-style/Solution.php
@@ -0,0 +1,8 @@
+<?php
+
+// BEGIN
+$itemCount = 20;
+$itemPrice = 100;
+
+print_r($itemCount * $itemPrice);
+// END
diff --git a/modules/30-variables/19-naming-style/SolutionTest.php b/modules/30-variables/19-naming-style/SolutionTest.php
index 22947d8f..f2def806 100644
--- a/modules/30-variables/19-naming-style/SolutionTest.php
+++ b/modules/30-variables/19-naming-style/SolutionTest.php
@@ -2,16 +2,13 @@
 
 namespace HexletBasics\Variables\Naming;
 
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        $expected = "-110";
+        $expected = "2000";
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/30-variables/19-naming-style/index.php b/modules/30-variables/19-naming-style/index.php
deleted file mode 100644
index c15ecce0..00000000
--- a/modules/30-variables/19-naming-style/index.php
+++ /dev/null
@@ -1,8 +0,0 @@
-<?php
-
-// BEGIN
-$firstNumber = 1.10;
-$secondNumber = -100;
-
-print_r($firstNumber * $secondNumber);
-// END
diff --git a/modules/30-variables/19-naming-style/ru/EXERCISE.md b/modules/30-variables/19-naming-style/ru/EXERCISE.md
index 0e87dcaa..d124393d 100644
--- a/modules/30-variables/19-naming-style/ru/EXERCISE.md
+++ b/modules/30-variables/19-naming-style/ru/EXERCISE.md
@@ -1,3 +1,4 @@
-Создайте две переменные с именами «первое число» и «второе число» на английском языке, используя lowerCamelCase. Запишите в первую переменную число `1.10`, во вторую — `-100`. Выведите на экран произведение чисел, записанных в получившиеся переменные.
-
-Код будет работать с любыми названиями, а наша система всегда проверяет только результат на экране, поэтому выполнение этого задания — под вашу ответственность.
+1. Создайте две переменные: количество товаров в заказе и цена одного товара. Используйте lowerCamelCase. Как вы назовете переменные — на ваше усмотрение, тесты это не проверяют.
+2. Запишите в первую переменную число `20`, во вторую — `100`.
+3. Вычислите итоговую стоимость заказа.
+4. Выведите результат на экран.
diff --git a/modules/30-variables/19-naming-style/ru/README.md b/modules/30-variables/19-naming-style/ru/README.md
index 892af728..1c4376e6 100644
--- a/modules/30-variables/19-naming-style/ru/README.md
+++ b/modules/30-variables/19-naming-style/ru/README.md
@@ -1,18 +1,46 @@
-Некоторые имена довольно просты — например, `$greeting`. Но часто все не так очевидно. Довольно часто имена составные, то есть включают в себя несколько слов. Например, «имя пользователя». В разных языках применяются разные стили кодирования, и имя переменной будет отличаться.
+`$greeting` служит примером простого и понятного имени переменной. Но часто имен вроде `$name`, `$email` или `$price` оказывается недостаточно. Например, нужно описать имя пользователя, общее количество заказов, максимальную длину сообщения. Такие имена уже состоят из нескольких слов. Как в таком случае будет выглядеть имя переменной?
 
-В именовании переменных можно выделить четыре основных подхода, которые иногда комбинируют друг с другом. Все эти подходы проявляют себя, когда имя переменной состоит из нескольких слов:
+В разных языках программирования используются разные стили именования. От этого зависит, как будет выглядеть имя переменной из нескольких слов. Например, вот как можно записать переменную, которая хранит максимальную длину сообщения:
 
-* kebab-case — составные части переменной разделяются дефисом (`my-super-var`)
-* snake_case — для разделения используется подчеркивание (`my_super_var`)
-* CamelCase  — каждое слово в переменной пишется с заглавной буквы (`MySuperVar`)
-* lowerCamelCase — каждое слово в переменной пишется с заглавной буквы, кроме первого (`mySuperVar`)
+1. `$maxmessagelength`
+1. `$maxMessageLength`
+1. `$max-message-length`
+1. `$max_message_length`
 
-В PHP используется CamelCase и его вариация lowerCamelCase, при котором первая буква первого слова — строчная. Именно lowerCamelCase применяется для переменных. Это значит, что имена соединяются друг с другом, при этом все имена кроме первого становятся с заглавной буквы: `$userName`. С тремя словами это выглядит так: `$mySuperVariable`.
+## Основные стили
 
-Другое общепринятое правило гласит — не используйте транслит для имен, только английский язык. Если вы испытываете сложности с английским, то пользуйтесь переводчиком. Со временем, копаясь в чужом коде, вы сформируете правильные представления об именовании.
+Вот три популярных подхода к написанию составных имен:
 
-Названия должны не только передавать смысл, но и соответствовать синтаксическим правилам, которые обычно никак не проверяются на уровне языка, но нужны во время разработки. Процесс написания программ в современном мире — коллективная работа, и для лучшего взаимодействия в команде код пишется в едином стиле, как если бы над ним работал один человек.
+- kebab-case: слова разделяются дефисом: `max-message-length`.
 
-В каждом языке свои правила. Относительно недавно в PHP появился общепринятый [стандарт кодирования](https://www.php-fig.org/psr/psr-1/), к которому все так или иначе стремятся. Подобные стандарты описывают множество аспектов. Советуем с самого начала завести привычку заглядывать в стандарт и писать код в соответствие с ним.
+  В PHP не работает, так как дефис (-) воспринимается как оператор вычитания.
 
-К счастью, сегодня не нужно помнить все правила из стандарта, потому что существуют специальные программы, которые проверяют код автоматически и сообщают о нарушениях. Такие программы называются **линтерами**, и вы начнете их использовать немного позже, когда у вас появится чуть больше опыта.
+- snake_case: слова разделяются подчеркиванием: `$max_message_length`.
+
+  Это стандарт, например, для Python. В PHP так именуются многие встроенные функции, но для переменных этот стиль не используется.
+
+- CamelCase: каждое слово с заглавной буквы, без разделителей: `MaxMessageLength`. У него есть вариация lowerCamelCase, при которой первое слово пишется со строчной буквы: `$maxMessageLength`.
+
+  Именно lowerCamelCase является стандартом для переменных в PHP.
+
+## Как правильно в PHP
+
+```php
+<?php
+
+$userName = "Daenerys";
+$maxLength = 280;
+$totalOrdersCount = 17;
+```
+
+- Первое слово пишется со строчной буквы
+- Каждое следующее слово начинается с заглавной
+- Разделители между словами не используются
+
+В каждом языке свои правила. В PHP есть общепринятый [стандарт кодирования](https://www.php-fig.org/psr/psr-1/), который описывает множество подобных аспектов. Не обязательно помнить все его правила: код автоматически проверяют линтеры, с которыми мы уже познакомились ранее.
+
+## Как не надо
+
+Не стоит включать тип данных в имя переменной. Такие имена хуже читаются и быстро устаревают. Например, `$userNameString` или `$messagesNumber` описывают не смысл переменной, а ее техническую реализацию.
+
+Имя должно отвечать на вопрос "что хранится?", а не "какого это типа?". Поэтому лучше писать `$userName` вместо `$userNameString` и `$messagesCount` вместо `$messagesNumber`.
diff --git a/modules/30-variables/19-naming-style/ru/data.yml b/modules/30-variables/19-naming-style/ru/data.yml
index 83df8fc9..878aeb80 100644
--- a/modules/30-variables/19-naming-style/ru/data.yml
+++ b/modules/30-variables/19-naming-style/ru/data.yml
@@ -1,6 +1,8 @@
 ---
 name: Именование переменных
-tips: []
+tips:
+  - |
+    [CamelCase](https://ru.wikipedia.org/wiki/CamelCase)
 definitions:
   - name: Стандарт кодирования
     description: набор синтаксических и стилистических правил написания кода.
diff --git a/modules/30-variables/20-magic-numbers/Solution.php b/modules/30-variables/20-magic-numbers/Solution.php
new file mode 100644
index 00000000..1254f012
--- /dev/null
+++ b/modules/30-variables/20-magic-numbers/Solution.php
@@ -0,0 +1,11 @@
+<?php
+
+$label = 'Ящиков на складе:';
+
+// BEGIN
+$palletsCount = 6;
+$boxesPerPallet = 17;
+print_r($label);
+print_r("\n");
+print_r($palletsCount * $boxesPerPallet);
+// END
diff --git a/modules/30-variables/20-magic-numbers/SolutionTest.php b/modules/30-variables/20-magic-numbers/SolutionTest.php
index 968be728..827829b1 100644
--- a/modules/30-variables/20-magic-numbers/SolutionTest.php
+++ b/modules/30-variables/20-magic-numbers/SolutionTest.php
@@ -2,16 +2,13 @@
 
 namespace HexletBasics\Variables\MagicNumbers;
 
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        $expected = 'King Balon the 6th has 102 rooms.';
+        $expected = "Ящиков на складе:\n102";
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/30-variables/20-magic-numbers/index.php b/modules/30-variables/20-magic-numbers/index.php
deleted file mode 100644
index 0f94634c..00000000
--- a/modules/30-variables/20-magic-numbers/index.php
+++ /dev/null
@@ -1,9 +0,0 @@
-<?php
-
-$king = 'King Balon the 6th';
-
-// BEGIN
-$numberOfCastles = 6;
-$roomsPerCastle = 17;
-print_r($king . ' has ' . ($numberOfCastles * $roomsPerCastle) . ' rooms.');
-// END
diff --git a/modules/30-variables/20-magic-numbers/ru/EXERCISE.md b/modules/30-variables/20-magic-numbers/ru/EXERCISE.md
index 8cdb3e6e..6a418e51 100644
--- a/modules/30-variables/20-magic-numbers/ru/EXERCISE.md
+++ b/modules/30-variables/20-magic-numbers/ru/EXERCISE.md
@@ -1,25 +1,23 @@
-
-Вы столкнулись с таким кодом, который выводит на экран общее количество комнат во владении нынешнего короля:
+Склад принял поставку. Вы столкнулись с таким кодом, который считает общее количество ящиков:
 
 ```php
 <?php
 
-$king = 'King Balon the 6th';
-print_r($king . ' has ' . (6 * 17) . ' rooms.');
+$label = 'Ящиков на складе:';
+print_r($label);
+print_r("\n");
+print_r(6 * 17);
 ```
 
-Как видите, это магические числа: непонятно, что такое 6 и что такое 17. Можно догадаться, если знать историю королевской семьи: каждый новый король получает в наследство все замки от предков и строит новый замок — точную копию родительского.
-
-Эта странная династия просто плодит одинаковые замки…
-
-Избавьтесь от магических чисел, создав новые переменные, а затем выведите текст на экран.
+Числа 6 и 17 здесь — магические: непонятно, что они означают. Избавьтесь от них, создав переменные с понятными именами, и выведите результат на экран.
 
 Получится так:
 
 ```text
-King Balon the 6th has 102 rooms.
+Ящиков на складе:
+102
 ```
 
-Названия переменных должны передавать смысл чисел, но при этом должны оставаться достаточно короткими и ёмкими для комфортного чтения.
+Названия переменных должны передавать смысл чисел, но оставаться короткими и емкими.
 
-Помните: код будет работать с любыми названиями, а наша система всегда проверяет только результат на экране, поэтому выполнение этого задания — под вашу ответственность.
+Помните: код будет работать с любыми названиями, а система проверяет только результат на экране — выполнение задания под вашу ответственность.
diff --git a/modules/30-variables/20-magic-numbers/ru/data.yml b/modules/30-variables/20-magic-numbers/ru/data.yml
index a9d34092..6204a854 100644
--- a/modules/30-variables/20-magic-numbers/ru/data.yml
+++ b/modules/30-variables/20-magic-numbers/ru/data.yml
@@ -1,3 +1,6 @@
 ---
 name: Магические числа
-tips: []
+tips:
+  - >
+    [Магические
+    числа](https://ru.wikipedia.org/wiki/Магическое_число_(программирование))
diff --git a/modules/30-variables/23-constants/Solution.php b/modules/30-variables/23-constants/Solution.php
new file mode 100644
index 00000000..63c81dd4
--- /dev/null
+++ b/modules/30-variables/23-constants/Solution.php
@@ -0,0 +1,5 @@
+<?php
+
+// BEGIN
+const MAX_LOGIN_ATTEMPTS = 3;
+// END
diff --git a/modules/30-variables/23-constants/SolutionTest.php b/modules/30-variables/23-constants/SolutionTest.php
index 64080d5b..699f8579 100644
--- a/modules/30-variables/23-constants/SolutionTest.php
+++ b/modules/30-variables/23-constants/SolutionTest.php
@@ -2,13 +2,12 @@
 
 namespace HexletBasics\Variables\Constants;
 
-use PHPUnit\Framework\TestCase;
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        require 'index.php';
-        $this->assertEquals(3, DRAGONS_BORN_COUNT);
+        $this->assertEquals(3, MAX_LOGIN_ATTEMPTS);
     }
 }
diff --git a/modules/30-variables/23-constants/index.php b/modules/30-variables/23-constants/index.php
deleted file mode 100644
index 51d5eead..00000000
--- a/modules/30-variables/23-constants/index.php
+++ /dev/null
@@ -1,5 +0,0 @@
-<?php
-
-// BEGIN
-const DRAGONS_BORN_COUNT = 3;
-// END
diff --git a/modules/30-variables/23-constants/ru/EXERCISE.md b/modules/30-variables/23-constants/ru/EXERCISE.md
index 4768f44c..e95d46d1 100644
--- a/modules/30-variables/23-constants/ru/EXERCISE.md
+++ b/modules/30-variables/23-constants/ru/EXERCISE.md
@@ -1 +1 @@
-Создайте константу `DRAGONS_BORN_COUNT` и запишите в неё число 3 — это количество драконов, родившихся у Дайенерис.
+Создайте константу `MAX_LOGIN_ATTEMPTS` и запишите в нее число `3` — максимальное количество попыток входа в систему.
diff --git a/modules/30-variables/23-constants/ru/README.md b/modules/30-variables/23-constants/ru/README.md
index 71ec3030..6140d30b 100644
--- a/modules/30-variables/23-constants/ru/README.md
+++ b/modules/30-variables/23-constants/ru/README.md
@@ -1,6 +1,12 @@
-Разработчики часто работают с данными, которые никогда не меняются. Например, число π, которое всегда равно `3.14` и не может измениться.
+Иногда в программе встречаются значения, которые никогда не должны меняться. Например:
 
-Для обращения к подобным данным в PHP принято использовать константы:
+- Математическая константа π (пи).
+- Курс доллара на определенную дату.
+- Фиксированная комиссия сервиса.
+
+Такие значения называются константами и их принято отличать от обычных переменных, чтобы не возникало желания их менять.
+
+## Пример: число π
 
 ```php
 <?php
@@ -9,24 +15,41 @@ const PI = 3.14;
 print_r(PI); // => 3.14
 ```
 
-Создание константы отличается от создания переменной. Оно начинается с ключевого слова `const` и последующего имени константы. При этом знак доллара не нужен. Далее ей присваивается нужное значение.
+Здесь PI является константой, которая хранит значение числа π. Создание константы отличается от создания переменной: оно начинается с ключевого слова `const`, а знак доллара перед именем не нужен. Смысл константы в том, что ее значение не меняется в ходе работы программы.
 
-Константы принято именовать буквами в верхнем регистре с `_` в качестве разделителя. Константа тоже может использоваться в любом выражении. Единственное ограничение — константу нельзя изменить.
+## Чем отличается константа от переменной?
 
-В PHP много встроенных констант, которые можно использовать в любом месте программы. Вот некоторые из них:
+Концепт констант распространен в большинстве языков программирования. В PHP константа является отдельной сущностью языка: в отличие от переменной, ее значение нельзя изменить. Попытка определить константу повторно приводит к ошибке:
+
+```php
+<?php
+
+const PI = 3.14;
+const PI = 3.14159; // Ошибка: константу нельзя определить повторно
+```
 
-* `PHP_VERSION` — текущая версия PHP
-* `PHP_MAXPATHLEN` — максимальная разрешенная длина имени файла
-* `PHP_INT_MAX` — максимальное возможное значение целых чисел (integer)
+При этом константа, как и переменная, может использоваться в любом выражении.
 
-Кроме обычных констант в PHP существует отдельная группа — **магические константы**. Их отличия заключаются в следующем:
+## Как оформляются константы
+
+- Все буквы заглавные
+- Слова разделяются символом подчеркивания `_`
+- Стиль называется UPPER_SNAKE_CASE (еще его называют SCREAMING_SNAKE_CASE)
+
+```php
+<?php
+
+const PI = 3.14;
+const MAX_USERS = 100;
+const DEFAULT_TIMEOUT = 30;
+```
+
+В PHP много встроенных констант, которые можно использовать в любом месте программы. Вот некоторые из них:
 
-* Магические константы невозможно определить самому, можно пользоваться только существующими
-* Магические константы начинаются и заканчиваются символами `__` (два подчеркивания)
-* Магия заключается в том, что такие константы имеют одно и то же значение только в пределах определенной части программы
+- `PHP_VERSION` — текущая версия PHP
+- `PHP_MAXPATHLEN` — максимальная разрешенная длина имени файла
+- `PHP_INT_MAX` — максимальное возможное значение целых чисел (integer)
 
-Последний пункт говорит о том, что существуют не очень постоянные константы, но их изменения регламентированы и на практике не вызывают проблем. К подобным константам относятся:
+## Зачем нужны константы?
 
-* `__LINE__` — содержит текущую строку файла, в котором она используется
-* `__FILE__` — путь до текущего файла
-* `__DIR__` — путь до директории, в которой находится текущий файл
+Константы делают код понятнее и безопаснее. Они помогают сразу увидеть, какие значения в программе считаются фиксированными и не должны меняться. Это особенно важно при работе с такими данными, как математические и физические постоянные, настройки по умолчанию или фиксированные лимиты. Использование констант снижает риск ошибок: по имени сразу понятно, что перед нами константа, и менять ее не следует. Кроме того, если значение все же нужно будет изменить (например, в настройках), достаточно поменять его в одном месте, и изменение автоматически подхватится во всей программе.
diff --git a/modules/30-variables/24-magic-constants/SolutionTest.php b/modules/30-variables/24-magic-constants/SolutionTest.php
deleted file mode 100644
index 827c5480..00000000
--- a/modules/30-variables/24-magic-constants/SolutionTest.php
+++ /dev/null
@@ -1,16 +0,0 @@
-<?php
-
-namespace HexletBasics;
-
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        $this->expectOutputString(__DIR__);
-        require 'index.php';
-    }
-}
diff --git a/modules/30-variables/24-magic-constants/description.es.yml b/modules/30-variables/24-magic-constants/description.es.yml
deleted file mode 100644
index e11a3ca9..00000000
--- a/modules/30-variables/24-magic-constants/description.es.yml
+++ /dev/null
@@ -1,28 +0,0 @@
----
-
-name: Constantes mágicas
-theory: |
-
-  Además de las constantes normales, en PHP existe un grupo separado llamado **constantes mágicas**. Sus diferencias son las siguientes:
-
-  * No se pueden definir constantes mágicas por uno mismo, solo se pueden utilizar las existentes.
-  * Las constantes mágicas comienzan y terminan con los caracteres `__` (dos guiones bajos).
-  * La magia radica en que estas constantes tienen el mismo valor solo dentro de una parte específica del programa.
-
-  El último punto puede parecer extraño. ¿Cómo pueden ser constantes si su valor cambia? Para ser honestos, no son muy constantes, pero sus cambios están claramente regulados y en la práctica no causan problemas. Algunos ejemplos de estas constantes son:
-
-  * `__LINE__` - contiene la línea actual del archivo en el que se utiliza
-  * `__FILE__` - la ruta al archivo actual
-  * `__DIR__` - la ruta al directorio en el que se encuentra el archivo actual
-
-instructions: |
-
-  Muestra en pantalla la ruta al directorio actual utilizando una constante mágica.
-
-tips:
-  - |
-    [Constantes mágicas](https://php.net/manual/es/language.constants.predefined.php)
-
-definitions:
-  - name: Constante mágica
-    description: una constante especial disponible en PHP; tiene diferentes valores en diferentes contextos.
diff --git a/modules/30-variables/24-magic-constants/en/EXERCISE.md b/modules/30-variables/24-magic-constants/en/EXERCISE.md
deleted file mode 100644
index 82b21470..00000000
--- a/modules/30-variables/24-magic-constants/en/EXERCISE.md
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Output the path to the current directory using a magic constant.
diff --git a/modules/30-variables/24-magic-constants/en/README.md b/modules/30-variables/24-magic-constants/en/README.md
deleted file mode 100644
index 6e68dd1d..00000000
--- a/modules/30-variables/24-magic-constants/en/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
-
-In addition to the usual constants, PHP has a separate group of **magic constants**. The differences are as follows:
-
-* You can't define magic constants yourself, you can only use existing ones.
-* Magic constants begin and end with `__` (two underscores).
-* The magic is that the constants have the same value only within a certain part of the program.
-
-This last point may seem strange. What kind of constants are they if their value changes? To put it bluntly, they're not very constant, but their changes are clearly regulated and in practice don't cause problems. Such constants include, for example, the following:
-
-* `__LINE__` — contains the current line of the file it's used in
-* `__FILE__` — path to the current file
-* `__DIR__` — the path to the directory where the current file is located
diff --git a/modules/30-variables/24-magic-constants/en/data.yml b/modules/30-variables/24-magic-constants/en/data.yml
deleted file mode 100644
index 6a4fd466..00000000
--- a/modules/30-variables/24-magic-constants/en/data.yml
+++ /dev/null
@@ -1,11 +0,0 @@
----
-name: Magic constants
-tips:
-  - >
-    [Magic
-    constants](https://www.php.net/manual/en/language.constants.predefined.php)
-definitions:
-  - name: A magic constant
-    description: >-
-      is a special constant available in PHP; it contains different values in
-      different contexts.
diff --git a/modules/30-variables/24-magic-constants/es/EXERCISE.md b/modules/30-variables/24-magic-constants/es/EXERCISE.md
deleted file mode 100644
index ec09bb2c..00000000
--- a/modules/30-variables/24-magic-constants/es/EXERCISE.md
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Muestra en pantalla la ruta al directorio actual utilizando una constante mágica.
diff --git a/modules/30-variables/24-magic-constants/es/README.md b/modules/30-variables/24-magic-constants/es/README.md
deleted file mode 100644
index 57e77e65..00000000
--- a/modules/30-variables/24-magic-constants/es/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
-
-Además de las constantes normales, en PHP existe un grupo separado llamado **constantes mágicas**. Sus diferencias son las siguientes:
-
-* No se pueden definir constantes mágicas por uno mismo, solo se pueden utilizar las existentes.
-* Las constantes mágicas comienzan y terminan con los caracteres `__` (dos guiones bajos).
-* La magia radica en que estas constantes tienen el mismo valor solo dentro de una parte específica del programa.
-
-El último punto puede parecer extraño. ¿Cómo pueden ser constantes si su valor cambia? Para ser honestos, no son muy constantes, pero sus cambios están claramente regulados y en la práctica no causan problemas. Algunos ejemplos de estas constantes son:
-
-* `__LINE__` - contiene la línea actual del archivo en el que se utiliza
-* `__FILE__` - la ruta al archivo actual
-* `__DIR__` - la ruta al directorio en el que se encuentra el archivo actual
diff --git a/modules/30-variables/24-magic-constants/es/data.yml b/modules/30-variables/24-magic-constants/es/data.yml
deleted file mode 100644
index 94a0ad1c..00000000
--- a/modules/30-variables/24-magic-constants/es/data.yml
+++ /dev/null
@@ -1,11 +0,0 @@
----
-name: Constantes mágicas
-tips:
-  - >
-    [Constantes
-    mágicas](https://php.net/manual/es/language.constants.predefined.php)
-definitions:
-  - name: Constante mágica
-    description: >-
-      una constante especial disponible en PHP; tiene diferentes valores en
-      diferentes contextos.
diff --git a/modules/30-variables/24-magic-constants/index.php b/modules/30-variables/24-magic-constants/index.php
deleted file mode 100644
index 8aa42cf9..00000000
--- a/modules/30-variables/24-magic-constants/index.php
+++ /dev/null
@@ -1,5 +0,0 @@
-<?php
-
-// BEGIN
-print_r(__DIR__);
-// END
diff --git a/modules/30-variables/24-magic-constants/ru/EXERCISE.md b/modules/30-variables/24-magic-constants/ru/EXERCISE.md
deleted file mode 100644
index 20f4c4e2..00000000
--- a/modules/30-variables/24-magic-constants/ru/EXERCISE.md
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Выведите на экран путь до текущей директории, используя магическую константу.
diff --git a/modules/30-variables/24-magic-constants/ru/README.md b/modules/30-variables/24-magic-constants/ru/README.md
deleted file mode 100644
index 6bfd7030..00000000
--- a/modules/30-variables/24-magic-constants/ru/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
-
-Кроме обычных констант, в PHP существует отдельная группа — **магические константы**. Их отличия заключаются в следующем:
-
-* Магические константы невозможно определить самому, можно пользоваться только существующими.
-* Магические константы начинаются и заканчиваются символами `__` (два подчёркивания).
-* Магия заключается в том, что такие константы имеют одно и то же значение только в пределах определенной части программы.
-
-Последний пункт может показаться странным. Какие же они константы, если их значение меняется? Прямо скажем, они не очень постоянные, но их изменения четко регламентированы и на практике не вызывают проблем. К подобным константам относятся, например, такие:
-
-* `__LINE__` — содержит текущую строку файла, в котором она используется
-* `__FILE__` — путь до текущего файла
-* `__DIR__` — путь до директории, в которой находится текущий файл
diff --git a/modules/30-variables/24-magic-constants/ru/data.yml b/modules/30-variables/24-magic-constants/ru/data.yml
deleted file mode 100644
index 4f55d20c..00000000
--- a/modules/30-variables/24-magic-constants/ru/data.yml
+++ /dev/null
@@ -1,11 +0,0 @@
----
-name: Магические константы
-tips:
-  - >
-    [Магические
-    константы](https://php.net/manual/ru/language.constants.predefined.php)
-definitions:
-  - name: Магическая константа
-    description: >-
-      специальная константа, доступная в PHP; содержит разное значение в разных
-      контекстах.
diff --git a/modules/30-variables/25-interpolation/SolutionTest.php b/modules/30-variables/25-interpolation/SolutionTest.php
deleted file mode 100644
index 19afe7c3..00000000
--- a/modules/30-variables/25-interpolation/SolutionTest.php
+++ /dev/null
@@ -1,17 +0,0 @@
-<?php
-
-namespace HexletBasics\Variables\Interpolation;
-
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        $expected = 'Do you want to eat, Arya?';
-        $this->expectOutputString($expected);
-        require 'index.php';
-    }
-}
diff --git a/modules/30-variables/25-interpolation/index.php b/modules/30-variables/25-interpolation/index.php
deleted file mode 100644
index 4dfa44f7..00000000
--- a/modules/30-variables/25-interpolation/index.php
+++ /dev/null
@@ -1,7 +0,0 @@
-<?php
-
-$stark = 'Arya';
-
-// BEGIN
-print_r("Do you want to eat, {$stark}?");
-// END
diff --git a/modules/30-variables/25-interpolation/ru/EXERCISE.md b/modules/30-variables/25-interpolation/ru/EXERCISE.md
deleted file mode 100644
index 5933ce12..00000000
--- a/modules/30-variables/25-interpolation/ru/EXERCISE.md
+++ /dev/null
@@ -1,5 +0,0 @@
-Выведите на экран строку `Do you want to eat, <name>?`. Где вместо `<name>` должна использоваться переменная `$stark`. Вывод должен получиться таким:
-
-```text
-Do you want to eat, Arya?
-```
diff --git a/modules/30-variables/25-interpolation/ru/README.md b/modules/30-variables/25-interpolation/ru/README.md
deleted file mode 100644
index f867779a..00000000
--- a/modules/30-variables/25-interpolation/ru/README.md
+++ /dev/null
@@ -1,34 +0,0 @@
-Представим, что нам нужно создать заголовок письма из двух переменных и знаков препинания. Эту задачу можно решить так:
-
-```php
-<?php
-
-$firstName = 'Joffrey';
-$greeting = 'Hello';
-
-print_r($greeting . ", " . $firstName . "!"); // => 'Hello, Joffrey!'
-```
-
-Это простой случай, но даже здесь нужно приложить усилия, чтобы увидеть, какая в итоге получится строка. Нужно следить за несколькими кавычками и пробелами, и с первого взгляда сложно понять, что и где начинается и заканчивается.
-
-Есть другой более удобный способ — **интерполяция**. Так это выглядит:
-
-```php
-<?php
-
-$firstName = 'Joffrey';
-$greeting = 'Hello';
-
-// Обратите внимание на ограничители строки — это двойные кавычки
-// Интерполяция не работает с одинарными кавычками
-print_r("{$greeting}, {$firstName}!"); // => Hello, Joffrey!
-```
-
-
-В этом примере мы создали одну строку и в нужном нам порядке вставили в нее переменные с помощью фигурных скобок (`{}`). Получился шаблон, куда внесены нужные значения.
-
-Теперь нам не нужно заботиться об отдельных строках для знаков препинания и пробелов. Эти символы записаны в строке-шаблоне.
-
-В одной строке можно делать сколько угодно блоков с фигурными скобками. Также интерполяция работает только со строками в двойных кавычках.
-
-Почти во всех языках интерполяция предпочтительнее конкатенации для объединения строк. Строка при этом получается склеенная, и внутри нее хорошо просматриваются пробелы и другие символы.
diff --git a/modules/30-variables/25-interpolation/ru/data.yml b/modules/30-variables/25-interpolation/ru/data.yml
deleted file mode 100644
index 390eab8f..00000000
--- a/modules/30-variables/25-interpolation/ru/data.yml
+++ /dev/null
@@ -1,8 +0,0 @@
----
-name: Интерполяция
-tips: []
-definitions:
-  - name: Интерполяция
-    description: >-
-      способ соединения строк через вставку значений переменных в строку-шаблон
-      с помощью фигурных скобок. Например, `\"Hi, {$name}!\"`.
diff --git a/modules/30-variables/30-symbols/SolutionTest.php b/modules/30-variables/30-symbols/SolutionTest.php
deleted file mode 100644
index 6a54da1a..00000000
--- a/modules/30-variables/30-symbols/SolutionTest.php
+++ /dev/null
@@ -1,17 +0,0 @@
-<?php
-
-namespace HexletBasics\Variables\Symbols;
-
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        $expected = 'hodor';
-        $this->expectOutputString($expected);
-        require 'index.php';
-    }
-}
diff --git a/modules/30-variables/30-symbols/index.php b/modules/30-variables/30-symbols/index.php
deleted file mode 100644
index c43db9c7..00000000
--- a/modules/30-variables/30-symbols/index.php
+++ /dev/null
@@ -1,9 +0,0 @@
-<?php
-
-$one = 'Naharis';
-$two = 'Mormont';
-$three = 'Sand';
-
-// BEGIN
-print_r("{$one[2]}{$two[1]}{$three[3]}{$two[4]}{$two[2]}");
-// END
diff --git a/modules/30-variables/30-symbols/ru/EXERCISE.md b/modules/30-variables/30-symbols/ru/EXERCISE.md
deleted file mode 100644
index 58ea64b3..00000000
--- a/modules/30-variables/30-symbols/ru/EXERCISE.md
+++ /dev/null
@@ -1,9 +0,0 @@
-Вам даны три переменные с фамилиями разных людей. Составьте и выведите на экран слово из символов в таком порядке:
-
-1. Третий символ из первой строки.
-2. Второй символ из второй строки.
-3. Четвертый символ из третьей строки.
-4. Пятый символ из второй строки.
-5. Третий символ из второй строки.
-
-Попробуйте использовать интерполяцию: внутри фигурных скобок можно помещать не только целые переменные, но и отдельные символы с помощью квадратных скобок.
diff --git a/modules/30-variables/30-symbols/ru/README.md b/modules/30-variables/30-symbols/ru/README.md
deleted file mode 100644
index cbe8ac7d..00000000
--- a/modules/30-variables/30-symbols/ru/README.md
+++ /dev/null
@@ -1,49 +0,0 @@
-В этом уроке мы научимся получать из строки конкретный символ. Например, если сайт знает имя и фамилию пользователя, и в какой-то момент требуется вывести эту информацию в формате `A. Ivanov`. В этом случае нужно взять первый символ из имени:
-
-```php
-<?php
-
-$firstName = 'Alexander';
-
-print_r($firstName[0]); // => A
-```
-
-Квадратные скобки с цифрой — это специальный оператор извлечения строки. Эта цифра называется **индексом** — позицией символа внутри строки.
-
-Индексы начинаются с нуля почти во всех языках программирования. Чтобы получить первый символ, нужно указать индекс `0`. Индекс последнего элемента равен длине строки минус единица:
-
-```php
-<?php
-
-$firstName = 'Alexander';
-
-// Длина строки 9, поэтому последний индекс — это 8
-print_r($firstName[8]);  // => r
-
-// Вопрос на самопроверку. Что выведет этот код?
-$magic = '\nyou';
-print_r($magic[1]); // => ?
-```
-
-Также допустимо использовать отрицательные индексы. В этом случае идет обращение к символам с конца строки. `-1` — индекс последнего символа, `-2` — предпоследнего и так далее. В отличие от прямой индексации обратный отсчет идет от `-1`:
-
-```php
-<?php
-
-$firstName = 'Alexander';
-
-print_r($firstName[-1]); // => r
-```
-
-Индексом может быть не только конкретное число, но и значение переменной. Вот пример, который приведет к тому же результату — выводу на экран символа `A`:
-
-```php
-<?php
-
-$firstName = 'Alexander';
-$index = 0;
-
-print_r($firstName[$index]); // => A
-```
-
-Здесь индекс внутри квадратных скобок записан не числом, а переменной.
diff --git a/modules/30-variables/30-symbols/ru/data.yml b/modules/30-variables/30-symbols/ru/data.yml
deleted file mode 100644
index 405090b7..00000000
--- a/modules/30-variables/30-symbols/ru/data.yml
+++ /dev/null
@@ -1,3 +0,0 @@
----
-name: Извлечение символов из строки
-tips: []
diff --git a/modules/30-variables/35-heredoc/SolutionTest.php b/modules/30-variables/35-heredoc/SolutionTest.php
deleted file mode 100644
index e11976b3..00000000
--- a/modules/30-variables/35-heredoc/SolutionTest.php
+++ /dev/null
@@ -1,20 +0,0 @@
-<?php
-
-namespace HexletBasics\Variables\Heredoc;
-
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        $expected = <<<EOT
-Lannister, Targaryen, Baratheon, Stark, Tyrell... they're all just spokes on a wheel.
-This one's on top, then that one's on top, and on and on it spins, crushing those on the ground.
-EOT;
-        $this->expectOutputString($expected);
-        require 'index.php';
-    }
-}
diff --git a/modules/30-variables/35-heredoc/index.php b/modules/30-variables/35-heredoc/index.php
deleted file mode 100644
index 4fdcf328..00000000
--- a/modules/30-variables/35-heredoc/index.php
+++ /dev/null
@@ -1,10 +0,0 @@
-<?php
-
-// BEGIN
-$str = <<<EOT
-Lannister, Targaryen, Baratheon, Stark, Tyrell... they're all just spokes on a wheel.
-This one's on top, then that one's on top, and on and on it spins, crushing those on the ground.
-EOT;
-// END
-
-print_r($str);
diff --git a/modules/30-variables/35-heredoc/ru/EXERCISE.md b/modules/30-variables/35-heredoc/ru/EXERCISE.md
deleted file mode 100644
index cf047077..00000000
--- a/modules/30-variables/35-heredoc/ru/EXERCISE.md
+++ /dev/null
@@ -1,5 +0,0 @@
-
-Запишите в переменную `$str` текст, который приведен ниже. Используйте heredoc-синтаксис.
-
-    Lannister, Targaryen, Baratheon, Stark, Tyrell... they're all just spokes on a wheel.
-    This one's on top, then that one's on top, and on and on it spins, crushing those on the ground.
diff --git a/modules/30-variables/35-heredoc/ru/README.md b/modules/30-variables/35-heredoc/ru/README.md
deleted file mode 100644
index f15bc171..00000000
--- a/modules/30-variables/35-heredoc/ru/README.md
+++ /dev/null
@@ -1,19 +0,0 @@
-Определять строки в PHP можно с помощью специального heredoc-синтаксиса. После оператора `<<<` необходимо указать идентификатор с произвольным именем, затем перевод строки и саму строку. В конце добавляется тот же идентификатор, который закрывает вставку. Такой способ удобен для задания длинных строк, внутри которых встречаются и переводы строк, и разнотипные кавычки:
-
-```php
-<?php
-
-$str = <<<EOT
-Пример строки,
-охватывающей несколько строк,
-с использованием heredoc-синтаксиса.
-Здесь не нужно экранировать ни одинарные ', ни двойные " кавычки.
-EOT;
-print_r($str);
-// => Пример строки,
-// => охватывающей несколько строк,
-// => с использованием heredoc-синтаксиса.
-// => Здесь не нужно экранировать ни одинарные ', ни двойные " кавычки.
-```
-
-Перед закрывающим идентификатором, в нашем случае — `EOT`, не должны стоять пробелы, иначе PHP начнет ругаться на ошибку синтаксиса.
diff --git a/modules/30-variables/35-heredoc/ru/data.yml b/modules/30-variables/35-heredoc/ru/data.yml
deleted file mode 100644
index fd50d7c2..00000000
--- a/modules/30-variables/35-heredoc/ru/data.yml
+++ /dev/null
@@ -1,6 +0,0 @@
----
-name: Heredoc
-definitions: []
-tips:
-  - >
-    [Heredoc](https://www.php.net/manual/ru/language.types.string.php#language.types.string.syntax.heredoc)
diff --git a/modules/30-variables/24-magic-constants/Makefile b/modules/31-advanced-strings/100-unicode/Makefile
similarity index 100%
rename from modules/30-variables/24-magic-constants/Makefile
rename to modules/31-advanced-strings/100-unicode/Makefile
diff --git a/modules/31-advanced-strings/100-unicode/Solution.php b/modules/31-advanced-strings/100-unicode/Solution.php
new file mode 100644
index 00000000..a34687e0
--- /dev/null
+++ b/modules/31-advanced-strings/100-unicode/Solution.php
@@ -0,0 +1,6 @@
+<?php
+
+// BEGIN
+print_r(strlen('Привет!') . "\n");
+print_r(mb_strlen('Привет!') . "\n");
+// END
diff --git a/modules/10-basics/30-comments/SolutionTest.php b/modules/31-advanced-strings/100-unicode/SolutionTest.php
similarity index 51%
rename from modules/10-basics/30-comments/SolutionTest.php
rename to modules/31-advanced-strings/100-unicode/SolutionTest.php
index d9f63d8e..f0ba2ef6 100644
--- a/modules/10-basics/30-comments/SolutionTest.php
+++ b/modules/31-advanced-strings/100-unicode/SolutionTest.php
@@ -1,15 +1,14 @@
 <?php
 
-namespace HexletBasics\Basics\Comments;
+namespace HexletBasics\AdvancedStrings\Unicode;
 
-use PHPUnit\Framework\TestCase;
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        $expected = '';
+        $expected = "13\n7\n";
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/60-deep-into-strings/10-unicode/description.es.yml b/modules/31-advanced-strings/100-unicode/description.es.yml
similarity index 100%
rename from modules/60-deep-into-strings/10-unicode/description.es.yml
rename to modules/31-advanced-strings/100-unicode/description.es.yml
diff --git a/modules/60-deep-into-strings/10-unicode/en/EXERCISE.md b/modules/31-advanced-strings/100-unicode/en/EXERCISE.md
similarity index 100%
rename from modules/60-deep-into-strings/10-unicode/en/EXERCISE.md
rename to modules/31-advanced-strings/100-unicode/en/EXERCISE.md
diff --git a/modules/60-deep-into-strings/10-unicode/en/README.md b/modules/31-advanced-strings/100-unicode/en/README.md
similarity index 100%
rename from modules/60-deep-into-strings/10-unicode/en/README.md
rename to modules/31-advanced-strings/100-unicode/en/README.md
diff --git a/modules/60-deep-into-strings/10-unicode/en/data.yml b/modules/31-advanced-strings/100-unicode/en/data.yml
similarity index 100%
rename from modules/60-deep-into-strings/10-unicode/en/data.yml
rename to modules/31-advanced-strings/100-unicode/en/data.yml
diff --git a/modules/60-deep-into-strings/10-unicode/es/EXERCISE.md b/modules/31-advanced-strings/100-unicode/es/EXERCISE.md
similarity index 100%
rename from modules/60-deep-into-strings/10-unicode/es/EXERCISE.md
rename to modules/31-advanced-strings/100-unicode/es/EXERCISE.md
diff --git a/modules/60-deep-into-strings/10-unicode/es/README.md b/modules/31-advanced-strings/100-unicode/es/README.md
similarity index 100%
rename from modules/60-deep-into-strings/10-unicode/es/README.md
rename to modules/31-advanced-strings/100-unicode/es/README.md
diff --git a/modules/60-deep-into-strings/10-unicode/es/data.yml b/modules/31-advanced-strings/100-unicode/es/data.yml
similarity index 100%
rename from modules/60-deep-into-strings/10-unicode/es/data.yml
rename to modules/31-advanced-strings/100-unicode/es/data.yml
diff --git a/modules/31-advanced-strings/100-unicode/ru/EXERCISE.md b/modules/31-advanced-strings/100-unicode/ru/EXERCISE.md
new file mode 100644
index 00000000..7b9bbbca
--- /dev/null
+++ b/modules/31-advanced-strings/100-unicode/ru/EXERCISE.md
@@ -0,0 +1,3 @@
+Выведите на экран длину строки `Привет!` двумя способами: сначала с помощью функции `strlen()`, затем — `mb_strlen()`. Каждое значение должно быть на своей строке.
+
+Так вы своими глазами увидите разницу между количеством байтов и количеством символов в юникод-строке.
diff --git a/modules/60-deep-into-strings/10-unicode/ru/README.md b/modules/31-advanced-strings/100-unicode/ru/README.md
similarity index 95%
rename from modules/60-deep-into-strings/10-unicode/ru/README.md
rename to modules/31-advanced-strings/100-unicode/ru/README.md
index e0eecfae..4f1e9583 100644
--- a/modules/60-deep-into-strings/10-unicode/ru/README.md
+++ b/modules/31-advanced-strings/100-unicode/ru/README.md
@@ -1,4 +1,4 @@
-Данные программы хранятся в памяти компьютера в виде последовательности нулей и единиц. На этом уровне нет разницы между строками, числами или булевыми значениями. В памяти все выглядит одинаково. Разница появляется только в результате интерпретации.
+Данные программы хранятся в памяти компьютера в виде последовательности нулей и единиц. На этом уровне нет разницы между строками и числами. В памяти все выглядит одинаково. Разница появляется только в результате интерпретации.
 
 Программа знает, что внутри некоторой переменной хранится строка, поэтому она берет нули и единички и пропускает их сквозь кодовую таблицу. В ней указано, какому числу соответствует какая буква. В результате программист видит строку. В этом уроке мы обсудим, как работают такие кодовые таблицы.
 
@@ -42,7 +42,7 @@
 ```php
 <?php
 
-echo strlen('Привет!'); // => 13
+print_r(strlen('Привет!')); // => 13
 ```
 
 Языки разделились на два лагеря. Одни языки встроили поддержку в уже существующие функции — в итоге переход на UTF-8 никак не отразился на процессе программирования. Среди таких языков есть Java, Ruby, JavaScript.
@@ -52,7 +52,7 @@ echo strlen('Привет!'); // => 13
 ```php
 <?php
 
-echo mb_strlen('Привет!'); // => 7
+print_r(mb_strlen('Привет!')); // => 7
 ```
 
 А вот достойной альтернативы взятию конкретного символа в строке по индексу не существует. Такую задачу нужно выполнять с помощью функции `mb_substr()`:
diff --git a/modules/60-deep-into-strings/10-unicode/ru/data.yml b/modules/31-advanced-strings/100-unicode/ru/data.yml
similarity index 100%
rename from modules/60-deep-into-strings/10-unicode/ru/data.yml
rename to modules/31-advanced-strings/100-unicode/ru/data.yml
diff --git a/modules/30-variables/25-interpolation/Makefile b/modules/31-advanced-strings/110-locales/Makefile
similarity index 100%
rename from modules/30-variables/25-interpolation/Makefile
rename to modules/31-advanced-strings/110-locales/Makefile
diff --git a/modules/60-deep-into-strings/30-locales/index.php b/modules/31-advanced-strings/110-locales/Solution.php
similarity index 100%
rename from modules/60-deep-into-strings/30-locales/index.php
rename to modules/31-advanced-strings/110-locales/Solution.php
diff --git a/modules/60-deep-into-strings/30-locales/SolutionTest.php b/modules/31-advanced-strings/110-locales/SolutionTest.php
similarity index 62%
rename from modules/60-deep-into-strings/30-locales/SolutionTest.php
rename to modules/31-advanced-strings/110-locales/SolutionTest.php
index 117c8d06..358fc408 100644
--- a/modules/60-deep-into-strings/30-locales/SolutionTest.php
+++ b/modules/31-advanced-strings/110-locales/SolutionTest.php
@@ -1,8 +1,8 @@
 <?php
 
-namespace HexletBasics\DeepIntoStrings\Locales;
+namespace HexletBasics\AdvancedStrings\Locales;
 
-use PHPUnit\Framework\TestCase;
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
@@ -10,6 +10,5 @@ public function test()
     {
         $expected = setlocale(LC_CTYPE, 0);
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/60-deep-into-strings/30-locales/description.es.yml b/modules/31-advanced-strings/110-locales/description.es.yml
similarity index 100%
rename from modules/60-deep-into-strings/30-locales/description.es.yml
rename to modules/31-advanced-strings/110-locales/description.es.yml
diff --git a/modules/60-deep-into-strings/30-locales/en/EXERCISE.md b/modules/31-advanced-strings/110-locales/en/EXERCISE.md
similarity index 100%
rename from modules/60-deep-into-strings/30-locales/en/EXERCISE.md
rename to modules/31-advanced-strings/110-locales/en/EXERCISE.md
diff --git a/modules/60-deep-into-strings/30-locales/en/README.md b/modules/31-advanced-strings/110-locales/en/README.md
similarity index 100%
rename from modules/60-deep-into-strings/30-locales/en/README.md
rename to modules/31-advanced-strings/110-locales/en/README.md
diff --git a/modules/60-deep-into-strings/30-locales/en/data.yml b/modules/31-advanced-strings/110-locales/en/data.yml
similarity index 100%
rename from modules/60-deep-into-strings/30-locales/en/data.yml
rename to modules/31-advanced-strings/110-locales/en/data.yml
diff --git a/modules/60-deep-into-strings/30-locales/es/EXERCISE.md b/modules/31-advanced-strings/110-locales/es/EXERCISE.md
similarity index 100%
rename from modules/60-deep-into-strings/30-locales/es/EXERCISE.md
rename to modules/31-advanced-strings/110-locales/es/EXERCISE.md
diff --git a/modules/60-deep-into-strings/30-locales/es/README.md b/modules/31-advanced-strings/110-locales/es/README.md
similarity index 100%
rename from modules/60-deep-into-strings/30-locales/es/README.md
rename to modules/31-advanced-strings/110-locales/es/README.md
diff --git a/modules/60-deep-into-strings/30-locales/es/data.yml b/modules/31-advanced-strings/110-locales/es/data.yml
similarity index 100%
rename from modules/60-deep-into-strings/30-locales/es/data.yml
rename to modules/31-advanced-strings/110-locales/es/data.yml
diff --git a/modules/60-deep-into-strings/30-locales/ru/EXERCISE.md b/modules/31-advanced-strings/110-locales/ru/EXERCISE.md
similarity index 100%
rename from modules/60-deep-into-strings/30-locales/ru/EXERCISE.md
rename to modules/31-advanced-strings/110-locales/ru/EXERCISE.md
diff --git a/modules/60-deep-into-strings/30-locales/ru/README.md b/modules/31-advanced-strings/110-locales/ru/README.md
similarity index 100%
rename from modules/60-deep-into-strings/30-locales/ru/README.md
rename to modules/31-advanced-strings/110-locales/ru/README.md
diff --git a/modules/60-deep-into-strings/30-locales/ru/data.yml b/modules/31-advanced-strings/110-locales/ru/data.yml
similarity index 100%
rename from modules/60-deep-into-strings/30-locales/ru/data.yml
rename to modules/31-advanced-strings/110-locales/ru/data.yml
diff --git a/modules/30-variables/30-symbols/Makefile b/modules/31-advanced-strings/120-startwith/Makefile
similarity index 100%
rename from modules/30-variables/30-symbols/Makefile
rename to modules/31-advanced-strings/120-startwith/Makefile
diff --git a/modules/31-advanced-strings/120-startwith/Solution.php b/modules/31-advanced-strings/120-startwith/Solution.php
new file mode 100644
index 00000000..32cf84d6
--- /dev/null
+++ b/modules/31-advanced-strings/120-startwith/Solution.php
@@ -0,0 +1,5 @@
+<?php
+
+// BEGIN
+print_r(mb_strpos('https://hexlet.io/courses', 'courses'));
+// END
diff --git a/modules/70-dates/40-timezone/SolutionTest.php b/modules/31-advanced-strings/120-startwith/SolutionTest.php
similarity index 51%
rename from modules/70-dates/40-timezone/SolutionTest.php
rename to modules/31-advanced-strings/120-startwith/SolutionTest.php
index 2f654688..1c62e406 100644
--- a/modules/70-dates/40-timezone/SolutionTest.php
+++ b/modules/31-advanced-strings/120-startwith/SolutionTest.php
@@ -1,15 +1,14 @@
 <?php
 
-namespace HexletBasics\Loops\Timezone;
+namespace HexletBasics\AdvancedStrings\StartWith;
 
-use PHPUnit\Framework\TestCase;
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        $expected = 'UTC';
+        $expected = '18';
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/60-deep-into-strings/40-startwith/description.es.yml b/modules/31-advanced-strings/120-startwith/description.es.yml
similarity index 100%
rename from modules/60-deep-into-strings/40-startwith/description.es.yml
rename to modules/31-advanced-strings/120-startwith/description.es.yml
diff --git a/modules/60-deep-into-strings/40-startwith/en/EXERCISE.md b/modules/31-advanced-strings/120-startwith/en/EXERCISE.md
similarity index 100%
rename from modules/60-deep-into-strings/40-startwith/en/EXERCISE.md
rename to modules/31-advanced-strings/120-startwith/en/EXERCISE.md
diff --git a/modules/60-deep-into-strings/40-startwith/en/README.md b/modules/31-advanced-strings/120-startwith/en/README.md
similarity index 100%
rename from modules/60-deep-into-strings/40-startwith/en/README.md
rename to modules/31-advanced-strings/120-startwith/en/README.md
diff --git a/modules/60-deep-into-strings/40-startwith/en/data.yml b/modules/31-advanced-strings/120-startwith/en/data.yml
similarity index 100%
rename from modules/60-deep-into-strings/40-startwith/en/data.yml
rename to modules/31-advanced-strings/120-startwith/en/data.yml
diff --git a/modules/60-deep-into-strings/40-startwith/es/EXERCISE.md b/modules/31-advanced-strings/120-startwith/es/EXERCISE.md
similarity index 100%
rename from modules/60-deep-into-strings/40-startwith/es/EXERCISE.md
rename to modules/31-advanced-strings/120-startwith/es/EXERCISE.md
diff --git a/modules/60-deep-into-strings/40-startwith/es/README.md b/modules/31-advanced-strings/120-startwith/es/README.md
similarity index 100%
rename from modules/60-deep-into-strings/40-startwith/es/README.md
rename to modules/31-advanced-strings/120-startwith/es/README.md
diff --git a/modules/60-deep-into-strings/40-startwith/es/data.yml b/modules/31-advanced-strings/120-startwith/es/data.yml
similarity index 100%
rename from modules/60-deep-into-strings/40-startwith/es/data.yml
rename to modules/31-advanced-strings/120-startwith/es/data.yml
diff --git a/modules/31-advanced-strings/120-startwith/ru/EXERCISE.md b/modules/31-advanced-strings/120-startwith/ru/EXERCISE.md
new file mode 100644
index 00000000..623d938c
--- /dev/null
+++ b/modules/31-advanced-strings/120-startwith/ru/EXERCISE.md
@@ -0,0 +1,3 @@
+В программе нужно вырезать из адреса `https://hexlet.io/courses` имя раздела. Первый шаг — узнать, где оно начинается.
+
+Выведите на экран позицию, с которой в строке `https://hexlet.io/courses` начинается подстрока `courses`. Используйте функцию `mb_strpos()`.
diff --git a/modules/31-advanced-strings/120-startwith/ru/README.md b/modules/31-advanced-strings/120-startwith/ru/README.md
new file mode 100644
index 00000000..292ec10c
--- /dev/null
+++ b/modules/31-advanced-strings/120-startwith/ru/README.md
@@ -0,0 +1,27 @@
+Часто в работе со строками нужно определить, входит ли одна строка — **подстрока** — в другую, и если входит, то где. Для этого в PHP есть функция [mb_strpos()](https://php.net/manual/ru/function.mb-strpos.php). Она ищет позицию первого вхождения одной строки в другую:
+
+```php
+<?php
+
+print_r(mb_strpos('Валар Моргулис', 'Моргулис')); // => 6
+```
+
+Функция вернула `6` — индекс буквы `М`, с которой начинается подстрока. Индексы, как обычно, отсчитываются с нуля:
+
+```php
+<?php
+
+print_r(mb_strpos('Валар Моргулис', 'Валар')); // => 0
+```
+
+Здесь вернулся `0`: подстрока найдена в самом начале строки.
+
+Если же подстрока не найдена, `mb_strpos()` возвращает специальное значение `false` — «ложь». При выводе через `print_r()` оно выглядит как пустая строка:
+
+```php
+<?php
+
+print_r(mb_strpos('Валар Моргулис', 'Дракарис')); // =>
+```
+
+Здесь скрыта ловушка, в которую часто попадают новички: результат `0` («найдено в начале строки») легко спутать с `false` («не найдено вообще»). Чтобы различать их, нужно строгое сравнение — мы разберем его в уроках про логику. А пока запомните: `mb_strpos()` отвечает на вопрос «где?», а не «есть ли?».
diff --git a/modules/60-deep-into-strings/40-startwith/ru/data.yml b/modules/31-advanced-strings/120-startwith/ru/data.yml
similarity index 100%
rename from modules/60-deep-into-strings/40-startwith/ru/data.yml
rename to modules/31-advanced-strings/120-startwith/ru/data.yml
diff --git a/modules/35-calling-functions/120-function-signature/Makefile b/modules/31-advanced-strings/25-interpolation/Makefile
similarity index 100%
rename from modules/35-calling-functions/120-function-signature/Makefile
rename to modules/31-advanced-strings/25-interpolation/Makefile
diff --git a/modules/31-advanced-strings/25-interpolation/Solution.php b/modules/31-advanced-strings/25-interpolation/Solution.php
new file mode 100644
index 00000000..f90f5d6d
--- /dev/null
+++ b/modules/31-advanced-strings/25-interpolation/Solution.php
@@ -0,0 +1,8 @@
+<?php
+
+$username = 'Анна';
+$orderNumber = 1337;
+
+// BEGIN
+print_r("Здравствуйте, {$username}! Ваш заказ #{$orderNumber} принят.");
+// END
diff --git a/modules/31-advanced-strings/25-interpolation/SolutionTest.php b/modules/31-advanced-strings/25-interpolation/SolutionTest.php
new file mode 100644
index 00000000..1be5d35f
--- /dev/null
+++ b/modules/31-advanced-strings/25-interpolation/SolutionTest.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace HexletBasics\AdvancedStrings\Interpolation;
+
+use HexletBasics\Exercise\TestCase;
+
+class SolutionTest extends TestCase
+{
+    public function test()
+    {
+        $expected = 'Здравствуйте, Анна! Ваш заказ #1337 принят.';
+        $this->expectOutputString($expected);
+    }
+}
diff --git a/modules/30-variables/25-interpolation/description.es.yml b/modules/31-advanced-strings/25-interpolation/description.es.yml
similarity index 100%
rename from modules/30-variables/25-interpolation/description.es.yml
rename to modules/31-advanced-strings/25-interpolation/description.es.yml
diff --git a/modules/30-variables/25-interpolation/en/EXERCISE.md b/modules/31-advanced-strings/25-interpolation/en/EXERCISE.md
similarity index 100%
rename from modules/30-variables/25-interpolation/en/EXERCISE.md
rename to modules/31-advanced-strings/25-interpolation/en/EXERCISE.md
diff --git a/modules/30-variables/25-interpolation/en/README.md b/modules/31-advanced-strings/25-interpolation/en/README.md
similarity index 100%
rename from modules/30-variables/25-interpolation/en/README.md
rename to modules/31-advanced-strings/25-interpolation/en/README.md
diff --git a/modules/30-variables/25-interpolation/en/data.yml b/modules/31-advanced-strings/25-interpolation/en/data.yml
similarity index 100%
rename from modules/30-variables/25-interpolation/en/data.yml
rename to modules/31-advanced-strings/25-interpolation/en/data.yml
diff --git a/modules/30-variables/25-interpolation/es/EXERCISE.md b/modules/31-advanced-strings/25-interpolation/es/EXERCISE.md
similarity index 100%
rename from modules/30-variables/25-interpolation/es/EXERCISE.md
rename to modules/31-advanced-strings/25-interpolation/es/EXERCISE.md
diff --git a/modules/30-variables/25-interpolation/es/README.md b/modules/31-advanced-strings/25-interpolation/es/README.md
similarity index 100%
rename from modules/30-variables/25-interpolation/es/README.md
rename to modules/31-advanced-strings/25-interpolation/es/README.md
diff --git a/modules/30-variables/25-interpolation/es/data.yml b/modules/31-advanced-strings/25-interpolation/es/data.yml
similarity index 100%
rename from modules/30-variables/25-interpolation/es/data.yml
rename to modules/31-advanced-strings/25-interpolation/es/data.yml
diff --git a/modules/31-advanced-strings/25-interpolation/ru/EXERCISE.md b/modules/31-advanced-strings/25-interpolation/ru/EXERCISE.md
new file mode 100644
index 00000000..091a230d
--- /dev/null
+++ b/modules/31-advanced-strings/25-interpolation/ru/EXERCISE.md
@@ -0,0 +1,7 @@
+Интернет-магазин отправляет покупателю подтверждение заказа. Имя покупателя и номер заказа уже хранятся в переменных — нужно подставить их в шаблон сообщения с помощью интерполяции.
+
+Используйте переменные `$username` и `$orderNumber`, чтобы вывести на экран:
+
+```text
+Здравствуйте, Анна! Ваш заказ #1337 принят.
+```
diff --git a/modules/31-advanced-strings/25-interpolation/ru/README.md b/modules/31-advanced-strings/25-interpolation/ru/README.md
new file mode 100644
index 00000000..f6a05e19
--- /dev/null
+++ b/modules/31-advanced-strings/25-interpolation/ru/README.md
@@ -0,0 +1,81 @@
+Вспомним, как работает конкатенация. Для этого мы соединяем нужные строки (или переменные со строками внутри) с помощью точки `.`.
+
+```php
+<?php
+
+$firstName = 'Joffrey';
+$greeting = 'Hello';
+
+print_r($greeting . ", " . $firstName . "!");
+// => Hello, Joffrey!
+```
+
+Но при этом в сложных выражениях становится трудно сразу увидеть, какой текст получится на выходе. Особенно если в строке используются пробелы, запятые или кавычки: они начинают мешать восприятию. Даже текущий пример требует небольшого напряжения, чтобы понять, какая получится строка.
+
+По этой причине во многих языках существует операция, которая называется интерполяцией. Интерполяция представляет собой способ встраивать значения переменных прямо внутрь строки. В PHP она работает в строках с двойными кавычками. Вот так:
+
+```php
+<?php
+
+$firstName = 'Joffrey';
+$greeting = 'Hello';
+
+print_r("{$greeting}, {$firstName}!");
+// => Hello, Joffrey!
+```
+
+Имена переменных записываются внутри строки в фигурных скобках, и PHP автоматически подставляет нужные значения:
+
+```text
+$firstName = 'Joff'
+$greeting  = 'Hello'
+
+"{$greeting}, {$firstName}!"
+  └────┬────┘  └────┬─────┘
+   'Hello'      'Joff'
+      └──────┬──────┘
+      'Hello, Joff!'
+```
+
+Сравните эти два примера рядом:
+
+```php
+<?php
+
+print_r($greeting . ", " . $firstName . "!");
+print_r("{$greeting}, {$firstName}!");
+```
+
+Второй вариант проще и понятнее.
+
+В одной строке можно делать сколько угодно блоков с фигурными скобками. Важно помнить: интерполяция работает только в двойных кавычках. Строка в одинарных кавычках выводится как есть, без подстановки значений:
+
+```php
+<?php
+
+$firstName = 'Joffrey';
+
+print_r('Hello, {$firstName}!');
+// => Hello, {$firstName}!
+```
+
+## Пример
+
+```php
+<?php
+
+$school = 'Hexlet';
+
+$whatIsIt = "{$school} - online courses";
+print_r($whatIsIt); // => Hexlet - online courses
+```
+
+Такая запись легко читается: пробелы, дефисы и символы видны сразу. Строка выглядит именно так, как она появится в выводе. Это делает код понятным и удобным в поддержке. По этой причине в большинстве языков интерполяция является более предпочтительной, чем конкатенация.
+
+## Почему это важно
+
+Интерполяция предпочтительнее конкатенации почти во всех современных языках программирования. Она:
+
+- Упрощает структуру строк.
+- Улучшает читаемость кода.
+- Снижает количество ошибок при работе с пробелами и знаками препинания.
diff --git a/modules/31-advanced-strings/25-interpolation/ru/data.yml b/modules/31-advanced-strings/25-interpolation/ru/data.yml
new file mode 100644
index 00000000..8dc1df0e
--- /dev/null
+++ b/modules/31-advanced-strings/25-interpolation/ru/data.yml
@@ -0,0 +1,11 @@
+---
+name: Интерполяция
+tips:
+  - >
+    [Интерполяция строк в
+    PHP](https://www.php.net/manual/ru/language.types.string.php#language.types.string.parsing)
+definitions:
+  - name: Интерполяция
+    description: >-
+      способ получения сложной строки из нескольких простых с использованием
+      специальных шаблонов. Например, `\"Hi, {$name}!\"`.
diff --git a/modules/35-calling-functions/135-calling-functions-default-arguments/Makefile b/modules/31-advanced-strings/30-symbols/Makefile
similarity index 100%
rename from modules/35-calling-functions/135-calling-functions-default-arguments/Makefile
rename to modules/31-advanced-strings/30-symbols/Makefile
diff --git a/modules/31-advanced-strings/30-symbols/Solution.php b/modules/31-advanced-strings/30-symbols/Solution.php
new file mode 100644
index 00000000..800066a9
--- /dev/null
+++ b/modules/31-advanced-strings/30-symbols/Solution.php
@@ -0,0 +1,7 @@
+<?php
+
+$text = 'PHP programming';
+
+// BEGIN
+print_r($text[7] . $text[8] . $text[12] . $text[4]);
+// END
diff --git a/modules/31-advanced-strings/30-symbols/SolutionTest.php b/modules/31-advanced-strings/30-symbols/SolutionTest.php
new file mode 100644
index 00000000..f94cbb73
--- /dev/null
+++ b/modules/31-advanced-strings/30-symbols/SolutionTest.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace HexletBasics\AdvancedStrings\Symbols;
+
+use HexletBasics\Exercise\TestCase;
+
+class SolutionTest extends TestCase
+{
+    public function test()
+    {
+        $expected = 'grip';
+        $this->expectOutputString($expected);
+    }
+}
diff --git a/modules/30-variables/30-symbols/description.es.yml b/modules/31-advanced-strings/30-symbols/description.es.yml
similarity index 100%
rename from modules/30-variables/30-symbols/description.es.yml
rename to modules/31-advanced-strings/30-symbols/description.es.yml
diff --git a/modules/30-variables/30-symbols/en/EXERCISE.md b/modules/31-advanced-strings/30-symbols/en/EXERCISE.md
similarity index 100%
rename from modules/30-variables/30-symbols/en/EXERCISE.md
rename to modules/31-advanced-strings/30-symbols/en/EXERCISE.md
diff --git a/modules/30-variables/30-symbols/en/README.md b/modules/31-advanced-strings/30-symbols/en/README.md
similarity index 100%
rename from modules/30-variables/30-symbols/en/README.md
rename to modules/31-advanced-strings/30-symbols/en/README.md
diff --git a/modules/30-variables/30-symbols/en/data.yml b/modules/31-advanced-strings/30-symbols/en/data.yml
similarity index 100%
rename from modules/30-variables/30-symbols/en/data.yml
rename to modules/31-advanced-strings/30-symbols/en/data.yml
diff --git a/modules/30-variables/30-symbols/es/EXERCISE.md b/modules/31-advanced-strings/30-symbols/es/EXERCISE.md
similarity index 100%
rename from modules/30-variables/30-symbols/es/EXERCISE.md
rename to modules/31-advanced-strings/30-symbols/es/EXERCISE.md
diff --git a/modules/30-variables/30-symbols/es/README.md b/modules/31-advanced-strings/30-symbols/es/README.md
similarity index 100%
rename from modules/30-variables/30-symbols/es/README.md
rename to modules/31-advanced-strings/30-symbols/es/README.md
diff --git a/modules/30-variables/30-symbols/es/data.yml b/modules/31-advanced-strings/30-symbols/es/data.yml
similarity index 100%
rename from modules/30-variables/30-symbols/es/data.yml
rename to modules/31-advanced-strings/30-symbols/es/data.yml
diff --git a/modules/31-advanced-strings/30-symbols/ru/EXERCISE.md b/modules/31-advanced-strings/30-symbols/ru/EXERCISE.md
new file mode 100644
index 00000000..7cf55f2b
--- /dev/null
+++ b/modules/31-advanced-strings/30-symbols/ru/EXERCISE.md
@@ -0,0 +1 @@
+В переменной `$text` спрятано секретное слово. Извлеките нужные символы из переменной по индексам, соедините их и выведите на экран слово `grip`.
diff --git a/modules/31-advanced-strings/30-symbols/ru/README.md b/modules/31-advanced-strings/30-symbols/ru/README.md
new file mode 100644
index 00000000..f24ff8b3
--- /dev/null
+++ b/modules/31-advanced-strings/30-symbols/ru/README.md
@@ -0,0 +1,110 @@
+Иногда нужно получить один символ из строки. Например, если сайт знает имя и фамилию пользователя и нужно вывести их в сокращенном формате вида A. Ivanov. Для этого потребуется взять первую букву имени.
+
+![Извлечение символов из строки](./assets/symbols.png)
+
+В PHP для доступа к символам строки используют индексацию. Индексация означает, что у каждого символа в строке есть свой номер, то есть индекс. Индексация начинается с нуля: у первого символа индекс `0`, у второго `1` и так далее. Представим, что у нас есть строка:
+
+```php
+<?php
+
+$firstName = 'Alexander';
+```
+
+Чтобы получить первую букву, указываем ее позицию (индекс) в квадратных скобках:
+
+```php
+<?php
+
+print_r($firstName[0]); // => A
+```
+
+Квадратные скобки с индексом внутри — это специальный оператор извлечения символа из строки. Индексы в PHP (и во многих языках) начинаются с нуля:
+
+```text
+Символ	A	l	e	x	a	n	d	e	r
+Индекс	0	1	2	3	4	5	6	7	8
+```
+
+Длина строки `Alexander` равна `9`, поэтому индекс последнего символа равен `8`, то есть `9 - 1`.
+
+Чтобы получить, например, последний символ, можно написать:
+
+```php
+<?php
+
+print_r($firstName[8]); // => r
+```
+
+Если изменится длина строки, то последний элемент тоже сдвинется и придется указывать новый индекс, по которому расположен этот символ.
+
+А если выйти за границы строки, PHP сообщит о проблеме:
+
+```php
+<?php
+
+print_r($firstName[9]);
+// Warning: Uninitialized string offset 9
+```
+
+Поэтому в программировании принято проверять длину строки и обращаться к ее символам, только если это безопасно. Мы до этого дойдем в будущих уроках.
+
+## Укороченное извлечение с конца
+
+Для получения элементов с конца лучше пользоваться отрицательными индексами. В таком случае отсчет начинается с конца.
+
+```php
+<?php
+
+$firstName = 'Alexander';
+
+print_r($firstName[-1]); // => r, последний символ
+print_r($firstName[-2]); // => e, предпоследний символ
+```
+
+```text
+Строка:  'H' 'e' 'x' 'l' 'e' 't'
+Индекс:   0   1   2   3   4   5
+С конца: -6  -5  -4  -3  -2  -1
+```
+
+Отрицательные индексы работают так:
+
+- -1 соответствует последнему символу
+- -2 соответствует предпоследнему
+- и так далее
+
+Это удобно и безопасно, потому что работает правильно, даже если строка меняет свою длину.
+
+Индекс можно хранить в переменной:
+
+```php
+<?php
+
+$firstName = 'Alexander';
+$index = 0;
+
+print_r($firstName[$index]); // => A
+```
+
+Такой подход полезен, когда индекс вычисляется где-то в коде, а потом используется для доступа к нужному символу.
+
+## Спецсимволы
+
+При индексации учитываются обычные буквы, знаки и спецсимволы. Все они занимают позицию в строке и имеют свой индекс, даже если их "не видно" на экране.
+
+Например, в строке `"\nyou"` первый символ представляет собой `\n` (перенос строки), а под индексом 1 уже идет буква `y`. Поэтому обращение `$magic[1]` вернет именно `y`. Обратите внимание на двойные кавычки: в одинарных кавычках `\n` остался бы двумя отдельными символами — обратным слешем и буквой `n`.
+
+## Подумайте: что выведет этот код?
+
+```php
+<?php
+
+$magic = "\nyou";
+print_r($magic[1]); // => ?
+```
+
+Вывод будет:
+
+```text
+y
+```
diff --git a/modules/31-advanced-strings/30-symbols/ru/assets/symbols.png b/modules/31-advanced-strings/30-symbols/ru/assets/symbols.png
new file mode 100644
index 00000000..6093469e
Binary files /dev/null and b/modules/31-advanced-strings/30-symbols/ru/assets/symbols.png differ
diff --git a/modules/31-advanced-strings/30-symbols/ru/data.yml b/modules/31-advanced-strings/30-symbols/ru/data.yml
new file mode 100644
index 00000000..b16dee92
--- /dev/null
+++ b/modules/31-advanced-strings/30-symbols/ru/data.yml
@@ -0,0 +1,6 @@
+---
+name: Извлечение символов из строки
+tips: []
+definitions:
+  - name: Индекс
+    description: позиция символа внутри строки.
diff --git a/modules/35-calling-functions/180-variadic-arguments/Makefile b/modules/31-advanced-strings/70-slices/Makefile
similarity index 100%
rename from modules/35-calling-functions/180-variadic-arguments/Makefile
rename to modules/31-advanced-strings/70-slices/Makefile
diff --git a/modules/31-advanced-strings/70-slices/Solution.php b/modules/31-advanced-strings/70-slices/Solution.php
new file mode 100644
index 00000000..9a5f0349
--- /dev/null
+++ b/modules/31-advanced-strings/70-slices/Solution.php
@@ -0,0 +1,7 @@
+<?php
+
+$url = 'https://hexlet.io';
+
+// BEGIN
+print_r(substr($url, 8));
+// END
diff --git a/modules/31-advanced-strings/70-slices/SolutionTest.php b/modules/31-advanced-strings/70-slices/SolutionTest.php
new file mode 100644
index 00000000..28f2201c
--- /dev/null
+++ b/modules/31-advanced-strings/70-slices/SolutionTest.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace HexletBasics\AdvancedStrings\Slices;
+
+use HexletBasics\Exercise\TestCase;
+
+class SolutionTest extends TestCase
+{
+    public function test()
+    {
+        $expected = 'hexlet.io';
+        $this->expectOutputString($expected);
+    }
+}
diff --git a/modules/31-advanced-strings/70-slices/description.es.yml b/modules/31-advanced-strings/70-slices/description.es.yml
new file mode 100644
index 00000000..81bff07c
--- /dev/null
+++ b/modules/31-advanced-strings/70-slices/description.es.yml
@@ -0,0 +1,32 @@
+---
+
+name: Subcadenas
+theory: |
+  Usa `substr()` para extraer parte de una cadena. El formato es `substr(cadena, inicio, longitud)`:
+
+  ```php
+  <?php
+
+  $text = 'Hello, World!';
+  print_r(substr($text, 7));     // => World!
+  print_r(substr($text, 7, 5));  // => World
+  print_r(substr($text, -6));    // => World! (el índice negativo cuenta desde el final)
+  ```
+
+  Si se omite la longitud, PHP toma todo desde el índice inicial hasta el final de la cadena.
+
+instructions: |
+  Dada la variable `$url = 'https://hexlet.io'`, extrae e imprime el dominio sin el protocolo usando `substr()`:
+
+  ```text
+  hexlet.io
+  ```
+
+tips:
+  - >
+    [Función substr](https://www.php.net/manual/es/function.substr.php)
+
+definitions:
+  - name: Subcadena
+    description: >-
+      una parte de una cadena extraída según los parámetros dados: inicio y longitud.
diff --git a/modules/31-advanced-strings/70-slices/en/EXERCISE.md b/modules/31-advanced-strings/70-slices/en/EXERCISE.md
new file mode 100644
index 00000000..9a507b31
--- /dev/null
+++ b/modules/31-advanced-strings/70-slices/en/EXERCISE.md
@@ -0,0 +1,5 @@
+Given `$url = 'https://hexlet.io'`, extract and print the domain without the protocol using `substr()`:
+
+```text
+hexlet.io
+```
diff --git a/modules/31-advanced-strings/70-slices/en/README.md b/modules/31-advanced-strings/70-slices/en/README.md
new file mode 100644
index 00000000..8965ba0d
--- /dev/null
+++ b/modules/31-advanced-strings/70-slices/en/README.md
@@ -0,0 +1,12 @@
+Use `substr()` to extract part of a string. The format is `substr(string, start, length)`:
+
+```php
+<?php
+
+$text = 'Hello, World!';
+print_r(substr($text, 7));     // => World!
+print_r(substr($text, 7, 5));  // => World
+print_r(substr($text, -6));    // => World! (negative index counts from the end)
+```
+
+If the length is omitted, PHP takes everything from the start index to the end of the string.
diff --git a/modules/31-advanced-strings/70-slices/en/data.yml b/modules/31-advanced-strings/70-slices/en/data.yml
new file mode 100644
index 00000000..7357bd89
--- /dev/null
+++ b/modules/31-advanced-strings/70-slices/en/data.yml
@@ -0,0 +1,9 @@
+---
+name: Substrings
+tips:
+  - >
+    [substr function](https://www.php.net/manual/en/function.substr.php)
+definitions:
+  - name: Substring
+    description: >-
+      a part of a string extracted by the given parameters: start and length.
diff --git a/modules/31-advanced-strings/70-slices/es/EXERCISE.md b/modules/31-advanced-strings/70-slices/es/EXERCISE.md
new file mode 100644
index 00000000..24e4cdb2
--- /dev/null
+++ b/modules/31-advanced-strings/70-slices/es/EXERCISE.md
@@ -0,0 +1,5 @@
+Dada la variable `$url = 'https://hexlet.io'`, extrae e imprime el dominio sin el protocolo usando `substr()`:
+
+```text
+hexlet.io
+```
diff --git a/modules/31-advanced-strings/70-slices/es/README.md b/modules/31-advanced-strings/70-slices/es/README.md
new file mode 100644
index 00000000..31b04736
--- /dev/null
+++ b/modules/31-advanced-strings/70-slices/es/README.md
@@ -0,0 +1,12 @@
+Usa `substr()` para extraer parte de una cadena. El formato es `substr(cadena, inicio, longitud)`:
+
+```php
+<?php
+
+$text = 'Hello, World!';
+print_r(substr($text, 7));     // => World!
+print_r(substr($text, 7, 5));  // => World
+print_r(substr($text, -6));    // => World! (el índice negativo cuenta desde el final)
+```
+
+Si se omite la longitud, PHP toma todo desde el índice inicial hasta el final de la cadena.
diff --git a/modules/31-advanced-strings/70-slices/es/data.yml b/modules/31-advanced-strings/70-slices/es/data.yml
new file mode 100644
index 00000000..c42e4492
--- /dev/null
+++ b/modules/31-advanced-strings/70-slices/es/data.yml
@@ -0,0 +1,9 @@
+---
+name: Subcadenas
+tips:
+  - >
+    [Función substr](https://www.php.net/manual/es/function.substr.php)
+definitions:
+  - name: Subcadena
+    description: >-
+      una parte de una cadena extraída según los parámetros dados: inicio y longitud.
diff --git a/modules/31-advanced-strings/70-slices/ru/EXERCISE.md b/modules/31-advanced-strings/70-slices/ru/EXERCISE.md
new file mode 100644
index 00000000..37f156fd
--- /dev/null
+++ b/modules/31-advanced-strings/70-slices/ru/EXERCISE.md
@@ -0,0 +1 @@
+Программа получает полный адрес сайта и должна выделить из него только имя домена — без протокола `https://`. В переменной `$url` хранится адрес `https://hexlet.io`. Извлеките с помощью `substr()` доменное имя `hexlet.io` и выведите на экран. Задание можно сделать разными способами.
diff --git a/modules/31-advanced-strings/70-slices/ru/README.md b/modules/31-advanced-strings/70-slices/ru/README.md
new file mode 100644
index 00000000..b5fc9dab
--- /dev/null
+++ b/modules/31-advanced-strings/70-slices/ru/README.md
@@ -0,0 +1,150 @@
+Работая со строками, мы часто сталкиваемся с задачей: извлечь часть строки. Например, получить год из даты, имя из полного ФИО или первые несколько символов из адреса электронной почты. Для таких случаев в PHP существует удобный инструмент: встроенная функция `substr()`.
+
+## Что такое подстрока?
+
+Подстрока является частью строки. То, что входит внутрь другой строки. Например, в строке `'12-08-2034'` подстрокой может быть `'2034'`, `'12'` или даже `'-'`. Все зависит от того, какую информацию нам нужно извлечь.
+
+Допустим, у нас есть строка с датой `'12-08-2034'`. Мы хотим получить из нее только год `'2034'`. В этой строке каждый символ имеет индекс (позицию), начиная с нуля:
+
+```text
+'1' '2' '-' '0' '8' '-' '2' '0' '3' '4'
+ 0   1   2   3   4   5   6   7   8   9
+```
+
+Получается, год начинается с индекса 6 и состоит из четырех символов. Чтобы извлечь его, мы используем `substr()`:
+
+```php
+<?php
+
+$value = '12-08-2034';
+$year = substr($value, 6, 4);
+print_r($year); // => 2034
+```
+
+Запись `substr($value, 6, 4)` означает: взять из строки `$value` четыре символа, начиная с индекса 6. Формат:
+
+```text
+substr(строка, начало, длина)
+```
+
+Обратите внимание: третий параметр задает не индекс конца, а количество символов, которое нужно взять.
+
+```php
+<?php
+
+// Последний символ имеет индекс 10, а всего символов 11
+$value = 'code-basics';
+
+print_r(substr($value, 5, 6)); // => basics (6 символов с индекса 5)
+print_r(substr($value, 0, 7)); // => code-ba (7 символов с начала)
+print_r(substr($value, 2, 4)); // => de-b
+```
+
+Как все это считать? Если мы работаем с конкретной строкой, то почти всегда это делается на глаз.
+
+## Подстрока является строкой
+
+```php
+<?php
+
+$value = '01-12-9873';
+
+substr($value, 1, 1); // => 1
+substr($value, 3, 2); // => 12
+```
+
+`substr()` всегда возвращает строку, даже если в ней только цифры. Это значит, что результат можно использовать, как обычную строку: конкатенировать, печатать, интерполировать и так далее. В том числе из него можно извлечь новую подстроку:
+
+```php
+<?php
+
+$value = '01-12-9873';
+
+$part = substr($value, 3, 4); // => 12-9
+print_r(substr($part, 0, 2)); // => 12
+```
+
+Сначала мы получили подстроку `'12-9'`, а потом извлекли из нее новую подстроку `'12'`.
+
+## Подстрока до конца или с начала
+
+Иногда нужно взять часть строки до конца или от начала. Такие ситуации тоже легко обрабатываются:
+
+```php
+<?php
+
+$value = 'Hexlet';
+
+print_r(substr($value, 3));    // => let (с индекса 3 до конца)
+print_r(substr($value, 0, 3)); // => Hex (от начала, три символа)
+```
+
+Если длину не указать, PHP сам возьмет все символы от начального индекса до конца строки.
+
+## Отрицательные индексы
+
+PHP позволяет считать не только слева направо, но и с конца строки. Для этого используются отрицательные значения:
+
+```php
+<?php
+
+$value = 'Hexlet';
+
+print_r(substr($value, -1));    // => t (последний символ)
+print_r(substr($value, -3));    // => let (последние три символа)
+print_r(substr($value, 1, -1)); // => exle (с индекса 1 до предпоследнего символа)
+```
+
+Отрицательное начало означает отсчет от конца строки: `-1` соответствует последнему символу, `-2` — предпоследнему и так далее. Отрицательная длина означает «взять все, кроме указанного количества символов с конца».
+
+Это удобно, когда заранее неизвестна длина строки, но нужно взять «хвост» или «середину» строки относительно конца.
+
+## Переворот строки
+
+В некоторых языках, например в Python, у срезов строк есть параметр «шаг», с помощью которого можно взять каждый второй символ или перевернуть строку. У `substr()` шага нет, но для переворота строки в PHP есть отдельная встроенная функция `strrev()`:
+
+```php
+<?php
+
+$value = 'Hexlet';
+
+print_r(strrev($value)); // => telxeH
+```
+
+## Подстрока с переменными
+
+Параметры `substr()` не обязаны быть жестко зафиксированы числами. Можно использовать переменные:
+
+```php
+<?php
+
+$start = 1;
+$length = 4;
+
+$value = 'Hexlet';
+print_r(substr($value, $start, $length)); // => exle
+```
+
+Это особенно полезно, когда границы вычисляются во время работы программы.
+
+## Осторожно: кириллица
+
+Функция `substr()` работает с байтами, а не с символами. Для латиницы это одно и то же, но символы кириллицы и других нелатинских алфавитов занимают больше одного байта. Для таких строк используется функция `mb_substr()` — подробнее о работе с кодировками мы поговорим в конце курса.
+
+## Быстрая шпаргалка
+
+```php
+<?php
+
+$value = 'Hexlet';
+
+substr($value, 0);     // Hexlet — вся строка
+substr($value, 5);     // t
+substr($value, 0, 5);  // Hexle
+substr($value, -1);    // t — последний символ
+substr($value, -3);    // let — последние три символа
+substr($value, 2, -1); // xle — с третьего символа до предпоследнего
+strrev($value);        // telxeH — строка в обратном порядке
+```
+
+Не переживайте, если сейчас не запомните все комбинации: вы быстро начнете использовать их на практике. Главное понимать, как работает базовая структура `substr(строка, начало, длина)`.
diff --git a/modules/31-advanced-strings/70-slices/ru/data.yml b/modules/31-advanced-strings/70-slices/ru/data.yml
new file mode 100644
index 00000000..3b828174
--- /dev/null
+++ b/modules/31-advanced-strings/70-slices/ru/data.yml
@@ -0,0 +1,9 @@
+---
+name: Подстроки
+tips:
+  - >
+    [Функция substr](https://www.php.net/manual/ru/function.substr.php)
+definitions:
+  - name: Подстрока
+    description: >-
+      часть строки, извлеченная по указанным параметрам: началу и длине.
diff --git a/modules/27-data-types/40-primitive-data-types/Makefile b/modules/31-advanced-strings/90-multiline-strings/Makefile
similarity index 100%
rename from modules/27-data-types/40-primitive-data-types/Makefile
rename to modules/31-advanced-strings/90-multiline-strings/Makefile
diff --git a/modules/31-advanced-strings/90-multiline-strings/Solution.php b/modules/31-advanced-strings/90-multiline-strings/Solution.php
new file mode 100644
index 00000000..24c25c8d
--- /dev/null
+++ b/modules/31-advanced-strings/90-multiline-strings/Solution.php
@@ -0,0 +1,12 @@
+<?php
+
+// BEGIN
+$text = <<<EOT
+Уважаемый пользователь!
+Ваш заказ успешно оформлен.
+Ожидаемая дата доставки: 3-5 рабочих дней.
+Спасибо, что выбрали нас!
+EOT;
+// END
+
+print_r($text);
diff --git a/modules/31-advanced-strings/90-multiline-strings/SolutionTest.php b/modules/31-advanced-strings/90-multiline-strings/SolutionTest.php
new file mode 100644
index 00000000..094b72d9
--- /dev/null
+++ b/modules/31-advanced-strings/90-multiline-strings/SolutionTest.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace HexletBasics\AdvancedStrings\MultilineStrings;
+
+use HexletBasics\Exercise\TestCase;
+
+class SolutionTest extends TestCase
+{
+    public function test()
+    {
+        $expected = <<<EOT
+Уважаемый пользователь!
+Ваш заказ успешно оформлен.
+Ожидаемая дата доставки: 3-5 рабочих дней.
+Спасибо, что выбрали нас!
+EOT;
+        $this->expectOutputString($expected);
+    }
+}
diff --git a/modules/30-variables/35-heredoc/description.es.yml b/modules/31-advanced-strings/90-multiline-strings/description.es.yml
similarity index 100%
rename from modules/30-variables/35-heredoc/description.es.yml
rename to modules/31-advanced-strings/90-multiline-strings/description.es.yml
diff --git a/modules/30-variables/35-heredoc/en/EXERCISE.md b/modules/31-advanced-strings/90-multiline-strings/en/EXERCISE.md
similarity index 100%
rename from modules/30-variables/35-heredoc/en/EXERCISE.md
rename to modules/31-advanced-strings/90-multiline-strings/en/EXERCISE.md
diff --git a/modules/30-variables/35-heredoc/en/README.md b/modules/31-advanced-strings/90-multiline-strings/en/README.md
similarity index 100%
rename from modules/30-variables/35-heredoc/en/README.md
rename to modules/31-advanced-strings/90-multiline-strings/en/README.md
diff --git a/modules/30-variables/35-heredoc/en/data.yml b/modules/31-advanced-strings/90-multiline-strings/en/data.yml
similarity index 100%
rename from modules/30-variables/35-heredoc/en/data.yml
rename to modules/31-advanced-strings/90-multiline-strings/en/data.yml
diff --git a/modules/30-variables/35-heredoc/es/EXERCISE.md b/modules/31-advanced-strings/90-multiline-strings/es/EXERCISE.md
similarity index 100%
rename from modules/30-variables/35-heredoc/es/EXERCISE.md
rename to modules/31-advanced-strings/90-multiline-strings/es/EXERCISE.md
diff --git a/modules/30-variables/35-heredoc/es/README.md b/modules/31-advanced-strings/90-multiline-strings/es/README.md
similarity index 100%
rename from modules/30-variables/35-heredoc/es/README.md
rename to modules/31-advanced-strings/90-multiline-strings/es/README.md
diff --git a/modules/30-variables/35-heredoc/es/data.yml b/modules/31-advanced-strings/90-multiline-strings/es/data.yml
similarity index 100%
rename from modules/30-variables/35-heredoc/es/data.yml
rename to modules/31-advanced-strings/90-multiline-strings/es/data.yml
diff --git a/modules/31-advanced-strings/90-multiline-strings/ru/EXERCISE.md b/modules/31-advanced-strings/90-multiline-strings/ru/EXERCISE.md
new file mode 100644
index 00000000..f6ee838b
--- /dev/null
+++ b/modules/31-advanced-strings/90-multiline-strings/ru/EXERCISE.md
@@ -0,0 +1,8 @@
+Интернет-магазин хранит текст письма о статусе заказа в переменной и отправляет его покупателю. Запишите в переменную `$text` текст письма, приведённый ниже. Используйте heredoc-синтаксис. Все переносы строк должны сохраниться.
+
+```text
+Уважаемый пользователь!
+Ваш заказ успешно оформлен.
+Ожидаемая дата доставки: 3-5 рабочих дней.
+Спасибо, что выбрали нас!
+```
diff --git a/modules/31-advanced-strings/90-multiline-strings/ru/README.md b/modules/31-advanced-strings/90-multiline-strings/ru/README.md
new file mode 100644
index 00000000..fdeb6cb4
--- /dev/null
+++ b/modules/31-advanced-strings/90-multiline-strings/ru/README.md
@@ -0,0 +1,106 @@
+Иногда текст в программе должен состоять из нескольких строк. Например, при генерации письма, создании шаблона, форматировании сообщения об ошибке или просто работе с длинными текстами.
+
+Конечно, можно использовать символ перевода строки `\n`, как мы делали раньше:
+
+```php
+<?php
+
+$text = "Пример текста,\nсостоящего из\nнескольких строк";
+```
+
+На печати строка будет выглядеть вот так:
+
+```text
+Пример текста,
+состоящего из
+нескольких строк
+```
+
+Но такой способ становится неудобным, особенно если строка длинная или нужно часто добавлять новые переносы. Каждый `\n` приходится вставлять вручную, и это ухудшает читаемость кода.
+
+## Heredoc как альтернатива
+
+В PHP есть более удобный способ записывать текст в несколько строк: heredoc-синтаксис. После оператора `<<<` указывается идентификатор с произвольным именем, затем перевод строки и сам текст. В конце на отдельной строке добавляется тот же идентификатор, который закрывает строку:
+
+```php
+<?php
+
+$text = <<<EOT
+Пример текста,
+состоящего из
+нескольких строк
+EOT;
+```
+
+Теперь в коде все выглядит так же, как и при выводе:
+
+```text
+Пример текста,
+состоящего из
+нескольких строк
+```
+
+## Закрывающий идентификатор
+
+Закрывающий идентификатор, в нашем случае — `EOT`, должен находиться на отдельной строке. Начиная с PHP 7.3 его можно сдвигать вправо пробелами — тогда такой же отступ уберется из каждой строки текста.
+
+Перевод строки перед закрывающим идентификатором не входит в результат. Поэтому строка выше заканчивается словом `строк` без пустой строки в конце — в отличие от некоторых других языков, где перенос закрывающих кавычек на новую строку добавляет лишний перевод строки.
+
+## Преимущества heredoc
+
+- Читаемость кода: текст в коде выглядит почти как на экране.
+- Удобство при редактировании: легко добавлять, удалять и менять строки.
+- Не нужно экранировать кавычки:
+
+```php
+<?php
+
+$quote = <<<EOT
+Здесь не нужно экранировать ни 'одинарные', ни "двойные" кавычки
+EOT;
+```
+
+## Интерполяция внутри heredoc
+
+Heredoc работает как строка в двойных кавычках: внутри можно подставлять значения переменных с помощью интерполяции:
+
+```php
+<?php
+
+$a = 'А';
+$b = 'B';
+
+$text = <<<EOT
+{$a} и {$b}
+сидели на трубе
+EOT;
+```
+
+Вывод:
+
+```text
+А и B
+сидели на трубе
+```
+
+Это особенно удобно для шаблонов, писем, сообщений об ошибках и многострочных описаний.
+
+## Nowdoc
+
+У heredoc есть «брат» — nowdoc. Разница в том, что идентификатор после `<<<` заключается в одинарные кавычки. Nowdoc ведет себя как строка в одинарных кавычках: интерполяция и спецсимволы внутри не работают, текст выводится как есть:
+
+```php
+<?php
+
+$name = 'Joffrey';
+
+$text = <<<'EOT'
+Hello, {$name}!
+EOT;
+
+print_r($text); // => Hello, {$name}!
+```
+
+## Компьютер и человек воспринимают код по-разному
+
+PHP может обработать и строки с `\n`, и heredoc. Для интерпретатора это одно и то же. Но для человека, читающего код, heredoc намного удобнее и нагляднее.
diff --git a/modules/31-advanced-strings/90-multiline-strings/ru/data.yml b/modules/31-advanced-strings/90-multiline-strings/ru/data.yml
new file mode 100644
index 00000000..2a0195eb
--- /dev/null
+++ b/modules/31-advanced-strings/90-multiline-strings/ru/data.yml
@@ -0,0 +1,8 @@
+---
+name: Многострочные строки
+definitions: []
+tips:
+  - >
+    [Heredoc](https://www.php.net/manual/ru/language.types.string.php#language.types.string.syntax.heredoc)
+  - >
+    [Nowdoc](https://www.php.net/manual/ru/language.types.string.php#language.types.string.syntax.nowdoc)
diff --git a/modules/31-advanced-strings/description.en.yml b/modules/31-advanced-strings/description.en.yml
new file mode 100644
index 00000000..1f2b5c47
--- /dev/null
+++ b/modules/31-advanced-strings/description.en.yml
@@ -0,0 +1,5 @@
+---
+
+name: Deeper Into Strings
+description:
+  We continue studying strings and their relationship with variables. We cover interpolation, character extraction, substrings, and multiline strings.
diff --git a/modules/31-advanced-strings/description.es.yml b/modules/31-advanced-strings/description.es.yml
new file mode 100644
index 00000000..3b9f3636
--- /dev/null
+++ b/modules/31-advanced-strings/description.es.yml
@@ -0,0 +1,5 @@
+---
+
+name: Más sobre cadenas de texto
+description:
+  Continuamos aprendiendo sobre cadenas de texto y su relación con las variables. Exploramos la interpolación, la extracción de caracteres, las subcadenas y las cadenas multilínea.
diff --git a/modules/31-advanced-strings/description.ru.yml b/modules/31-advanced-strings/description.ru.yml
new file mode 100644
index 00000000..8946cc33
--- /dev/null
+++ b/modules/31-advanced-strings/description.ru.yml
@@ -0,0 +1,5 @@
+---
+
+name: Глубже про строки
+description:
+  Продолжаем изучать строки и их связь с переменными. Разбираем интерполяцию, извлечение символов, получение подстрок и многострочные строки.
diff --git a/modules/27-data-types/50-data-types-weak-typing/Makefile b/modules/33-data-types/40-primitive-data-types/Makefile
similarity index 100%
rename from modules/27-data-types/50-data-types-weak-typing/Makefile
rename to modules/33-data-types/40-primitive-data-types/Makefile
diff --git a/modules/33-data-types/40-primitive-data-types/Solution.php b/modules/33-data-types/40-primitive-data-types/Solution.php
new file mode 100644
index 00000000..ff0e42f5
--- /dev/null
+++ b/modules/33-data-types/40-primitive-data-types/Solution.php
@@ -0,0 +1,15 @@
+<?php
+
+$currentYear = 2026;
+
+// BEGIN
+$name = 'Anna';
+$birthYear = 1994;
+$age = $currentYear - $birthYear;
+$rating = 4.7;
+
+print_r("Name: {$name}\n");
+print_r("Birth year: {$birthYear}\n");
+print_r("Age: {$age}\n");
+print_r("Rating: {$rating}");
+// END
diff --git a/modules/27-data-types/40-primitive-data-types/SolutionTest.php b/modules/33-data-types/40-primitive-data-types/SolutionTest.php
similarity index 59%
rename from modules/27-data-types/40-primitive-data-types/SolutionTest.php
rename to modules/33-data-types/40-primitive-data-types/SolutionTest.php
index d97f7e5b..6d27cb11 100644
--- a/modules/27-data-types/40-primitive-data-types/SolutionTest.php
+++ b/modules/33-data-types/40-primitive-data-types/SolutionTest.php
@@ -2,16 +2,19 @@
 
 namespace HexletBasics\DataTypes\PrimitiveDataTypes;
 
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        $expected = '-0.304';
+        $expected = <<<HERE
+Name: Anna
+Birth year: 1994
+Age: 32
+Rating: 4.7
+HERE;
+
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/27-data-types/40-primitive-data-types/description.es.yml b/modules/33-data-types/40-primitive-data-types/description.es.yml
similarity index 100%
rename from modules/27-data-types/40-primitive-data-types/description.es.yml
rename to modules/33-data-types/40-primitive-data-types/description.es.yml
diff --git a/modules/27-data-types/40-primitive-data-types/en/EXERCISE.md b/modules/33-data-types/40-primitive-data-types/en/EXERCISE.md
similarity index 100%
rename from modules/27-data-types/40-primitive-data-types/en/EXERCISE.md
rename to modules/33-data-types/40-primitive-data-types/en/EXERCISE.md
diff --git a/modules/27-data-types/40-primitive-data-types/en/README.md b/modules/33-data-types/40-primitive-data-types/en/README.md
similarity index 100%
rename from modules/27-data-types/40-primitive-data-types/en/README.md
rename to modules/33-data-types/40-primitive-data-types/en/README.md
diff --git a/modules/27-data-types/40-primitive-data-types/en/data.yml b/modules/33-data-types/40-primitive-data-types/en/data.yml
similarity index 100%
rename from modules/27-data-types/40-primitive-data-types/en/data.yml
rename to modules/33-data-types/40-primitive-data-types/en/data.yml
diff --git a/modules/27-data-types/40-primitive-data-types/es/EXERCISE.md b/modules/33-data-types/40-primitive-data-types/es/EXERCISE.md
similarity index 100%
rename from modules/27-data-types/40-primitive-data-types/es/EXERCISE.md
rename to modules/33-data-types/40-primitive-data-types/es/EXERCISE.md
diff --git a/modules/27-data-types/40-primitive-data-types/es/README.md b/modules/33-data-types/40-primitive-data-types/es/README.md
similarity index 100%
rename from modules/27-data-types/40-primitive-data-types/es/README.md
rename to modules/33-data-types/40-primitive-data-types/es/README.md
diff --git a/modules/27-data-types/40-primitive-data-types/es/data.yml b/modules/33-data-types/40-primitive-data-types/es/data.yml
similarity index 100%
rename from modules/27-data-types/40-primitive-data-types/es/data.yml
rename to modules/33-data-types/40-primitive-data-types/es/data.yml
diff --git a/modules/33-data-types/40-primitive-data-types/ru/EXERCISE.md b/modules/33-data-types/40-primitive-data-types/ru/EXERCISE.md
new file mode 100644
index 00000000..c55ade45
--- /dev/null
+++ b/modules/33-data-types/40-primitive-data-types/ru/EXERCISE.md
@@ -0,0 +1,22 @@
+В программе уже задан текущий год:
+
+```php
+<?php
+
+$currentYear = 2026;
+```
+
+Напишите программу, которая выводит данные профиля в таком формате:
+
+```text
+Name: Anna
+Birth year: 1994
+Age: 32
+Rating: 4.7
+```
+
+Для этого:
+
+- создайте переменную с годом рождения;
+- вычислите возраст на основе текущего года;
+- выведите данные на экран с подписями слева.
diff --git a/modules/33-data-types/40-primitive-data-types/ru/README.md b/modules/33-data-types/40-primitive-data-types/ru/README.md
new file mode 100644
index 00000000..dc35ba26
--- /dev/null
+++ b/modules/33-data-types/40-primitive-data-types/ru/README.md
@@ -0,0 +1,105 @@
+Программы работают с разной информацией: текстом, числами, датами, списками, логическими значениями. У каждого значения в программе есть тип.
+
+Например:
+
+- "Hello, World!" является строкой (`string`)
+- 7, -198, 0 являются целыми числами (`int`)
+- 3.14, -0.01, 1.0 являются рациональными числами (`float`)
+
+## Что такое тип данных?
+
+Тип данных определяет:
+
+- какие значения к нему относятся;
+- какие операции с ним можно делать.
+
+Например, числа можно складывать, делить и умножать. А вот строки соединяются по-другому: при помощи конкатенации. Умножать строку на строку бессмысленно и недопустимо:
+
+```php
+// Нельзя: 'мама' * 'блокнот'
+```
+
+Язык программирования распознает типы. Поэтому PHP не позволит нам умножать текст на текст, но позволит умножать число на число. Наличие типов и таких ограничений в языке защищает программы от случайных ошибок.
+
+## Числа и строки относятся к разным типам
+
+В отличие от строк, числа оборачивать в кавычки не нужно. Пример вывода числа:
+
+```php
+<?php
+
+print_r(5);  // => 5
+print_r(-5); // => -5
+```
+
+Пример вывода строки:
+
+```php
+<?php
+
+print_r('5');  // => 5
+print_r('-5'); // => -5
+```
+
+На экране результат выглядит одинаково, но внутри программы это совершенно разные вещи:
+
+| Значение | Тип данных          |
+|----------|---------------------|
+| `5`      | `int` (целое число) |
+| `'5'`    | `string` (строка)   |
+
+Число `5` и строка `'5'` — разные значения, и операции с ними работают по-разному. Правда, при несоответствии типов PHP часто пытается сам преобразовать один тип в другой. Насколько это удобно и чем опасно — разберем чуть позже в этом модуле.
+
+## Целые и рациональные числа
+
+PHP различает два вида чисел:
+
+- `int` обозначает целые числа: -3, 0, 7, 100000
+- `float` обозначает вещественные (рациональные) числа: 1.0, -3.14, 2.718
+
+Такое разделение связано с особенностями устройства компьютеров — мы говорили об этом в уроке про числа с плавающей точкой.
+
+Пример:
+
+```php
+<?php
+
+print_r(10.234); // => 10.234
+print_r(-0.4);   // => -0.4
+```
+
+В них можно записывать дробные значения и использовать их в вычислениях:
+
+```php
+<?php
+
+print_r(3.5 + 1.2);  // => 4.7
+print_r(5.0 / 2.0);  // => 2.5
+print_r(2.75 - 0.5); // => 2.25
+```
+
+## Примитивные типы
+
+Типы вроде:
+
+- string (строка),
+- int (целое число),
+- float (рациональное число)
+
+называются примитивными: они встроены прямо в сам язык PHP.
+
+```text
+Примитивные типы PHP
+├── int    : целые числа    (7, -3, 0)
+├── float  : дробные числа  (3.14, -0.5)
+├── string : строки         ('hello')
+└── bool   : логический тип (true, false)
+```
+
+Кроме строк и чисел, в PHP есть булев тип `bool` со значениями `true` и `false`, а также специальное значение `null`. Подробнее мы столкнемся с ними в будущем.
+
+Существуют и составные типы: массивы, объекты и другие. С ними мы познакомимся позже. Более того, в PHP можно создавать и свои собственные типы (например, классы), но для начала важно хорошо разобраться с примитивами.
+
+## Строки и строчки
+
+По-английски строки в программировании называются **strings**, а строчки текстовых файлов — **lines**. В русском языке может быть путаница, поэтому во всех уроках мы будем говорить «строка» для обозначения типа данных «строка», и «строчка» — для lines в файлах.
diff --git a/modules/27-data-types/40-primitive-data-types/ru/data.yml b/modules/33-data-types/40-primitive-data-types/ru/data.yml
similarity index 92%
rename from modules/27-data-types/40-primitive-data-types/ru/data.yml
rename to modules/33-data-types/40-primitive-data-types/ru/data.yml
index 6fba9029..f67d8a68 100644
--- a/modules/27-data-types/40-primitive-data-types/ru/data.yml
+++ b/modules/33-data-types/40-primitive-data-types/ru/data.yml
@@ -4,7 +4,7 @@ tips:
   - >
     [Литерал](https://ru.wikipedia.org/wiki/%D0%9B%D0%B8%D1%82%D0%B5%D1%80%D0%B0%D0%BB_(%D0%B8%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0))
   - |
-    [Статья о дробных числах](https://habrahabr.ru/post/112953/)
+    [Статья о дробных числах](https://habr.com/ru/articles/112953/)
 definitions:
   - name: Тип данных
     description: >-
diff --git a/modules/27-data-types/55-type-conversion/Makefile b/modules/33-data-types/50-data-types-weak-typing/Makefile
similarity index 100%
rename from modules/27-data-types/55-type-conversion/Makefile
rename to modules/33-data-types/50-data-types-weak-typing/Makefile
diff --git a/modules/27-data-types/50-data-types-weak-typing/index.php b/modules/33-data-types/50-data-types-weak-typing/Solution.php
similarity index 100%
rename from modules/27-data-types/50-data-types-weak-typing/index.php
rename to modules/33-data-types/50-data-types-weak-typing/Solution.php
diff --git a/modules/27-data-types/50-data-types-weak-typing/SolutionTest.php b/modules/33-data-types/50-data-types-weak-typing/SolutionTest.php
similarity index 67%
rename from modules/27-data-types/50-data-types-weak-typing/SolutionTest.php
rename to modules/33-data-types/50-data-types-weak-typing/SolutionTest.php
index afe3146f..c3a89d76 100644
--- a/modules/27-data-types/50-data-types-weak-typing/SolutionTest.php
+++ b/modules/33-data-types/50-data-types-weak-typing/SolutionTest.php
@@ -2,9 +2,7 @@
 
 namespace HexletBasics\DataTypes\WeakTyping;
 
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
@@ -12,6 +10,5 @@ public function test()
     {
         $expected = '13';
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/27-data-types/50-data-types-weak-typing/description.es.yml b/modules/33-data-types/50-data-types-weak-typing/description.es.yml
similarity index 100%
rename from modules/27-data-types/50-data-types-weak-typing/description.es.yml
rename to modules/33-data-types/50-data-types-weak-typing/description.es.yml
diff --git a/modules/27-data-types/50-data-types-weak-typing/en/EXERCISE.md b/modules/33-data-types/50-data-types-weak-typing/en/EXERCISE.md
similarity index 100%
rename from modules/27-data-types/50-data-types-weak-typing/en/EXERCISE.md
rename to modules/33-data-types/50-data-types-weak-typing/en/EXERCISE.md
diff --git a/modules/27-data-types/50-data-types-weak-typing/en/README.md b/modules/33-data-types/50-data-types-weak-typing/en/README.md
similarity index 100%
rename from modules/27-data-types/50-data-types-weak-typing/en/README.md
rename to modules/33-data-types/50-data-types-weak-typing/en/README.md
diff --git a/modules/27-data-types/50-data-types-weak-typing/en/data.yml b/modules/33-data-types/50-data-types-weak-typing/en/data.yml
similarity index 100%
rename from modules/27-data-types/50-data-types-weak-typing/en/data.yml
rename to modules/33-data-types/50-data-types-weak-typing/en/data.yml
diff --git a/modules/27-data-types/50-data-types-weak-typing/es/EXERCISE.md b/modules/33-data-types/50-data-types-weak-typing/es/EXERCISE.md
similarity index 100%
rename from modules/27-data-types/50-data-types-weak-typing/es/EXERCISE.md
rename to modules/33-data-types/50-data-types-weak-typing/es/EXERCISE.md
diff --git a/modules/27-data-types/50-data-types-weak-typing/es/README.md b/modules/33-data-types/50-data-types-weak-typing/es/README.md
similarity index 100%
rename from modules/27-data-types/50-data-types-weak-typing/es/README.md
rename to modules/33-data-types/50-data-types-weak-typing/es/README.md
diff --git a/modules/27-data-types/50-data-types-weak-typing/es/data.yml b/modules/33-data-types/50-data-types-weak-typing/es/data.yml
similarity index 100%
rename from modules/27-data-types/50-data-types-weak-typing/es/data.yml
rename to modules/33-data-types/50-data-types-weak-typing/es/data.yml
diff --git a/modules/33-data-types/50-data-types-weak-typing/ru/EXERCISE.md b/modules/33-data-types/50-data-types-weak-typing/ru/EXERCISE.md
new file mode 100644
index 00000000..c676b967
--- /dev/null
+++ b/modules/33-data-types/50-data-types-weak-typing/ru/EXERCISE.md
@@ -0,0 +1,3 @@
+В игре два игрока. Первый набрал `7` очков, второй потерял очки: выражение `(-8 - -2)` описывает его результат. Посчитайте разницу и выведите на экран: `7 - (-8 - -2)`.
+
+Попробуйте сделать число 7 не числом, а строкой: `'7' - (-8 - -2)`. Сработает ли такой код? Поэкспериментируйте с другими числами тоже.
diff --git a/modules/33-data-types/50-data-types-weak-typing/ru/README.md b/modules/33-data-types/50-data-types-weak-typing/ru/README.md
new file mode 100644
index 00000000..f4e8c3ff
--- /dev/null
+++ b/modules/33-data-types/50-data-types-weak-typing/ru/README.md
@@ -0,0 +1,64 @@
+Нам известно про два разных типа данных: числа и строки. Мы могли складывать числа, потому что операция сложения — это операция для типа «числа». А что, если применить эту операцию к числу и строке?
+
+```php
+<?php
+
+print_r(1 + '7'); // => 8
+```
+
+`'7'` — это строка, а не число, при этом интерпретатор PHP выдал ответ `8`, как если бы мы складывали два числа. Когда PHP видит несоответствие типов, он сам пытается преобразовать информацию. В данном случае он преобразовал строку `'7'` в число `7`, а потом сложил `1` и `7`.
+
+## Слабая типизация
+
+Не все языки так делают. PHP — это язык со **слабой типизацией**. Он знает о существовании разных типов (числа, строки и другие), но относится к их использованию не строго и пытается преобразовывать данные, когда это кажется ему разумным.
+
+Обратите внимание: оператор `+` в PHP всегда означает арифметику, а для соединения строк есть отдельный оператор — конкатенация `.`. Поэтому в выражении `1 + '7'` PHP превращает строку в число, а в выражении `1 . '7'` — наоборот, число в строку:
+
+```php
+<?php
+
+print_r(1 + '7'); // => 8
+print_r(1 . '7'); // => 17
+```
+
+```text
+1 + '7'  →  8     (строка превратилась в число, сложение)
+'7' - 1  →  6     (строка превратилась в число, вычитание)
+1 . '7'  →  '17'  (число превратилось в строку, конкатенация)
+```
+
+Граница дозволенного у PHP все же есть. Если строку никак нельзя понять как число, современный PHP остановит программу с ошибкой:
+
+```php
+<?php
+
+print_r(1 + 'seven');
+// TypeError: Unsupported operand types: int + string
+```
+
+Но стоит строке начинаться с цифры — и PHP снова попробует «угадать»: выражение `1 + '7 самураев'` вернет `8`, лишь выдав предупреждение.
+
+## А как в строгих языках?
+
+В языках со **строгой (сильной) типизацией** сложить число со строкой не получится — программа остановится с ошибкой. Например, в Python или Ruby выражение `1 + '7'` приведет к ошибке типов: язык требует, чтобы программист явно указал, как преобразовать данные.
+
+При этом языки не делятся ровно на два лагеря — «строгие» и «слабые». Корректнее говорить, что у разных языков **разная степень строгости**: где-то неявных преобразований почти нет, а где-то их много. PHP находится у «слабого» края этой шкалы, хотя с каждой новой версией становится строже.
+
+## Статическая и динамическая типизация
+
+Есть и другое, отдельное понятие — статическая и динамическая типизация. Оно описывает, **когда** проверяются типы. PHP относится к динамически типизированным языкам: типы проверяются во время работы программы. В статически типизированных языках проверка обычно происходит раньше, еще до запуска кода, на стадии компиляции.
+
+Важно не путать две вещи:
+
+- статическая/динамическая типизация отвечает на вопрос «**когда** проверяются типы»;
+- сильная/слабая типизация отвечает на вопрос «**что произойдет**, если смешать разные типы без явного преобразования».
+
+Это независимые свойства. PHP — язык динамический и слабо типизированный.
+
+## Почему PHP такой
+
+PHP был создан для интернета, а в интернете вся информация — это строки. Даже когда мы вводим на сайте номер телефона или год рождения, на сервер эта информация поступает не как числа, а как строки. Поэтому авторы языка решили, что автоматически преобразовывать типы — правильно и удобно.
+
+Удобство есть, но у него высокая цена. На практике неявные преобразования создают множество ошибок и проблем, которые трудно найти: код может иногда работать, а иногда не работать. Это зависит от того, «повезло» ли в конкретном случае с автоматическим преобразованием. Программист замечает это не сразу.
+
+В дальнейших заданиях мы будем встречаться с таким поведением не раз. Часто будет возникать вопрос «почему мой код работает не так, как я ожидаю?». Слабая типизация красной нитью проходит сквозь всю разработку на PHP. Чуть позже в этом модуле мы научимся преобразовывать типы явно — и делать это всегда осознанно.
diff --git a/modules/33-data-types/50-data-types-weak-typing/ru/data.yml b/modules/33-data-types/50-data-types-weak-typing/ru/data.yml
new file mode 100644
index 00000000..48701926
--- /dev/null
+++ b/modules/33-data-types/50-data-types-weak-typing/ru/data.yml
@@ -0,0 +1,5 @@
+---
+name: Слабая типизация
+tips:
+  - |
+    [Типизация](https://ru.wikipedia.org/wiki/Сильная_и_слабая_типизация)
diff --git a/modules/35-calling-functions/900-stdlib/Makefile b/modules/33-data-types/52-data-types-immutability/Makefile
similarity index 100%
rename from modules/35-calling-functions/900-stdlib/Makefile
rename to modules/33-data-types/52-data-types-immutability/Makefile
diff --git a/modules/33-data-types/52-data-types-immutability/Solution.php b/modules/33-data-types/52-data-types-immutability/Solution.php
new file mode 100644
index 00000000..2b36e502
--- /dev/null
+++ b/modules/33-data-types/52-data-types-immutability/Solution.php
@@ -0,0 +1,9 @@
+<?php
+
+$one = 'Spencer';
+$two = 'Kristina';
+$three = 'Martina';
+
+// BEGIN
+print_r("{$one[1]}{$three[2]}{$two[2]}{$two[6]}{$two[4]}");
+// END
diff --git a/modules/33-data-types/52-data-types-immutability/SolutionTest.php b/modules/33-data-types/52-data-types-immutability/SolutionTest.php
new file mode 100644
index 00000000..3239872b
--- /dev/null
+++ b/modules/33-data-types/52-data-types-immutability/SolutionTest.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace HexletBasics\DataTypes\DataTypesImmutability;
+
+use HexletBasics\Exercise\TestCase;
+
+class SolutionTest extends TestCase
+{
+    public function test()
+    {
+        $expected = 'print';
+        $this->expectOutputString($expected);
+    }
+}
diff --git a/modules/33-data-types/52-data-types-immutability/description.es.yml b/modules/33-data-types/52-data-types-immutability/description.es.yml
new file mode 100644
index 00000000..db49f53f
--- /dev/null
+++ b/modules/33-data-types/52-data-types-immutability/description.es.yml
@@ -0,0 +1,47 @@
+---
+
+name: |
+  Inmutabilidad de los tipos primitivos
+
+theory: |
+  ¿Qué sucede cuando «cambiamos» una cadena de texto en PHP? Las funciones integradas como `strtoupper()` no modifican la cadena original, sino que devuelven una nueva:
+
+  ```php
+  <?php
+
+  $firstName = 'Alexander';
+  print_r(strtoupper($firstName)); // => ALEXANDER
+  print_r($firstName); // => Alexander
+  ```
+
+  Esto se debe a la inmutabilidad de los valores primitivos en PHP: una cadena de texto no puede ser cambiada después de su creación. La inmutabilidad de los tipos primitivos es importante por varias razones, siendo la principal el rendimiento.
+
+  Pero a veces necesitamos cambiar una cadena de texto. Para eso existen las variables:
+
+  ```php
+  <?php
+
+  $firstName = 'Alexander';
+  $firstName = strtoupper($firstName);
+  print_r($firstName); // => ALEXANDER
+  ```
+
+  Hay una gran diferencia entre *cambiar el valor de una variable* y *cambiar el valor en sí*. No se puede cambiar un valor primitivo en PHP, pero se puede reemplazar el valor de una variable sin problemas.
+
+instructions: |
+  En los tres nombres de los participantes se esconde una palabra secreta. Componla y muéstrala en pantalla con los caracteres en el siguiente orden:
+
+  1. El segundo carácter de la primera cadena
+  2. El tercer carácter de la tercera cadena
+  3. El tercer carácter de la segunda cadena
+  4. El séptimo carácter de la segunda cadena
+  5. El quinto carácter de la segunda cadena
+
+  Intenta usar interpolación: dentro de las llaves puedes colocar no solo variables enteras, sino también caracteres individuales usando corchetes.
+
+tips: []
+
+definitions:
+  - name: Inmutabilidad
+    description: |
+      estado en el que un objeto o variable no puede ser cambiado después de su creación
diff --git a/modules/33-data-types/52-data-types-immutability/en/EXERCISE.md b/modules/33-data-types/52-data-types-immutability/en/EXERCISE.md
new file mode 100644
index 00000000..d4d54717
--- /dev/null
+++ b/modules/33-data-types/52-data-types-immutability/en/EXERCISE.md
@@ -0,0 +1,9 @@
+A secret word is hidden in the three participants' names. Build it and print it out from the characters in this order:
+
+1. The second character of the first string
+2. The third character of the third string
+3. The third character of the second string
+4. The seventh character of the second string
+5. The fifth character of the second string
+
+Try using interpolation: inside curly brackets you can place not only whole variables, but also individual characters using square brackets.
diff --git a/modules/33-data-types/52-data-types-immutability/en/README.md b/modules/33-data-types/52-data-types-immutability/en/README.md
new file mode 100644
index 00000000..1f98f652
--- /dev/null
+++ b/modules/33-data-types/52-data-types-immutability/en/README.md
@@ -0,0 +1,23 @@
+What happens when we "change" a string in PHP? Built-in functions like `strtoupper()` do not modify the original string — they return a new one:
+
+```php
+<?php
+
+$firstName = 'Alexander';
+print_r(strtoupper($firstName)); // => ALEXANDER
+print_r($firstName); // => Alexander
+```
+
+This happens because of the immutability of primitive values in PHP: a string itself cannot be changed after creation. The immutability of primitive types is important for many reasons. The key reason is performance.
+
+But sometimes we need to change a string. That's what variables are for:
+
+```php
+<?php
+
+$firstName = 'Alexander';
+$firstName = strtoupper($firstName);
+print_r($firstName); // => ALEXANDER
+```
+
+There is a big difference between *changing the value of a variable* and *changing the value itself*. You can't change primitive values in PHP, but you can replace the value of a variable without any problem.
diff --git a/modules/33-data-types/52-data-types-immutability/en/data.yml b/modules/33-data-types/52-data-types-immutability/en/data.yml
new file mode 100644
index 00000000..e02b5da5
--- /dev/null
+++ b/modules/33-data-types/52-data-types-immutability/en/data.yml
@@ -0,0 +1,5 @@
+---
+name: |
+  Primitive data types immutability
+tips: []
+definitions: []
diff --git a/modules/33-data-types/52-data-types-immutability/es/EXERCISE.md b/modules/33-data-types/52-data-types-immutability/es/EXERCISE.md
new file mode 100644
index 00000000..616f33ac
--- /dev/null
+++ b/modules/33-data-types/52-data-types-immutability/es/EXERCISE.md
@@ -0,0 +1,9 @@
+En los tres nombres de los participantes se esconde una palabra secreta. Componla y muéstrala en pantalla con los caracteres en el siguiente orden:
+
+1. El segundo carácter de la primera cadena
+2. El tercer carácter de la tercera cadena
+3. El tercer carácter de la segunda cadena
+4. El séptimo carácter de la segunda cadena
+5. El quinto carácter de la segunda cadena
+
+Intenta usar interpolación: dentro de las llaves puedes colocar no solo variables enteras, sino también caracteres individuales usando corchetes.
diff --git a/modules/33-data-types/52-data-types-immutability/es/README.md b/modules/33-data-types/52-data-types-immutability/es/README.md
new file mode 100644
index 00000000..83ad6cab
--- /dev/null
+++ b/modules/33-data-types/52-data-types-immutability/es/README.md
@@ -0,0 +1,23 @@
+¿Qué sucede cuando «cambiamos» una cadena de texto en PHP? Las funciones integradas como `strtoupper()` no modifican la cadena original, sino que devuelven una nueva:
+
+```php
+<?php
+
+$firstName = 'Alexander';
+print_r(strtoupper($firstName)); // => ALEXANDER
+print_r($firstName); // => Alexander
+```
+
+Esto se debe a la inmutabilidad de los valores primitivos en PHP: una cadena de texto no puede ser cambiada después de su creación. La inmutabilidad de los tipos primitivos es importante por varias razones, siendo la principal el rendimiento.
+
+Pero a veces necesitamos cambiar una cadena de texto. Para eso existen las variables:
+
+```php
+<?php
+
+$firstName = 'Alexander';
+$firstName = strtoupper($firstName);
+print_r($firstName); // => ALEXANDER
+```
+
+Hay una gran diferencia entre *cambiar el valor de una variable* y *cambiar el valor en sí*. No se puede cambiar un valor primitivo en PHP, pero se puede reemplazar el valor de una variable sin problemas.
diff --git a/modules/33-data-types/52-data-types-immutability/es/data.yml b/modules/33-data-types/52-data-types-immutability/es/data.yml
new file mode 100644
index 00000000..708e320a
--- /dev/null
+++ b/modules/33-data-types/52-data-types-immutability/es/data.yml
@@ -0,0 +1,9 @@
+---
+name: |
+  Inmutabilidad de los tipos primitivos
+tips: []
+definitions:
+  - name: Inmutabilidad
+    description: >
+      estado en el que un objeto o variable no puede ser cambiado después de su
+      creación
diff --git a/modules/33-data-types/52-data-types-immutability/ru/EXERCISE.md b/modules/33-data-types/52-data-types-immutability/ru/EXERCISE.md
new file mode 100644
index 00000000..88940032
--- /dev/null
+++ b/modules/33-data-types/52-data-types-immutability/ru/EXERCISE.md
@@ -0,0 +1,9 @@
+В трех именах участников спрятано секретное слово. Составьте и выведите его из символов в таком порядке:
+
+1. Второй символ из первой строки
+2. Третий символ из третьей строки
+3. Третий символ из второй строки
+4. Седьмой символ из второй строки
+5. Пятый символ из второй строки
+
+Попробуйте использовать интерполяцию: внутри фигурных скобок можно помещать не только целые переменные, но и отдельные символы с помощью квадратных скобок.
diff --git a/modules/33-data-types/52-data-types-immutability/ru/README.md b/modules/33-data-types/52-data-types-immutability/ru/README.md
new file mode 100644
index 00000000..859d1e02
--- /dev/null
+++ b/modules/33-data-types/52-data-types-immutability/ru/README.md
@@ -0,0 +1,76 @@
+Представим, что у нас есть строка, и мы хотим сделать все буквы в ней большими. В PHP для этого есть встроенная функция `strtoupper()`:
+
+```php
+<?php
+
+$firstName = 'Alexander';
+print_r(strtoupper($firstName)); // => ALEXANDER
+```
+
+Может показаться, что функция изменила нашу строку. Проверим:
+
+```php
+<?php
+
+print_r($firstName); // => Alexander
+```
+
+Переменная осталась прежней. Функция `strtoupper()` не меняет исходную строку — она возвращает **новую** строку, составленную из больших букв. Так в PHP работают все функции для работы со строками: само значение после создания изменить нельзя. Программисты говорят, что такие значения **неизменяемые** (или иммутабельные).
+
+## Почему значения неизменяемые?
+
+Примитивные значения в PHP (строки, числа, логические значения) ведут себя как значения в математике: число `5` нельзя «отредактировать», можно только получить из него новое число. Это дает важные преимущества:
+
+- Безопасность: значения не изменятся случайно
+- Производительность: с неизменяемыми значениями интерпретатору проще работать
+- Предсказуемость: меньше неожиданных эффектов при передаче данных в функции
+
+## А как тогда изменить строку?
+
+Если нужно «изменить» строку, создается новая строка и сохраняется в ту же переменную:
+
+```php
+<?php
+
+$firstName = 'Alexander';
+$firstName = strtoupper($firstName);
+
+print_r($firstName); // => ALEXANDER
+```
+
+Переменная `$firstName` теперь просто хранит другую строку. Происходит замена значения переменной, а сама строка `'Alexander'` остается нетронутой.
+
+```text
+$firstName = 'Alexander'
+
+strtoupper($firstName)  →  'ALEXANDER'   ←  создана новая строка
+$firstName              →  'Alexander'   ←  исходная не изменилась
+
+$firstName = strtoupper($firstName)
+└──────────────┬───────────────────┘
+   в переменной теперь новая строка
+```
+
+Важно различать две вещи: *изменение значения переменной* и *изменение самого значения*. Значение переменной можно заменить без проблем, а вот само значение — строку, число — изменить нельзя.
+
+## Новая переменная или та же?
+
+Переиспользовать переменную стоит только тогда, когда речь идет об одной и той же сущности. Если пользователь ввел новое имя, это уже другая сущность, и лучше создать отдельную переменную:
+
+```php
+<?php
+
+// Одна и та же строка, просто обновляем
+$name = 'Alexander';
+$name = 'Blexander';
+
+// Разные сущности, лучше разные переменные
+$firstName = 'Alexander';
+$correctedFirstName = 'Blexander';
+```
+
+Попытка «запихать» все строки в одну переменную запутывает код. Переменная перестает говорить, что в ней хранится.
+
+## Вывод
+
+Примитивные типы данных в PHP (строки string, целые числа int, вещественные числа float и логические значения bool) ведут себя как неизменяемые (immutable) значения. Функции не меняют переданные им строки и числа, а возвращают новые значения. Любые «изменения» происходят путем создания нового значения и переопределения переменной.
diff --git a/modules/33-data-types/52-data-types-immutability/ru/data.yml b/modules/33-data-types/52-data-types-immutability/ru/data.yml
new file mode 100644
index 00000000..e0a8b6bd
--- /dev/null
+++ b/modules/33-data-types/52-data-types-immutability/ru/data.yml
@@ -0,0 +1,9 @@
+---
+name: |
+  Неизменяемость примитивных типов
+tips: []
+definitions:
+  - name: Неизменяемость
+    description: >
+      состояние, при котором объект, переменная не могут быть изменены после
+      создания
diff --git a/modules/30-variables/35-heredoc/Makefile b/modules/33-data-types/55-data-types-casting/Makefile
similarity index 100%
rename from modules/30-variables/35-heredoc/Makefile
rename to modules/33-data-types/55-data-types-casting/Makefile
diff --git a/modules/33-data-types/55-data-types-casting/Solution.php b/modules/33-data-types/55-data-types-casting/Solution.php
new file mode 100644
index 00000000..41b8bd35
--- /dev/null
+++ b/modules/33-data-types/55-data-types-casting/Solution.php
@@ -0,0 +1,9 @@
+<?php
+
+$temperature = 36.6;
+
+// BEGIN
+$intValue = (int) $temperature;
+$strValue = (string) $intValue;
+print_r($strValue . ' °C');
+// END
diff --git a/modules/33-data-types/55-data-types-casting/SolutionTest.php b/modules/33-data-types/55-data-types-casting/SolutionTest.php
new file mode 100644
index 00000000..814092d6
--- /dev/null
+++ b/modules/33-data-types/55-data-types-casting/SolutionTest.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace HexletBasics\DataTypes\DataTypesCasting;
+
+use HexletBasics\Exercise\TestCase;
+
+class SolutionTest extends TestCase
+{
+    public function test()
+    {
+        $expected = '36 °C';
+        $this->expectOutputString($expected);
+    }
+}
diff --git a/modules/27-data-types/55-type-conversion/description.es.yml b/modules/33-data-types/55-data-types-casting/description.es.yml
similarity index 100%
rename from modules/27-data-types/55-type-conversion/description.es.yml
rename to modules/33-data-types/55-data-types-casting/description.es.yml
diff --git a/modules/27-data-types/55-type-conversion/en/EXERCISE.md b/modules/33-data-types/55-data-types-casting/en/EXERCISE.md
similarity index 100%
rename from modules/27-data-types/55-type-conversion/en/EXERCISE.md
rename to modules/33-data-types/55-data-types-casting/en/EXERCISE.md
diff --git a/modules/27-data-types/55-type-conversion/en/README.md b/modules/33-data-types/55-data-types-casting/en/README.md
similarity index 100%
rename from modules/27-data-types/55-type-conversion/en/README.md
rename to modules/33-data-types/55-data-types-casting/en/README.md
diff --git a/modules/27-data-types/55-type-conversion/en/data.yml b/modules/33-data-types/55-data-types-casting/en/data.yml
similarity index 100%
rename from modules/27-data-types/55-type-conversion/en/data.yml
rename to modules/33-data-types/55-data-types-casting/en/data.yml
diff --git a/modules/27-data-types/55-type-conversion/es/EXERCISE.md b/modules/33-data-types/55-data-types-casting/es/EXERCISE.md
similarity index 100%
rename from modules/27-data-types/55-type-conversion/es/EXERCISE.md
rename to modules/33-data-types/55-data-types-casting/es/EXERCISE.md
diff --git a/modules/27-data-types/55-type-conversion/es/README.md b/modules/33-data-types/55-data-types-casting/es/README.md
similarity index 100%
rename from modules/27-data-types/55-type-conversion/es/README.md
rename to modules/33-data-types/55-data-types-casting/es/README.md
diff --git a/modules/27-data-types/55-type-conversion/es/data.yml b/modules/33-data-types/55-data-types-casting/es/data.yml
similarity index 100%
rename from modules/27-data-types/55-type-conversion/es/data.yml
rename to modules/33-data-types/55-data-types-casting/es/data.yml
diff --git a/modules/33-data-types/55-data-types-casting/ru/EXERCISE.md b/modules/33-data-types/55-data-types-casting/ru/EXERCISE.md
new file mode 100644
index 00000000..ee11dc18
--- /dev/null
+++ b/modules/33-data-types/55-data-types-casting/ru/EXERCISE.md
@@ -0,0 +1,17 @@
+Термометр показывает температуру с десятичной точкой. Программа должна вывести только целое значение с подписью.
+
+У вас есть переменная:
+
+```php
+<?php
+
+$temperature = 36.6;
+```
+
+Напишите программу, которая:
+
+1. Преобразует температуру в целое число.
+2. Полученное число превратит в строку.
+3. Выведет эту строку на экран, добавив через пробел подпись `°C`.
+
+Используйте операторы приведения типа `(int)` и `(string)`.
diff --git a/modules/33-data-types/55-data-types-casting/ru/README.md b/modules/33-data-types/55-data-types-casting/ru/README.md
new file mode 100644
index 00000000..6125767c
--- /dev/null
+++ b/modules/33-data-types/55-data-types-casting/ru/README.md
@@ -0,0 +1,83 @@
+В реальных программах часто возникает ситуация, когда данные одного типа нужно превратить в другой. Это особенно актуально, например, при обработке ввода пользователя или данных из веб-форм. Там все приходит в виде строк, даже если вы ввели число.
+
+![Преобразование типов в PHP](./assets/number-as-string.png)
+
+PHP умеет преобразовывать типы автоматически — мы видели это в уроке про слабую типизацию. Но полагаться на неявные преобразования опасно. Когда вы точно знаете, какой тип хотите получить, лучше преобразовать значение **явно**. Для этого в PHP есть специальный синтаксис: перед значением в скобках указывается желаемый тип. Такая операция называется приведением типа (type casting). Явный код понятнее и предсказуемее.
+
+## Преобразование строки в число
+
+Представим, что мы получили из формы строку `'345'`, а нам нужно сложить это число с другим:
+
+```php
+<?php
+
+$number = (int) '345';
+print_r($number + 5); // => 350
+```
+
+Оператор `(int)` получает строку и превращает ее в целое число.
+
+```php
+<?php
+
+$value = '0';
+$convertedValue = (int) $value;
+print_r($convertedValue); // => 0
+
+print_r((int) '10'); // => 10
+print_r((int) 3.5);  // => 3 (дробная часть отбрасывается)
+```
+
+```text
+'123'  ──(int)──→  123  ──(float)──→  123.0
+                    │
+                (string)
+                    ↓
+                  '123'
+```
+
+## Преобразование в строку с помощью (string)
+
+Если нужно превратить число в строку, используйте оператор `(string)`:
+
+```php
+<?php
+
+print_r((string) 10);  // => '10'
+print_r((string) 3.5); // => '3.5'
+```
+
+Это полезно, например, при формировании текстов, сообщений и вывода:
+
+```php
+<?php
+
+$age = 42;
+print_r('Age: ' . (string) $age); // => Age: 42
+```
+
+## Преобразование в число с плавающей точкой с помощью (float)
+
+Если нужно число с десятичной точкой, используйте `(float)`:
+
+```php
+<?php
+
+print_r((float) '2.7'); // => 2.7
+```
+
+Выражение `(float) 5` тоже сработает: получится дробное число `5.0`, хотя `print_r()` выведет его без дробной части — как `5`.
+
+## Множественные преобразования
+
+Приведение типа можно использовать и внутри составных выражений. В более сложных ситуациях встречаются множественные преобразования: `(string) (5 + ((int) '4'))`. Порядок вычисления этого выражения следующий:
+
+```php
+<?php
+
+(int) '4';  // 4
+5 + 4;      // 9
+(string) 9; // '9'
+```
+
+На текущий момент мы знакомы только с несколькими типами, но приведение работает для любого типа.
diff --git a/modules/33-data-types/55-data-types-casting/ru/assets/number-as-string.png b/modules/33-data-types/55-data-types-casting/ru/assets/number-as-string.png
new file mode 100644
index 00000000..76d69af3
Binary files /dev/null and b/modules/33-data-types/55-data-types-casting/ru/assets/number-as-string.png differ
diff --git a/modules/33-data-types/55-data-types-casting/ru/data.yml b/modules/33-data-types/55-data-types-casting/ru/data.yml
new file mode 100644
index 00000000..47675627
--- /dev/null
+++ b/modules/33-data-types/55-data-types-casting/ru/data.yml
@@ -0,0 +1,6 @@
+---
+name: Явное преобразование типов
+tips:
+  - |
+    [Типизация](https://ru.wikipedia.org/wiki/Сильная_и_слабая_типизация)
+definitions: []
diff --git a/modules/27-data-types/description.en.yml b/modules/33-data-types/description.en.yml
similarity index 100%
rename from modules/27-data-types/description.en.yml
rename to modules/33-data-types/description.en.yml
diff --git a/modules/27-data-types/description.es.yml b/modules/33-data-types/description.es.yml
similarity index 100%
rename from modules/27-data-types/description.es.yml
rename to modules/33-data-types/description.es.yml
diff --git a/modules/27-data-types/description.ru.yml b/modules/33-data-types/description.ru.yml
similarity index 100%
rename from modules/27-data-types/description.ru.yml
rename to modules/33-data-types/description.ru.yml
diff --git a/modules/35-calling-functions/100-call/index.php b/modules/35-calling-functions/100-call/Solution.php
similarity index 100%
rename from modules/35-calling-functions/100-call/index.php
rename to modules/35-calling-functions/100-call/Solution.php
diff --git a/modules/35-calling-functions/100-call/SolutionTest.php b/modules/35-calling-functions/100-call/SolutionTest.php
index d1039aba..1b276e41 100644
--- a/modules/35-calling-functions/100-call/SolutionTest.php
+++ b/modules/35-calling-functions/100-call/SolutionTest.php
@@ -2,9 +2,7 @@
 
 namespace HexletBasics\CallingFunctions\Call;
 
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
@@ -12,6 +10,5 @@ public function test()
     {
         $expected = "12";
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/35-calling-functions/100-call/ru/EXERCISE.md b/modules/35-calling-functions/100-call/ru/EXERCISE.md
index 081bc8d1..112cc739 100644
--- a/modules/35-calling-functions/100-call/ru/EXERCISE.md
+++ b/modules/35-calling-functions/100-call/ru/EXERCISE.md
@@ -1 +1 @@
-В коде программы определены две переменные, содержащие имена компаний. Посчитайте их общую длину в символах и выведите ее на экран.
+Сайт проверяет, вместится ли реклама двух компаний-партнеров в одну строку. В коде определены их названия — посчитайте общее количество символов в обоих названиях с помощью функции `strlen()` и выведите на экран.
diff --git a/modules/35-calling-functions/100-call/ru/README.md b/modules/35-calling-functions/100-call/ru/README.md
index 5fdd3b8a..b73cdfb3 100644
--- a/modules/35-calling-functions/100-call/ru/README.md
+++ b/modules/35-calling-functions/100-call/ru/README.md
@@ -1,64 +1,147 @@
-Сложение, конкатенация и остальные рассмотренные операции — это базовые возможности языков программирования. Но со строками можно производить более сложные операции. Их можно переворачивать, менять регистр букв, удалять лишние символы.
+Программирование нужно для того, чтобы выполнять самые разные операции. Иногда это простые действия, например сложение чисел или объединение строк. Но чаще это сложные процессы вроде перевода денег со счета на счет, оформления заказа в интернет-магазине, расчета налогов или подготовки отчета.
 
-На более высоком уровне есть прикладная логика конкретного приложения. Программы списывают деньги, считают налоги, формируют отчеты. Количество подобных операций бесконечно и индивидуально для каждой программы. И все они должны быть выражены в коде. В этом помогают функции, с которыми мы познакомимся в этом уроке.
+Такие операции невозможно выразить одной командой. За действием вроде «перевести деньги» могут скрываться десятки, сотни и даже тысячи строк кода. Это проверка баланса, списание суммы, учет комиссии, обновление базы данных, отправка уведомления пользователю.
 
-## Какие бывают функции
+Чтобы управлять этим кодом и не теряться в деталях, используют функции. Функция объединяет блок кода в единое целое, прячет реализацию и позволяет сосредоточиться на смысле. Для программиста достаточно вызвать функцию и доверить ей всю внутреннюю работу.
 
-Для выражения любой произвольной операции в программировании существуют **функции**. Они бывают встроенными и добавленными программистом. С одной встроенной функцией мы уже знакомы — это `print_r()`.
+![Функция](./assets/function.png)
 
-**Функции** — одна из ключевых конструкций в программировании, без них невозможно сделать практически ничего. Сначала мы научимся пользоваться уже созданными функциями, а потом научимся создавать свои.
+Представим функцию, которая переводит деньги с одного счета на другой. В реальности внутри нее могут быть сотни строк кода, но мы этого не видим. Снаружи все выглядит как одна простая команда:
 
-## Как работать со встроенными функциями
+```php
+<?php
+
+transferMoney('Alice', 'Bob', 100);
+```
+
+Эта строка вызывает функцию `transferMoney()`. Ей передаются отправитель `Alice`, получатель `Bob` и сумма `100`.
 
-Начнем с простых функций для работы над строками. Ниже пример вызова функции `strrev()`, которая переворачивает строку:
+Вот еще несколько примеров вызова функций, которые мы могли бы реализовать. У каждой функции свое имя и свой набор данных для работы.
 
 ```php
 <?php
 
-// Вызов функции strrev с аргументом 'Hello!'
-$result = strrev('Hello!');
-print_r($result); // => '!olleH'
+// Да-да, print_r тоже функция
+print_r('Хекслет!');
+
+// Отправка письма пользователю
+sendEmail('bob@example.com', 'Добро пожаловать!');
+
+// Вычисление налога с указанной суммы
+calculateTax(5000, 'Florida');
+
+// Проверка, есть ли пользователь в системе
+isRegistered('Alice');
+
+// Получение случайного числа от 1 до 10
+randomNumber(1, 10);
+
+// Создание резервной копии базы данных
+backupDatabase();
+
+// Вычисление длины строки
+strlen('Hexlet'); // Результат: 6
 ```
 
-Мы создали переменную `$result` и указали интерпретатору записать в нее результат, который вернет вызов функции `strrev()`. В этом смысле функции идентичны операциям — они всегда возвращают результат своей работы.
+В вызове функции сначала пишется ее **имя**, затем круглые **скобки**. Скобки показывают, что это именно вызов. Так мы понимаем, что перед нами функция, а не переменная.
 
-Запись `strrev('Hello!')` означает, что вызывается функция с именем `strrev`, в которую был передан аргумент или параметр `'Hello!'`.
+Внутри скобок указываются **аргументы**, то есть данные, которые функция получает для работы. Их может быть несколько, один или вовсе ни одного.
 
-Аргументы нужны функциям для работы так же, как операторам нужны операнды. Функция `strrev()` переворачивает ту строку, которая передается ей в аргументах.
+## Откуда берутся функции?
 
-Вызов функции всегда обозначается скобками `()`. Они идут сразу за именем функции. В скобках может быть любое количество аргументов, а иногда — ни одного. Количество зависит от используемой функции. Например, функция `pow()` принимает на вход два аргумента и возводит число, переданное первым параметром, в степень, переданную вторым параметром:
+Одни функции встроены в язык (built-in), другие создают сами программисты.
+
+**Встроенные функции** представляют собой функции, которые идут вместе с языком PHP. Их можно использовать сразу, без дополнительных действий. В качестве примера можно привести функцию `print_r()`. Как говорят, она доступна глобально.
+
+**Функции, определяемые программистами**, создаются тогда, когда нужно оформить свою логику в отдельный блок. Такую функцию можно назвать любым именем и использовать в коде так же, как встроенные. Мы научимся этому позже.
+
+Кроме того, существуют функции, которые находятся в отдельных библиотеках. Чтобы ими пользоваться, библиотеку нужно установить и подключить к программе. Подробно этот механизм мы пока не разбираем. Пока достаточно знать, что он позволяет подключить внешний набор функций и сделать их доступными в программе.
+
+## Функция с одним параметром
+
+Одной из самых часто используемых встроенных функций является `strlen()`. Она возвращает количество символов в строке.
 
 ```php
 <?php
 
-$result = pow(2, 3); // 2 * 2 * 2
-print_r($result); // => 8
+$message = 'Hello!';
+$count = strlen($message);
+print_r($count); // => 6
+```
+
+Здесь в строке `'Hello!'` шесть символов, поэтому вызов `strlen($message)` вернет число `6`.
 
-// В современном PHP появился специальный оператор для возведения в степень
-$result = 2 ** 3; // 8
+```text
+Аргументы          Функция         Результат
+┌──────────┐     ┌──────────┐     ┌──────────┐
+│ 'Hello!' │ ──→ │ strlen() │ ──→ │    6     │
+└──────────┘     └──────────┘     └──────────┘
 ```
 
-Теперь рассмотрим пример функции, которая не принимает аргументов. Функция `rand()` генерирует и возвращает случайное число:
+## Возврат значения
+
+Возврат значения является одним из ключевых принципов работы функций. Благодаря ему мы можем соединять результаты разных действий и строить более сложную логику. Если функция возвращает значение, то мы можем сохранить его в переменную, передать в другую функцию или использовать в вычислениях. Именно так работает `strlen()`. Она считает количество символов и отдает результат наружу.
 
 ```php
 <?php
 
-$result = rand();
+$message1 = 'Hello!';
+$length1 = strlen($message1); // сохраняем результат
+
+$message2 = 'World!';
+$length2 = strlen($message2);
+
+$combinedLength = $length1 + $length2; // используем результат в выражении
+print_r($combinedLength); // => 12
+```
+
+Если бы `strlen()` сразу печатала результат на экран (как делает `print_r()`), то мы бы увидели число, но не смогли бы его использовать:
+
+```php
+<?php
+
+// воображаемая функция, которая только печатает результат
+fakeStrlen('Hello!'); // напечатает 6
+
+// но дальше это число уже недоступно
+// мы не можем его прибавить, сохранить или сравнить
+$result = fakeStrlen('Hello!'); // здесь в $result ничего нет
 ```
 
-Операторы и функции — это одно и то же. Разница в том, как они записываются. Если представить сложение как функцию, то она будет выглядеть так:
+Вот почему возврат значения представляет собой настолько важную концепцию. Он позволяет связывать функции между собой. Одни возвращают данные, другие используют их в своей работе. Именно так из маленьких шагов строятся большие и сложные программы.
+
+## Функция с несколькими параметрами
+
+Некоторые функции принимают сразу несколько данных для работы. В качестве примера подойдет встроенная функция `pow()`, которая возводит число в нужную степень. Первый параметр принимает основание степени, второй задает показатель.
 
 ```php
 <?php
 
-3 + 5; // 8
-sum(3, 5); // 8
+// 2 возводим в 3-ю степень: 2 * 2 * 2
+$result = pow(2, 3);
+print_r($result); // => 8
+
+// 5 во 2-й степени: 5 * 5
+print_r(pow(5, 2)); // => 25
+```
+
+По структуре вызов с несколькими параметрами не отличается от вызова с одним. Те же имя функции, скобки и аргументы через запятую внутри.
+
+## Параметры и аргументы
+
+В разговорах о функциях то и дело встречаются слова **параметры** и **аргументы**. Они связаны, но не одно и то же.
+
+О **параметрах** говорят при создании функции. Параметром называют переменную внутри функции, в которую попадает переданное значение. Об **аргументах** говорят при вызове. Аргументом называют то, что мы передаем в функцию. Это может быть число, переменная или любое выражение.
+
+```php
+<?php
 
-// Или даже так
-+(3, 5);
+// числа в качестве аргументов
+print_r(pow(2, 3)); // => 8
 
-// В PHP такой синтаксис невозможен, но есть языки (например, lisp),
-// где оно выглядит очень похоже
+$x = 2;
+// аргумент может быть выражением, оно вычислится до передачи в функцию
+print_r(pow($x + 1, 3)); // => 27
 ```
 
-Вопрос на самопроверку. Как узнать, что возвращает вызов `print_r()`? Проверьте.
+Запоминать это не обязательно, но пригодится при чтении англоязычной литературы.
diff --git a/modules/35-calling-functions/100-call/ru/assets/function.png b/modules/35-calling-functions/100-call/ru/assets/function.png
new file mode 100644
index 00000000..f89fee08
Binary files /dev/null and b/modules/35-calling-functions/100-call/ru/assets/function.png differ
diff --git a/modules/35-calling-functions/120-function-signature/SolutionTest.php b/modules/35-calling-functions/120-function-signature/SolutionTest.php
deleted file mode 100644
index 46c2447b..00000000
--- a/modules/35-calling-functions/120-function-signature/SolutionTest.php
+++ /dev/null
@@ -1,17 +0,0 @@
-<?php
-
-namespace HexletBasics\CallingFunctions\FunctionSignature;
-
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        $expected = 'Mount';
-        $this->expectOutputString($expected);
-        require 'index.php';
-    }
-}
diff --git a/modules/35-calling-functions/120-function-signature/description.es.yml b/modules/35-calling-functions/120-function-signature/description.es.yml
deleted file mode 100644
index 4755f47b..00000000
--- a/modules/35-calling-functions/120-function-signature/description.es.yml
+++ /dev/null
@@ -1,87 +0,0 @@
----
-
-name: Firma de la función
-theory: |
-  En esta lección aprenderemos a trabajar con la firma de una función. También aprenderemos cómo una función recibe y devuelve valores. Analizaremos las funciones `abs()` y `round()`.
-
-  ## Función abs()
-
-  La función `abs()`, que devuelve el valor absoluto, recibe un parámetro: un número. Si llamamos a `abs()` sin parámetros, PHP mostrará el siguiente mensaje de error:
-
-  ```
-  TypeError: abs() expects exactly 1 argument, 0 given
-  ```
-
-  Esto indica que la función espera un parámetro, pero la llamamos sin ninguno.
-
-  Los parámetros de `abs()` solo pueden ser números. Si intentamos pasarle una cadena de texto, obtendremos el siguiente error:
-
-  ```
-  TypeError: abs(): Argument #1 ($num) must be of type int|float, string given
-  ```
-
-  El resultado de llamar a esta función siempre es un número. Otra función puede tener un número diferente de parámetros y diferentes tipos de parámetros. Por ejemplo, puede existir una función que reciba tres parámetros: un número, una cadena de texto y otro número.
-
-  ¿Cómo sabemos cuántos y qué tipo de parámetros necesita la función `abs()` y qué tipo de valor devuelve? Lo vemos en la **firma** de la función. La firma define los parámetros de entrada y sus tipos, así como el parámetro de salida y su tipo.
-
-  Puedes leer más sobre la función `abs()` en la [documentación oficial de PHP](https://www.php.net/manual/es/function.abs.php). En la sección "Descripción" encontrarás el siguiente texto:
-
-  ```txt
-  abs(int|float $num): int|float
-
-  Devuelve el valor absoluto de num.
-  ```
-
-  Esta es la firma de la función y una breve explicación en español.
-
-  La información se interpreta de la siguiente manera:
-
-  * El nombre de la función es `abs`
-  * La función recibe un parámetro: un número (num)
-  * La función devuelve un número
-  * La función devuelve el valor absoluto de num
-
-  Si hay más de un parámetro, debemos pasarlos en el mismo orden en que están definidos en la firma. Cualquier función siempre devuelve solo un valor. Esta es una limitación del lenguaje y no puede ser violada.
-
-  ## Argumentos por defecto
-
-  Veamos la función `round()`. Esta función redondea un número:
-
-  ```php
-  <?php
-
-  $result = round(10.25, 0); // 10
-  ```
-
-  Le pasamos dos argumentos: el número y la precisión de redondeo. El valor `0` significa que se redondeará al número entero más cercano.
-
-  La mayoría de las veces, queremos redondear al número entero, por lo que los creadores de la función `round` hicieron que el segundo argumento sea opcional y le dieron un valor predeterminado de `0`. Esto significa que podemos omitir el segundo argumento y el resultado será el mismo:
-
-  ```php
-  <?php
-
-  $result = round(10.25); // 10
-  ```
-
-  Y si necesitamos una precisión diferente, podemos pasar un argumento:
-
-  ```php
-  <?php
-
-  $result = round(10.25, 1); // 10.3
-  ```
-
-  Si una función en PHP tiene argumentos opcionales, siempre se colocan después de los argumentos obligatorios. Pueden ser cualquier cantidad de argumentos, dependiendo de la función. Pero estos argumentos siempre se colocan juntos y al final de la lista de argumentos.
-
-instructions: |
-  Ahora es tu turno de mirar la firma de una función en la documentación y entender cómo usarla. Puedes leer la documentación en español, pero un programador debe ser capaz de leer la documentación en inglés. Utiliza diccionarios o traductores si es necesario. Es mejor acostumbrarse y mejorar tus habilidades de lectura en inglés desde el principio, de lo contrario, tendrás dificultades en el futuro.
-
-  En PHP, hay una función llamada `ucfirst()`. Estudia su firma en la página [https://php.net/manual/es/function.ucfirst.php](https://php.net/manual/es/function.ucfirst.php).
-
-  Escribe un programa que utilice la función `ucfirst()` con la variable `$text` y muestre el resultado en pantalla. El valor de la variable `$text` ya está definido.
-
-tips: []
-
-definitions:
-  - name: Firma de la función
-    description: descripción formal de los tipos de argumentos y el tipo de valor devuelto por una función.
diff --git a/modules/35-calling-functions/120-function-signature/en/EXERCISE.md b/modules/35-calling-functions/120-function-signature/en/EXERCISE.md
deleted file mode 100644
index f2ef9574..00000000
--- a/modules/35-calling-functions/120-function-signature/en/EXERCISE.md
+++ /dev/null
@@ -1,6 +0,0 @@
-
-Now it's your turn, look at the signature of a function in the documentation and work out how to use it. Now it's your turn to find the function signature in the documentation and figure out how to use it.
-
-In PHP, there's a function called `ucfirst()`. Study its signature at [https://www.php.net/manual/en/function.ucfirst.php](https://www.php.net/manual/en/function.ucfirst.php).
-
-Write a program that uses `ucfirst()` with the variable `$text` and displays the result. The value of the `$text` variable is already defined.
diff --git a/modules/35-calling-functions/120-function-signature/en/README.md b/modules/35-calling-functions/120-function-signature/en/README.md
deleted file mode 100644
index 1711de36..00000000
--- a/modules/35-calling-functions/120-function-signature/en/README.md
+++ /dev/null
@@ -1,28 +0,0 @@
-
-The `pow()`, function, which raises a number to any power, takes two parameters: **which number to raise** and **to what power to raise it to**. If you call `pow()` without parameters, PHP outputs the following: `PHP Warning:  pow() expects exactly 2 parameters, 0 given in php shell code on line 1`. The interpreter has told you that the function expects 2 parameters, and that you called it without parameters.
-
-Whoever created the `pow()`, function made it a function with two mandatory parameters, so it can't be called with any other number of parameters.
-
-Moreover, the parameters of `pow()` can only be numbers. Attempting to pass, for example, a string to it will result in the following error: `PHP Warning:  A non-numeric value encountered in php shell code on line 1`. The result of this function call will also always be a number.
-
-Other functions may have different numbers of parameters and different types of parameters. For example, there may be a function that takes three parameters: a number, a string, and another number.
-
-How do we know how many parameters the `pow` function needs and what sort of result it'll return? We've taken a look at this function's **signature**. The signature defines the input parameters and their types, as well as the output parameter and its type. You can read about the `pow` function in [the official PHP documentation](https://www.php.net/manual/en/function.pow.php). In the "description" section, you can see this this text:
-
-```text
-pow ( number $base , number $exp ) : number
-
-Returns base raised to the power of exp.
-```
-
-This is a function signature and a short explanation.
-
-The information is deciphered as follows:
-- the function is called `pow`
-- the function takes two parameters: a number (base) and a number (exp)
-- the function returns a number (number)
-- the function returns base raised to the power of exp
-
-Parameters can only be passed in the order they're given in the signature.
-
-Any function will always return only one value. This restriction exists at language level and cannot be broken.
diff --git a/modules/35-calling-functions/120-function-signature/en/data.yml b/modules/35-calling-functions/120-function-signature/en/data.yml
deleted file mode 100644
index a017ebd6..00000000
--- a/modules/35-calling-functions/120-function-signature/en/data.yml
+++ /dev/null
@@ -1,7 +0,0 @@
----
-name: Function signature
-definitions:
-  - name: A function signature
-    description: >-
-      is a formal description of the types of arguments and the type of return
-      value of a function.
diff --git a/modules/35-calling-functions/120-function-signature/es/EXERCISE.md b/modules/35-calling-functions/120-function-signature/es/EXERCISE.md
deleted file mode 100644
index 9c293162..00000000
--- a/modules/35-calling-functions/120-function-signature/es/EXERCISE.md
+++ /dev/null
@@ -1,5 +0,0 @@
-Ahora es tu turno de mirar la firma de una función en la documentación y entender cómo usarla. Puedes leer la documentación en español, pero un programador debe ser capaz de leer la documentación en inglés. Utiliza diccionarios o traductores si es necesario. Es mejor acostumbrarse y mejorar tus habilidades de lectura en inglés desde el principio, de lo contrario, tendrás dificultades en el futuro.
-
-En PHP, hay una función llamada `ucfirst()`. Estudia su firma en la página [https://php.net/manual/es/function.ucfirst.php](https://php.net/manual/es/function.ucfirst.php).
-
-Escribe un programa que utilice la función `ucfirst()` con la variable `$text` y muestre el resultado en pantalla. El valor de la variable `$text` ya está definido.
diff --git a/modules/35-calling-functions/120-function-signature/es/README.md b/modules/35-calling-functions/120-function-signature/es/README.md
deleted file mode 100644
index 4ae1e666..00000000
--- a/modules/35-calling-functions/120-function-signature/es/README.md
+++ /dev/null
@@ -1,70 +0,0 @@
-En esta lección aprenderemos a trabajar con la firma de una función. También aprenderemos cómo una función recibe y devuelve valores. Analizaremos las funciones `abs()` y `round()`.
-
-## Función abs()
-
-La función `abs()`, que devuelve el valor absoluto, recibe un parámetro: un número. Si llamamos a `abs()` sin parámetros, PHP mostrará el siguiente mensaje de error:
-
-```text
-TypeError: abs() expects exactly 1 argument, 0 given
-```
-
-Esto indica que la función espera un parámetro, pero la llamamos sin ninguno.
-
-Los parámetros de `abs()` solo pueden ser números. Si intentamos pasarle una cadena de texto, obtendremos el siguiente error:
-
-```text
-TypeError: abs(): Argument #1 ($num) must be of type int|float, string given
-```
-
-El resultado de llamar a esta función siempre es un número. Otra función puede tener un número diferente de parámetros y diferentes tipos de parámetros. Por ejemplo, puede existir una función que reciba tres parámetros: un número, una cadena de texto y otro número.
-
-¿Cómo sabemos cuántos y qué tipo de parámetros necesita la función `abs()` y qué tipo de valor devuelve? Lo vemos en la **firma** de la función. La firma define los parámetros de entrada y sus tipos, así como el parámetro de salida y su tipo.
-
-Puedes leer más sobre la función `abs()` en la [documentación oficial de PHP](https://www.php.net/manual/es/function.abs.php). En la sección "Descripción" encontrarás el siguiente texto:
-
-```txt
-abs(int|float $num): int|float
-
-Devuelve el valor absoluto de num.
-```
-
-Esta es la firma de la función y una breve explicación en español.
-
-La información se interpreta de la siguiente manera:
-
-* El nombre de la función es `abs`
-* La función recibe un parámetro: un número (num)
-* La función devuelve un número
-* La función devuelve el valor absoluto de num
-
-Si hay más de un parámetro, debemos pasarlos en el mismo orden en que están definidos en la firma. Cualquier función siempre devuelve solo un valor. Esta es una limitación del lenguaje y no puede ser violada.
-
-## Argumentos por defecto
-
-Veamos la función `round()`. Esta función redondea un número:
-
-```php
-<?php
-
-$result = round(10.25, 0); // 10
-```
-
-Le pasamos dos argumentos: el número y la precisión de redondeo. El valor `0` significa que se redondeará al número entero más cercano.
-
-La mayoría de las veces, queremos redondear al número entero, por lo que los creadores de la función `round` hicieron que el segundo argumento sea opcional y le dieron un valor predeterminado de `0`. Esto significa que podemos omitir el segundo argumento y el resultado será el mismo:
-
-```php
-<?php
-
-$result = round(10.25); // 10
-```
-
-Y si necesitamos una precisión diferente, podemos pasar un argumento:
-
-```php
-<?php
-
-$result = round(10.25, 1); // 10.3
-```
-
-Si una función en PHP tiene argumentos opcionales, siempre se colocan después de los argumentos obligatorios. Pueden ser cualquier cantidad de argumentos, dependiendo de la función. Pero estos argumentos siempre se colocan juntos y al final de la lista de argumentos.
diff --git a/modules/35-calling-functions/120-function-signature/es/data.yml b/modules/35-calling-functions/120-function-signature/es/data.yml
deleted file mode 100644
index 13637a60..00000000
--- a/modules/35-calling-functions/120-function-signature/es/data.yml
+++ /dev/null
@@ -1,8 +0,0 @@
----
-name: Firma de la función
-tips: []
-definitions:
-  - name: Firma de la función
-    description: >-
-      descripción formal de los tipos de argumentos y el tipo de valor devuelto
-      por una función.
diff --git a/modules/35-calling-functions/120-function-signature/index.php b/modules/35-calling-functions/120-function-signature/index.php
deleted file mode 100644
index a826b95e..00000000
--- a/modules/35-calling-functions/120-function-signature/index.php
+++ /dev/null
@@ -1,7 +0,0 @@
-<?php
-
-$text = 'mount';
-
-// BEGIN
-print_r(ucfirst($text));
-// END
diff --git a/modules/35-calling-functions/120-function-signature/ru/EXERCISE.md b/modules/35-calling-functions/120-function-signature/ru/EXERCISE.md
deleted file mode 100644
index 6830c809..00000000
--- a/modules/35-calling-functions/120-function-signature/ru/EXERCISE.md
+++ /dev/null
@@ -1,5 +0,0 @@
-Теперь ваша очередь посмотреть на сигнатуру функции в документации и разобраться, как её использовать. Можете читать документацию на русском языке, но программист обязан уметь читать документацию на английском. Используйте словари или переводчики при необходимости. Лучше сразу привыкать и подтягивать навыки чтения на английском, иначе будут сложности в будущем.
-
-В PHP есть функция `ucfirst()`. Изучите её сигнатуру на странице [https://php.net/manual/ru/function.ucfirst.php](https://php.net/manual/ru/function.ucfirst.php).
-
-Напишите программу, которая использует функцию `ucfirst()` с переменной `$text` и выводит результат на экран. Значение переменной `$text` уже определено.
diff --git a/modules/35-calling-functions/120-function-signature/ru/README.md b/modules/35-calling-functions/120-function-signature/ru/README.md
deleted file mode 100644
index 4668407c..00000000
--- a/modules/35-calling-functions/120-function-signature/ru/README.md
+++ /dev/null
@@ -1,70 +0,0 @@
-В этом уроке мы научимся работать с сигнатурой функции. Также мы узнаем, как функция принимает и возвращает значения. Мы разберем функции `abs()` и `round()`.
-
-## Функция abs()
-
-Функция `abs()`, которая возвращает абсолютное значение, принимает параметр — число. Если вызывать `abs()` без параметров, то PHP выдаст следующее:
-
-```text
-TypeError: abs() expects exactly 1 argument, 0 given
-```
-
-Так интерпретатор сообщает, что функция ожидает один параметр, а мы вызвали ее без параметров.
-
-Параметрами `abs()` могут быть только числа. Если мы попробуем передать в нее строку, это приведет к следующей ошибке:
-
-```text
-TypeError: abs(): Argument #1 ($num) must be of type int|float, string given
-```
-
-Результат вызова этой функции — тоже всегда число. Другая функция может иметь иное число параметров и другие типы параметров. Например, может существовать функция, которая принимает три параметра: число, строку и еще одно число.
-
-Откуда мы знаем, сколько и каких параметров нужно функции `abs()` и какого типа будет возврат? Мы посмотрели в **сигнатуру** этой функции. Сигнатура определяет входные параметры и их типы, а также выходной параметр и его тип.
-
-О функции `abs()` можно почитать в [официальной документации PHP](https://www.php.net/manual/ru/function.abs.php). В разделе «Описание» есть такой текст:
-
-```txt
-abs(int|float $num): int|float
-
-Возвращает абсолютное значение num.
-```
-
-Это сигнатура функции и короткое пояснение на русском языке.
-
-Информация расшифровывается так:
-
-* Функция называется `abs`
-* Функция принимает параметр: число (num)
-* Функция возвращает число
-* Функция возвращает абсолютное значение num
-
-Если параметров больше одного, то передавать их можно только в той последовательности, в которой они определены в сигнатуре. Любая функция возвращает всегда только одно значение. Это ограничение существует на уровне языка, и не может нарушаться.
-
-## Аргументы по умолчанию
-
-Рассмотрим функцию `round()`. Она округляет переданное число:
-
-```php
-<?php
-
-$result = round(10.25, 0); // 10
-```
-
-Мы передали в нее два аргумента: число и точность округления. `0` означает, что округление будет до целого значения.
-
-Чаще всего нужно округлять именно до целого числа, поэтому создатели функции `round` сделали второй аргумент необязательным и задали ему внутри функции значение по умолчанию `0`. Значит, можно не указывать второй аргумент, а результат будет тем же:
-
-```php
-<?php
-
-$result = round(10.25); // 10
-```
-
-А если нужна другая точность, то можно передать аргумент:
-
-```php
-<?php
-
-$result = round(10.25, 1); // 10.3
-```
-
-Если функция в PHP принимает необязательные аргументы, то они всегда стоят после обязательных. Их количество может быть любым. Это зависит от самой функции. Но такие аргументы всегда идут рядом и в конце списка аргументов.
diff --git a/modules/35-calling-functions/120-function-signature/ru/data.yml b/modules/35-calling-functions/120-function-signature/ru/data.yml
deleted file mode 100644
index 81ba041d..00000000
--- a/modules/35-calling-functions/120-function-signature/ru/data.yml
+++ /dev/null
@@ -1,8 +0,0 @@
----
-name: Сигнатура функции
-tips: []
-definitions:
-  - name: Сигнатура функции
-    description: >-
-      формальное описание типов аргументов и типа возвращаемого значения
-      функции.
diff --git a/modules/35-calling-functions/135-calling-functions-default-arguments/SolutionTest.php b/modules/35-calling-functions/135-calling-functions-default-arguments/SolutionTest.php
deleted file mode 100644
index 3cabcbe8..00000000
--- a/modules/35-calling-functions/135-calling-functions-default-arguments/SolutionTest.php
+++ /dev/null
@@ -1,17 +0,0 @@
-<?php
-
-namespace HexletBasics\CallingFunctions\DefaultArguments;
-
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        $expected = '10.12';
-        $this->expectOutputString($expected);
-        require 'index.php';
-    }
-}
diff --git a/modules/35-calling-functions/135-calling-functions-default-arguments/index.php b/modules/35-calling-functions/135-calling-functions-default-arguments/index.php
deleted file mode 100644
index 26ce445f..00000000
--- a/modules/35-calling-functions/135-calling-functions-default-arguments/index.php
+++ /dev/null
@@ -1,7 +0,0 @@
-<?php
-
-$number = 10.1234;
-
-// BEGIN
-print_r(round($number, 2));
-// END
diff --git a/modules/35-calling-functions/135-calling-functions-default-arguments/ru/EXERCISE.md b/modules/35-calling-functions/135-calling-functions-default-arguments/ru/EXERCISE.md
deleted file mode 100644
index 8cbc27fa..00000000
--- a/modules/35-calling-functions/135-calling-functions-default-arguments/ru/EXERCISE.md
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Округлите число, записанное в переменную `$number`, до двух знаков после запятой и выведите результат на экран.
diff --git a/modules/35-calling-functions/135-calling-functions-default-arguments/ru/README.md b/modules/35-calling-functions/135-calling-functions-default-arguments/ru/README.md
deleted file mode 100644
index 505ac99f..00000000
--- a/modules/35-calling-functions/135-calling-functions-default-arguments/ru/README.md
+++ /dev/null
@@ -1,28 +0,0 @@
-
-Рассмотрим функцию `round()`. Она округляет переданное число:
-
-```php
-<?php
-
-$result = round(10.25, 0); // 10
-```
-
-Мы передали в неё два аргумента: число и точность округления. `0` означает, что округление будет до целого значения.
-
-Чаще всего нужно округлять именно до целого числа (а не до десятых, например), поэтому создатели функции `round` сделали второй аргумент **необязательным** и задали ему внутри функции **значение по умолчанию `0`**. Значит, можно не указывать второй аргумент, а результат будет тем же:
-
-```php
-<?php
-
-$result = round(10.25); // 10
-```
-
-А если нужна другая точность, то можно передать аргумент:
-
-```php
-<?php
-
-$result = round(10.25, 1); // 10.3
-```
-
-Если функция в PHP принимает необязательные аргументы, то они всегда стоят после обязательных. Их количество может быть любым (это зависит от самой функции), но они всегда идут рядом и в конце списка аргументов.
diff --git a/modules/35-calling-functions/135-calling-functions-default-arguments/ru/data.yml b/modules/35-calling-functions/135-calling-functions-default-arguments/ru/data.yml
deleted file mode 100644
index 4037df85..00000000
--- a/modules/35-calling-functions/135-calling-functions-default-arguments/ru/data.yml
+++ /dev/null
@@ -1,6 +0,0 @@
----
-name: Аргументы по умолчанию
-tips: []
-definitions:
-  - name: Аргумент по умолчанию
-    description: необязательный аргумент функции.
diff --git a/modules/40-define-functions/100-define/Makefile b/modules/35-calling-functions/135-calling-functions-default-params/Makefile
similarity index 100%
rename from modules/40-define-functions/100-define/Makefile
rename to modules/35-calling-functions/135-calling-functions-default-params/Makefile
diff --git a/modules/35-calling-functions/135-calling-functions-default-params/Solution.php b/modules/35-calling-functions/135-calling-functions-default-params/Solution.php
new file mode 100644
index 00000000..68240885
--- /dev/null
+++ b/modules/35-calling-functions/135-calling-functions-default-params/Solution.php
@@ -0,0 +1,17 @@
+<?php
+
+$distance = 450; // расстояние, км
+$fuelConsumption = 8.4; // расход топлива, л/100 км
+$fuelPrice = 64.2; // цена топлива, руб./литр
+$passengers = 4; // количество пассажиров
+
+// BEGIN
+$fuel = $distance / 100 * $fuelConsumption;
+print_r(round($fuel, 1) . "\n");
+
+$tripCost = $fuel * $fuelPrice;
+print_r(round($tripCost, 2) . "\n");
+
+$perPerson = $tripCost / $passengers;
+print_r(round($perPerson) . "\n");
+// END
diff --git a/modules/35-calling-functions/135-calling-functions-default-params/SolutionTest.php b/modules/35-calling-functions/135-calling-functions-default-params/SolutionTest.php
new file mode 100644
index 00000000..3e48af8e
--- /dev/null
+++ b/modules/35-calling-functions/135-calling-functions-default-params/SolutionTest.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace HexletBasics\CallingFunctions\DefaultParams;
+
+use HexletBasics\Exercise\TestCase;
+
+class SolutionTest extends TestCase
+{
+    public function test()
+    {
+        $expected = "37.8\n2426.76\n607\n";
+        $this->expectOutputString($expected);
+    }
+}
diff --git a/modules/35-calling-functions/135-calling-functions-default-arguments/description.es.yml b/modules/35-calling-functions/135-calling-functions-default-params/description.es.yml
similarity index 100%
rename from modules/35-calling-functions/135-calling-functions-default-arguments/description.es.yml
rename to modules/35-calling-functions/135-calling-functions-default-params/description.es.yml
diff --git a/modules/35-calling-functions/135-calling-functions-default-arguments/en/EXERCISE.md b/modules/35-calling-functions/135-calling-functions-default-params/en/EXERCISE.md
similarity index 100%
rename from modules/35-calling-functions/135-calling-functions-default-arguments/en/EXERCISE.md
rename to modules/35-calling-functions/135-calling-functions-default-params/en/EXERCISE.md
diff --git a/modules/35-calling-functions/135-calling-functions-default-arguments/en/README.md b/modules/35-calling-functions/135-calling-functions-default-params/en/README.md
similarity index 100%
rename from modules/35-calling-functions/135-calling-functions-default-arguments/en/README.md
rename to modules/35-calling-functions/135-calling-functions-default-params/en/README.md
diff --git a/modules/35-calling-functions/135-calling-functions-default-arguments/en/data.yml b/modules/35-calling-functions/135-calling-functions-default-params/en/data.yml
similarity index 100%
rename from modules/35-calling-functions/135-calling-functions-default-arguments/en/data.yml
rename to modules/35-calling-functions/135-calling-functions-default-params/en/data.yml
diff --git a/modules/35-calling-functions/135-calling-functions-default-arguments/es/EXERCISE.md b/modules/35-calling-functions/135-calling-functions-default-params/es/EXERCISE.md
similarity index 100%
rename from modules/35-calling-functions/135-calling-functions-default-arguments/es/EXERCISE.md
rename to modules/35-calling-functions/135-calling-functions-default-params/es/EXERCISE.md
diff --git a/modules/35-calling-functions/135-calling-functions-default-arguments/es/README.md b/modules/35-calling-functions/135-calling-functions-default-params/es/README.md
similarity index 100%
rename from modules/35-calling-functions/135-calling-functions-default-arguments/es/README.md
rename to modules/35-calling-functions/135-calling-functions-default-params/es/README.md
diff --git a/modules/35-calling-functions/135-calling-functions-default-arguments/es/data.yml b/modules/35-calling-functions/135-calling-functions-default-params/es/data.yml
similarity index 100%
rename from modules/35-calling-functions/135-calling-functions-default-arguments/es/data.yml
rename to modules/35-calling-functions/135-calling-functions-default-params/es/data.yml
diff --git a/modules/35-calling-functions/135-calling-functions-default-params/ru/EXERCISE.md b/modules/35-calling-functions/135-calling-functions-default-params/ru/EXERCISE.md
new file mode 100644
index 00000000..dbe89819
--- /dev/null
+++ b/modules/35-calling-functions/135-calling-functions-default-params/ru/EXERCISE.md
@@ -0,0 +1,19 @@
+В коде заданы данные об автомобильной поездке: расстояние, расход топлива, цена топлива и количество пассажиров.
+
+Вычислите и выведите на экран три значения:
+
+1. Объем топлива в литрах, необходимый для поездки. Округлите до одного знака после запятой.
+2. Общую стоимость поездки в рублях. Округлите до двух знаков после запятой.
+3. Стоимость поездки для каждого пассажира в рублях. Округлите до целого числа, вызвав `round()` без второго аргумента.
+
+Каждое значение выводится на отдельной строке.
+
+```text
+distance ──────┐
+               ├──→ fuel ──────┐
+fuelConsumption ───┘           ├──→ tripCost ──────┐
+                               │                   ├──→ perPerson
+fuelPrice ─────────────────────┘                   │
+                                                   │
+passengers ────────────────────────────────────────┘
+```
diff --git a/modules/35-calling-functions/135-calling-functions-default-params/ru/README.md b/modules/35-calling-functions/135-calling-functions-default-params/ru/README.md
new file mode 100644
index 00000000..0963aec7
--- /dev/null
+++ b/modules/35-calling-functions/135-calling-functions-default-params/ru/README.md
@@ -0,0 +1,65 @@
+Некоторые функции в PHP имеют **необязательные параметры**. Это значит, что для них заранее задано значение по умолчанию, и при вызове можно этот параметр не указывать.
+
+![Автосервис](./assets/default-parameters.png)
+
+Рассмотрим встроенную функцию `round()`, которая округляет число:
+
+```php
+<?php
+
+$result = round(10.25, 0); // 10
+```
+
+Мы передали в нее два значения:
+
+- Число, которое нужно округлить.
+- Точность округления, `0` означает, что округление будет до целого числа.
+
+Так как чаще всего нужно именно округление до целого, создатели функции `round()` сделали второй параметр необязательным и задали ему значение по умолчанию `0`. Поэтому результат будет тем же, даже если второй параметр не указывать:
+
+```php
+<?php
+
+$result = round(10.25); // 10
+```
+
+Если нужна другая точность, то ее можно указать явно:
+
+```php
+<?php
+
+// округление до одного знака после запятой
+$result = round(10.25, 1); // 10.3
+```
+
+```text
+round(10.25, 1)  →  аргументы: 10.25, 1    →  10.3
+round(10.25)     →  аргументы: 10.25, (0)  →  10
+                                       └── значение по умолчанию
+```
+
+Количество необязательных параметров зависит от конкретной функции, но обязательные всегда идут перед необязательными.
+
+## Сигнатура функции
+
+У каждой функции есть **сигнатура**, содержащая описание ее имени, параметров и порядка их использования. Сигнатура помогает понять, какие данные функция ожидает и что будет происходить, если параметры не указаны.
+
+Посмотрим на [документацию](https://www.php.net/manual/ru/function.round.php) для функции `round()`. Если ее немного упростить, сигнатура выглядит так:
+
+```php
+round(int|float $num, int $precision = 0): float
+```
+
+Функция называется `round`. Параметр `$num` обязателен — он принимает число для округления (целое или дробное). Параметр `$precision` имеет значение по умолчанию `0`, то есть необязателен; если его не указать, округление произойдет до целого числа. После двоеточия указан тип результата — функция возвращает дробное число (`float`).
+
+В полной сигнатуре из документации есть еще один необязательный параметр, который управляет режимом округления. Он нужен редко, поэтому мы его пока не рассматриваем.
+
+## Как работать с новыми функциями
+
+Когда вы встречаете новую функцию, можно использовать простой паттерн:
+
+1. Открыть документацию и найти сигнатуру функции.
+2. Посмотреть примеры использования.
+3. Перейти в интерактивную оболочку PHP (она запускается командой `php -a`) и попробовать вызвать функцию с разными аргументами.
+
+Такой подход помогает быстро разобраться, как именно работает функция, какие у нее обязательные и необязательные параметры и какие результаты она возвращает.
diff --git a/modules/35-calling-functions/135-calling-functions-default-params/ru/assets/default-parameters.png b/modules/35-calling-functions/135-calling-functions-default-params/ru/assets/default-parameters.png
new file mode 100644
index 00000000..97e4297a
Binary files /dev/null and b/modules/35-calling-functions/135-calling-functions-default-params/ru/assets/default-parameters.png differ
diff --git a/modules/35-calling-functions/135-calling-functions-default-params/ru/data.yml b/modules/35-calling-functions/135-calling-functions-default-params/ru/data.yml
new file mode 100644
index 00000000..df3f197c
--- /dev/null
+++ b/modules/35-calling-functions/135-calling-functions-default-params/ru/data.yml
@@ -0,0 +1,9 @@
+---
+name: Параметры по умолчанию
+tips:
+  - >
+    [Значения параметров по
+    умолчанию](https://www.php.net/manual/ru/functions.arguments.php#functions.arguments.default)
+definitions:
+  - name: Параметр по умолчанию
+    description: необязательный параметр функции.
diff --git a/modules/35-calling-functions/150-calling-functions-expression/index.php b/modules/35-calling-functions/150-calling-functions-expression/Solution.php
similarity index 61%
rename from modules/35-calling-functions/150-calling-functions-expression/index.php
rename to modules/35-calling-functions/150-calling-functions-expression/Solution.php
index 811c0cdc..440a29fc 100644
--- a/modules/35-calling-functions/150-calling-functions-expression/index.php
+++ b/modules/35-calling-functions/150-calling-functions-expression/Solution.php
@@ -1,6 +1,6 @@
 <?php
 
-$text = 'Never forget what you are, for surely the world will not';
+$text = 'Hello, PHP!';
 
 // BEGIN
 $result = "First: {$text[0]}\nLast: {$text[strlen($text) - 1]}";
diff --git a/modules/35-calling-functions/150-calling-functions-expression/SolutionTest.php b/modules/35-calling-functions/150-calling-functions-expression/SolutionTest.php
index 959e513b..a95251eb 100644
--- a/modules/35-calling-functions/150-calling-functions-expression/SolutionTest.php
+++ b/modules/35-calling-functions/150-calling-functions-expression/SolutionTest.php
@@ -2,16 +2,13 @@
 
 namespace HexletBasics\CallingFunctions\Expression;
 
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        $expected = "First: N\nLast: t";
+        $expected = "First: H\nLast: !";
         $this->expectOutputString($expected);
-        require 'index.php';
     }
 }
diff --git a/modules/35-calling-functions/150-calling-functions-expression/ru/EXERCISE.md b/modules/35-calling-functions/150-calling-functions-expression/ru/EXERCISE.md
index 5e4d8c62..ce14fa95 100644
--- a/modules/35-calling-functions/150-calling-functions-expression/ru/EXERCISE.md
+++ b/modules/35-calling-functions/150-calling-functions-expression/ru/EXERCISE.md
@@ -1,8 +1,8 @@
-Выведите на экран первую и последнюю буквы предложения, записанного в переменную `text`, в следующем формате:
+Приложение показывает краткую сводку по тексту: его первый и последний символ. Выведите на экран первый и последний символы строки из переменной `$text` в следующем формате:
 
 ```text
-First: N
-Last: t
+First: H
+Last: !
 ```
 
 Постарайтесь создать только одну переменную, в которую сразу запишется нужный текст перед печатью на экран. В этом уроке мы отрабатываем умение собирать составное выражение.
diff --git a/modules/35-calling-functions/150-calling-functions-expression/ru/README.md b/modules/35-calling-functions/150-calling-functions-expression/ru/README.md
index d3b9fdb9..ac218e03 100644
--- a/modules/35-calling-functions/150-calling-functions-expression/ru/README.md
+++ b/modules/35-calling-functions/150-calling-functions-expression/ru/README.md
@@ -1,58 +1,106 @@
-В программировании выражение – нечто возвращающее результат, который можно использовать. Напомним, что математические операции по типу сложения и вычитания и строковые операции — это выражения:
+Когда мы пишем программы, нам нужно соединять действия друг с другом. Сложение чисел, объединение строк и работа с переменными являются примерами того, как простые шаги можно комбинировать, получая более сложное поведение.
 
 ```php
 <?php
 
-1 + 5 * 3
-'He' . 'Let'
-// Переменные могут быть частью выражения
-$rate * 5
+$rate = 10;
+$hours = 5;
+$salary = $rate * $hours + 100;
+print_r($salary); // => 150
 ```
 
-Особенность выражений в том, что они возвращают результат, который можно, например, присвоить переменной или вывести на экран. Например:
+В программировании для этого используется понятие **выражение**. Оно обозначает конструкцию, которая вычисляется и дает результат. В примере выше `$rate * $hours + 100` является выражением, составленным из переменных (`$rate`, `$hours`), числового литерала (`100`) и арифметических операций. Все вместе оно возвращает результат, который можно сохранить в переменную или использовать дальше.
+
+Что нам дает это знание? Мы понимаем, что выражения можно комбинировать бесконечно, постепенно усложняя логику. Каждое новое выражение становится частью большего:
 
 ```php
 <?php
 
-// Здесь выражение — это 1 + 5
-$sum = 1 + 5;
-print_r(1 + 5);
+$bonus = 50;
+// Выражение из множества операций
+$salary = ($rate * $hours + $bonus) * 12 - 500;
+print_r($salary);
 ```
 
-Выражения можно комбинировать и получать более сложное поведение в самых неожиданных местах и неожиданным образом. Об этом мы поговорим позже. В результате мы будем лучше понимать, как можно соединять части кода, чтобы получить нужный результат.
-
-## Является ли функция выражением
+Здесь несколько выражений объединены в одно, и результат стал еще сложнее. Именно так и строятся программы. Маленькие шаги складываются в большие конструкции. Поэтому в программировании невозможно заранее заучить все комбинации. Гораздо важнее понять, как выражения соединяются между собой в нужный результат.
 
-Мы знаем, что функции возвращают результат, то есть они являются выражениями. Поэтому мы можем использовать вызов функции прямо в математических операциях.
+## Выражения как аргументы функций
 
-Например, так можно получить индекс последнего символа в слове:
+Аргументом функции всегда является какое-то значение. Но значение можно не только записывать напрямую, но и вычислять. А значит, в аргументы функции можно подставлять любые выражения.
 
 ```php
 <?php
 
-$name = 'php';
-// Индексы начинаются с нуля
-// Вызов метода и вычитание вместе!
-$last_index = strlen($name) - 1;
-print_r($last_index); // 2
+// Здесь аргумент функции print_r — это число 150
+print_r(150);
+
+// А здесь аргумент — выражение, которое сначала вычисляется
+print_r(10 * 15); // => 150
+
+// Можно комбинировать еще сложнее
+$rate = 10;
+$hours = 15;
+$bonus = 50;
+print_r($rate * $hours + $bonus); // => 200
 ```
 
-В этом коде нет нового синтаксиса. Мы только соединили уже известные части, опираясь на их природу. Можно пойти еще дальше:
+Функция `print_r()` просто получает готовое значение и выводит его на экран. Способ получения этого значения функции безразличен. Именно поэтому вызовы функций отлично сочетаются с любыми выражениями.
+
+## Вызов функции внутри функции
+
+Так как вызов функции сам по себе является выражением, его результат можно сразу передавать другой функции. Это позволяет строить еще более сложные конструкции.
 
 ```php
 <?php
 
-$name = 'php';
-print_r(strlen($name) - 1); // => 2
+$name = 'python';
+
+// Вызов strlen($name) возвращает 6
+// Этот результат сразу используется как аргумент print_r()
+print_r(strlen($name)); // => 6
+```
+
+Здесь `strlen($name)` вычисляется первым и возвращает число 6. Затем это значение подставляется в вызов `print_r()`. Такая комбинация может быть сколько угодно глубокой. Результат одной функции можно передать в другую, потом в следующую.
+
+Чтобы правильно читать такие конструкции, нужно помнить про порядок вызова.
+
+1. Сначала выполняется функция, которая находится «внутри», в нашем случае `strlen($name)`.
+2. Затем ее результат подставляется на место вызова.
+3. После этого выполняется внешняя функция, в данном случае `print_r()`.
+
+Таким образом, код `print_r(strlen($name))` можно мысленно разложить так:
+
+```text
+print_r(strlen('python'))
+
+Шаг 1:  strlen('python')  →  6
+Шаг 2:  print_r(6)        →  выводит 6
 ```
 
-Все это справедливо для любых функций, например, строковых:
+1. `strlen($name)` → `6`
+2. `print_r(6)`
+3. На экране появляется `6`.
+
+Этот принцип работает всегда. Сначала вычисляются вложенные вызовы, потом внешний.
+
+## Использование функций в составе выражений
+
+Функции возвращают значения, а значит их вызовы можно использовать как аргументы других функций и как часть любых других выражений.
 
 ```php
 <?php
 
-$name = 'Toto';
-// Используется интерполяция
-print_r("Имя пользователя: {$name}");
-// => Имя пользователя: Toto
+$name = 'python';
+
+// Вызов strlen($name) возвращает 6
+// Мы вычитаем 1, чтобы получить индекс последнего символа
+$lastIndex = strlen($name) - 1;
+print_r($lastIndex); // => 5
+
+// Можно использовать результат функции в арифметике
+$text = 'hexlet';
+$double = strlen($text) * 2;
+print_r($double); // => 12
 ```
+
+Здесь вызовы `strlen($name)` и `strlen($text)` являются полноценными выражениями. Они возвращают значения, которые можно комбинировать с числами, переменными и другими операциями.
diff --git a/modules/35-calling-functions/150-calling-functions-expression/ru/data.yml b/modules/35-calling-functions/150-calling-functions-expression/ru/data.yml
index d587eabd..46ef8cf7 100644
--- a/modules/35-calling-functions/150-calling-functions-expression/ru/data.yml
+++ b/modules/35-calling-functions/150-calling-functions-expression/ru/data.yml
@@ -1,2 +1,7 @@
 ---
 name: Вызов функции — выражение
+definitions:
+  - name: Выражение
+    description: >
+      последовательность действий над данными, приводящая к какому-то результату,
+      который можно использовать.
diff --git a/modules/35-calling-functions/180-variadic-arguments/SolutionTest.php b/modules/35-calling-functions/180-variadic-arguments/SolutionTest.php
deleted file mode 100644
index 14eb6bde..00000000
--- a/modules/35-calling-functions/180-variadic-arguments/SolutionTest.php
+++ /dev/null
@@ -1,17 +0,0 @@
-<?php
-
-namespace HexletBasics\CallingFunctions\Call;
-
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        $expected = -3;
-        $this->expectOutputString($expected);
-        require 'index.php';
-    }
-}
diff --git a/modules/35-calling-functions/180-variadic-arguments/ru/EXERCISE.md b/modules/35-calling-functions/180-variadic-arguments/ru/EXERCISE.md
deleted file mode 100644
index 92bfe495..00000000
--- a/modules/35-calling-functions/180-variadic-arguments/ru/EXERCISE.md
+++ /dev/null
@@ -1 +0,0 @@
-Посчитайте программно (а не в голове) минимальное число среди 3, 10, 22, -3, 0 — и выведите его на экран. Воспользуйтесь функцией `min()`, которая работает аналогично `max()`.
diff --git a/modules/35-calling-functions/180-variadic-arguments/ru/README.md b/modules/35-calling-functions/180-variadic-arguments/ru/README.md
deleted file mode 100644
index 948a5016..00000000
--- a/modules/35-calling-functions/180-variadic-arguments/ru/README.md
+++ /dev/null
@@ -1,16 +0,0 @@
-В этом уроке разберем одну особенность некоторых функций. Они могут принимать переменное число параметров. Но речь идет не о значениях по умолчанию. Посмотрим на этот пример:
-
-```php
-<?php
-
-max(1, 10, 3); // 10
-max(1, -3, 2, 3, 2); // 3
-```
-
-Функция `max()` находит максимальное значение среди переданных параметров. Интересно, сколько параметров она ожидает на вход? Если открыть документацию этой функции, то мы увидим такую конструкцию:
-
-```txt
-max(mixed $value, mixed ...$values): mixed
-```
-
-Такая запись говорит о том, что эта функция принимает на вход два обязательных параметра и любое число необязательных. Необязательность передаваемых параметров описывается многоточием `...`.
diff --git a/modules/35-calling-functions/180-variadic-arguments/ru/data.yml b/modules/35-calling-functions/180-variadic-arguments/ru/data.yml
deleted file mode 100644
index 753d1258..00000000
--- a/modules/35-calling-functions/180-variadic-arguments/ru/data.yml
+++ /dev/null
@@ -1,3 +0,0 @@
----
-name: Функции с переменным числом параметров
-tips: []
diff --git a/modules/40-define-functions/200-return/Makefile b/modules/35-calling-functions/180-variadic-parameters/Makefile
similarity index 100%
rename from modules/40-define-functions/200-return/Makefile
rename to modules/35-calling-functions/180-variadic-parameters/Makefile
diff --git a/modules/35-calling-functions/180-variadic-arguments/index.php b/modules/35-calling-functions/180-variadic-parameters/Solution.php
similarity index 100%
rename from modules/35-calling-functions/180-variadic-arguments/index.php
rename to modules/35-calling-functions/180-variadic-parameters/Solution.php
diff --git a/modules/35-calling-functions/180-variadic-parameters/SolutionTest.php b/modules/35-calling-functions/180-variadic-parameters/SolutionTest.php
new file mode 100644
index 00000000..5cb4d1c2
--- /dev/null
+++ b/modules/35-calling-functions/180-variadic-parameters/SolutionTest.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace HexletBasics\CallingFunctions\VariadicParameters;
+
+use HexletBasics\Exercise\TestCase;
+
+class SolutionTest extends TestCase
+{
+    public function test()
+    {
+        $expected = '-3';
+        $this->expectOutputString($expected);
+    }
+}
diff --git a/modules/35-calling-functions/180-variadic-arguments/description.es.yml b/modules/35-calling-functions/180-variadic-parameters/description.es.yml
similarity index 100%
rename from modules/35-calling-functions/180-variadic-arguments/description.es.yml
rename to modules/35-calling-functions/180-variadic-parameters/description.es.yml
diff --git a/modules/35-calling-functions/180-variadic-arguments/en/EXERCISE.md b/modules/35-calling-functions/180-variadic-parameters/en/EXERCISE.md
similarity index 100%
rename from modules/35-calling-functions/180-variadic-arguments/en/EXERCISE.md
rename to modules/35-calling-functions/180-variadic-parameters/en/EXERCISE.md
diff --git a/modules/35-calling-functions/180-variadic-arguments/en/README.md b/modules/35-calling-functions/180-variadic-parameters/en/README.md
similarity index 100%
rename from modules/35-calling-functions/180-variadic-arguments/en/README.md
rename to modules/35-calling-functions/180-variadic-parameters/en/README.md
diff --git a/modules/35-calling-functions/180-variadic-arguments/en/data.yml b/modules/35-calling-functions/180-variadic-parameters/en/data.yml
similarity index 100%
rename from modules/35-calling-functions/180-variadic-arguments/en/data.yml
rename to modules/35-calling-functions/180-variadic-parameters/en/data.yml
diff --git a/modules/35-calling-functions/180-variadic-arguments/es/EXERCISE.md b/modules/35-calling-functions/180-variadic-parameters/es/EXERCISE.md
similarity index 100%
rename from modules/35-calling-functions/180-variadic-arguments/es/EXERCISE.md
rename to modules/35-calling-functions/180-variadic-parameters/es/EXERCISE.md
diff --git a/modules/35-calling-functions/180-variadic-arguments/es/README.md b/modules/35-calling-functions/180-variadic-parameters/es/README.md
similarity index 100%
rename from modules/35-calling-functions/180-variadic-arguments/es/README.md
rename to modules/35-calling-functions/180-variadic-parameters/es/README.md
diff --git a/modules/35-calling-functions/180-variadic-arguments/es/data.yml b/modules/35-calling-functions/180-variadic-parameters/es/data.yml
similarity index 100%
rename from modules/35-calling-functions/180-variadic-arguments/es/data.yml
rename to modules/35-calling-functions/180-variadic-parameters/es/data.yml
diff --git a/modules/35-calling-functions/180-variadic-parameters/ru/EXERCISE.md b/modules/35-calling-functions/180-variadic-parameters/ru/EXERCISE.md
new file mode 100644
index 00000000..f8343173
--- /dev/null
+++ b/modules/35-calling-functions/180-variadic-parameters/ru/EXERCISE.md
@@ -0,0 +1 @@
+За неделю были зафиксированы такие температуры воздуха: 3, 10, 22, -3, 0 градусов. Найдите минимальное значение с помощью функции `min()` и выведите его на экран.
diff --git a/modules/35-calling-functions/180-variadic-parameters/ru/README.md b/modules/35-calling-functions/180-variadic-parameters/ru/README.md
new file mode 100644
index 00000000..58dce7cc
--- /dev/null
+++ b/modules/35-calling-functions/180-variadic-parameters/ru/README.md
@@ -0,0 +1,41 @@
+Некоторые функции обладают особенностью: они принимают переменное число аргументов. Это не связано со значениями по умолчанию, как в случае с `round()`. Речь идет о том, что количество передаваемых данных не ограничено фиксированным числом.
+
+Рассмотрим функцию `max()`. Она находит наибольшее значение из переданных данных.
+
+```php
+<?php
+
+print_r(max(1, 10, 3)); // => 10
+print_r(max(1, -3, 2, 3, 2)); // => 3
+```
+
+Откроем [документацию](https://www.php.net/manual/ru/function.max.php) и посмотрим на сигнатуру `max()`:
+
+```php
+max(mixed $value, mixed ...$values): mixed
+```
+
+Это значит:
+
+- функция требует как минимум одно значение (`$value`);
+- дальше можно передавать еще сколько угодно значений (`...$values`) — переменное число аргументов обозначается многоточием `...`;
+- функция вернет наибольшее из переданных.
+
+Тип `mixed` в сигнатуре означает «любой тип»: функция умеет сравнивать не только числа, но и другие значения.
+
+Если среди аргументов есть несколько одинаковых максимальных значений, возвращается первый из них.
+
+```php
+<?php
+
+print_r(max(5, 5, 2)); // => 5
+```
+
+Аналогично работает функция `min()`, только она ищет наименьшее значение:
+
+```php
+<?php
+
+print_r(min(1, 10, 3)); // => 1
+print_r(min(1, -3, 2, 3, 2)); // => -3
+```
diff --git a/modules/35-calling-functions/180-variadic-parameters/ru/data.yml b/modules/35-calling-functions/180-variadic-parameters/ru/data.yml
new file mode 100644
index 00000000..70466495
--- /dev/null
+++ b/modules/35-calling-functions/180-variadic-parameters/ru/data.yml
@@ -0,0 +1,9 @@
+---
+name: Функции с переменным числом параметров
+tips:
+  - >
+    [Пример функции с переменным числом
+    параметров](https://www.php.net/manual/ru/function.max.php)
+definitions:
+  - name: Аргумент по умолчанию
+    description: необязательный аргумент функции.
diff --git a/modules/35-calling-functions/270-deterministic/index.php b/modules/35-calling-functions/270-deterministic/Solution.php
similarity index 51%
rename from modules/35-calling-functions/270-deterministic/index.php
rename to modules/35-calling-functions/270-deterministic/Solution.php
index 7176b646..ff3027d2 100644
--- a/modules/35-calling-functions/270-deterministic/index.php
+++ b/modules/35-calling-functions/270-deterministic/Solution.php
@@ -1,5 +1,5 @@
 <?php
 
 // BEGIN
-print_r(rand(1, 6));
+print_r(rand(0, 10));
 // END
diff --git a/modules/35-calling-functions/270-deterministic/SolutionTest.php b/modules/35-calling-functions/270-deterministic/SolutionTest.php
index 6daa6fe6..8e3b179d 100644
--- a/modules/35-calling-functions/270-deterministic/SolutionTest.php
+++ b/modules/35-calling-functions/270-deterministic/SolutionTest.php
@@ -1,22 +1,19 @@
 <?php
 
-namespace HexletBasics\CallingFunctions\Call;
+namespace HexletBasics\CallingFunctions\Deterministic;
 
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        require 'index.php';
-        $randomSide = $this->getActualOutputForAssertion();
+        $randomRoll = $this->getActualOutputForAssertion();
         $this->assertThat(
-            $randomSide,
+            $randomRoll,
             $this->logicalAnd(
-                $this->greaterThanOrEqual(1),
-                $this->lessThanOrEqual(6)
+                $this->greaterThanOrEqual(0),
+                $this->lessThanOrEqual(10)
             )
         );
     }
diff --git a/modules/35-calling-functions/270-deterministic/ru/EXERCISE.md b/modules/35-calling-functions/270-deterministic/ru/EXERCISE.md
index e73eaa8a..9dd04992 100644
--- a/modules/35-calling-functions/270-deterministic/ru/EXERCISE.md
+++ b/modules/35-calling-functions/270-deterministic/ru/EXERCISE.md
@@ -1 +1,3 @@
-Выведите на экран случайное число от 1 до 6. Для реализации вам потребуется функция `rand()`, которая может принимать два числа: начальное и конечное
+В настольной игре бросают кубик и получают число от 0 до 10. Напишите программу, которая моделирует этот бросок: выводит на экран случайное целое число в диапазоне от 0 до 10. Для этой задачи вам понадобится функция `rand()`, которая может принимать два числа: начальное и конечное значение диапазона.
+
+Попробуйте решить это задание в одну строчку.
diff --git a/modules/35-calling-functions/270-deterministic/ru/README.md b/modules/35-calling-functions/270-deterministic/ru/README.md
index a76431ae..957bb5ac 100644
--- a/modules/35-calling-functions/270-deterministic/ru/README.md
+++ b/modules/35-calling-functions/270-deterministic/ru/README.md
@@ -1,21 +1,24 @@
-Независимо от того, какой язык программирования используется, функции внутри него обладают некоторыми фундаментальными свойствами. Если знать эти свойства, легче прогнозировать поведение функций, способы их тестирования и место их использования. В этом уроке мы изучим такие свойства функций и особенности их работы.
+У функций в любом языке программирования есть фундаментальные свойства. Эти свойства помогают понимать, как функция будет вести себя в разных ситуациях, как ее тестировать и где применять. Одним из таких свойств является **детерминированность**.
 
-## Что такое детерминированность
+![Двое сидят и разговаривают о детерминированной функции](./assets/deterministic.png)
 
-**Детерминированность** — это одно из фундаментальных свойств функций. Функция будет детерминированной, когда для одних и тех же входных аргументов она возвращает один и тот же результат. Например, функция, которая переворачивает строку, — детерминированная:
+**Детерминированная функция** всегда возвращает один и тот же результат при одинаковых входных данных. Например, детерминированной можно назвать функцию, которая считает количество символов:
 
 ```php
 <?php
 
-strrev('cat'); // tac
-strrev('cat'); // tac
+strlen('hexlet'); // 6
+strlen('hexlet'); // 6
+
+strlen('wow'); // 3
+strlen('wow'); // 3
 ```
 
-Сколько бы раз мы ее не вызывали и не передавали туда значение `'cat'`, она всегда вернет `'tac'`.
+Функцию `strlen()` можно вызывать бесконечно с одним и тем же аргументом, и она всегда вернет один и тот же результат.
 
-При этом функция, которая возвращает случайное число, не является детерминированной. В этом случае у одного и того же входа мы всегда получим разный результат.
+## Недетерминированные функции
 
-Даже если хотя бы один из миллиона вызовов вернет что-то другое, эта функция автоматически считается недетерминированной:
+К противоположному типу относятся **недетерминированные функции**. Они могут возвращать разные результаты при одинаковых входных данных или при их отсутствии (функции без параметров). Хорошим примером служит функция `rand()`, которая возвращает случайное число:
 
 ```php
 <?php
@@ -24,30 +27,21 @@ rand(); // 827606195
 rand(); // 635369726
 ```
 
-Детерминированность серьезно влияет на многие аспекты. Детерминированные функции удобны в работе, их легко оптимизировать и тестировать. Если есть возможность сделать функцию детерминированной, это стоит сделать.
-
-## Что такое побочные эффекты
-
-`print_r()` — это тоже функция. Она принимает на вход данные любого типа и выводит их на экран. При этом что бы она не возвращала, это значение не используется.
-
-`print_r()` выводит что-то на экран, но это не возврат значения. Это действие, которое выполняет функция. Вывод на экран и возврат значения из функции — разные и независимые операции.
-
-Технически вывод на экран равносилен записи в файл. Чтобы понять это, необходимо разобраться в устройстве операционных систем, что крайне важно для программистов.
+У этой функции нет аргументов, но ее результат каждый раз разный. Если хотя бы один вызов среди миллионов даст другой результат, функция считается недетерминированной.
 
-С точки зрения программы вывод на экран — это **побочный эффект**. Побочным эффектом называют операции, при которых происходит взаимодействие с внешним окружением (средой выполнения). К таким операциям относятся любые сетевые взаимодействия, вывод информации на экран, печать на принтере, взаимодействие с файловой системой — чтение и запись файлов.
-
-Побочные эффекты — один из основных источников проблем и ошибок в программных системах. Код с побочными эффектами сложен в тестировании и ненадежен. При этом без побочных эффектов программирование не имеет смысла. Без них было бы невозможно получить результат работы программы, например, записать в базу, вывести на экран, отправить по сети и так далее.
-
-Важно понимать принципы работы с побочными эффектами. Это влияет на стиль программирования и способность строить качественные программы. Эта тема полностью раскроется в курсе о функциях.
-
-## Что такое чистые функции
+```text
+Детерминированная:          Недетерминированная:
+strlen('abc') → всегда 3    rand() → 827606195
+strlen('abc') → всегда 3    rand() → 635369726
+strlen('abc') → всегда 3    rand() → 142503087
+```
 
-Когда функция детерминированная и не имеет побочных эффектов, ее называют **чистой** функцией. Такие функции:
+## Почему это важно
 
-* Проще читать, отлаживать и тестировать
-* Не зависят от порядка, в котором они вызываются
-* Просто запустить параллельно
+Детерминированность влияет на то, как мы работаем с функциями.
 
-Чистые функции независимы от времени. Недетерминизм и побочные эффекты добавляют понятие времени. Если функция зависит от чего-то, что может случиться или нет, и меняет что-то за пределами своих границ, то она неожиданно становится зависимой от времени.
+- детерминированные функции легко тестировать и предсказывать;
+- их проще оптимизировать и использовать повторно;
+- недетерминированные функции сложнее проверять, потому что результат меняется.
 
-Вопрос для самопроверки. Можно ли определить наличие побочных эффектов внутри функции, опираясь только на ее возврат?
+Поэтому там, где это возможно, лучше стремиться к тому, чтобы функция была детерминированной.
diff --git a/modules/35-calling-functions/270-deterministic/ru/assets/deterministic.png b/modules/35-calling-functions/270-deterministic/ru/assets/deterministic.png
new file mode 100644
index 00000000..1a6cf820
Binary files /dev/null and b/modules/35-calling-functions/270-deterministic/ru/assets/deterministic.png differ
diff --git a/modules/35-calling-functions/270-deterministic/ru/data.yml b/modules/35-calling-functions/270-deterministic/ru/data.yml
index 3f4b91c4..1e05afaf 100644
--- a/modules/35-calling-functions/270-deterministic/ru/data.yml
+++ b/modules/35-calling-functions/270-deterministic/ru/data.yml
@@ -4,3 +4,8 @@ tips:
   - >
     [Детерминированные
     функции](https://ru.wikipedia.org/wiki/Чистота_функции#Детерминированность_функции)
+definitions:
+  - name: Побочный эффект
+    description: >-
+      действие, которое изменяет внешнее окружение (среду выполнения). Например,
+      вывод на экран или отправка письма.
diff --git a/modules/35-calling-functions/900-stdlib/SolutionTest.php b/modules/35-calling-functions/900-stdlib/SolutionTest.php
deleted file mode 100644
index fe540095..00000000
--- a/modules/35-calling-functions/900-stdlib/SolutionTest.php
+++ /dev/null
@@ -1,17 +0,0 @@
-<?php
-
-namespace HexletBasics\CallingFunctions\Stdlib;
-
-use PHPUnit\Framework\TestCase;
-
-\HexletBasics\Functions\runScript();
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        $expected = 'string';
-        $this->expectOutputString($expected);
-        require 'index.php';
-    }
-}
diff --git a/modules/35-calling-functions/900-stdlib/description.es.yml b/modules/35-calling-functions/900-stdlib/description.es.yml
deleted file mode 100644
index e52fda2c..00000000
--- a/modules/35-calling-functions/900-stdlib/description.es.yml
+++ /dev/null
@@ -1,33 +0,0 @@
----
-
-name: Biblioteca estándar
-theory: |
-  PHP viene con un conjunto de funciones útiles. Juntas, forman la **biblioteca estándar**. Por lo general, incluye miles de funciones que no se pueden aprender todas, ni es necesario hacerlo. En esta lección, daremos recomendaciones sobre cómo trabajar con nuevas funciones.
-
-  Se supone que cualquier programador sabe dónde buscar la documentación y tiene una idea aproximada de lo que quiere lograr. Por lo tanto, programar sin internet es extremadamente difícil.
-
-  A menudo, los principiantes no saben a dónde ir ni qué buscar. Estos conocimientos y habilidades se adquieren con la experiencia. Durante el aprendizaje y el trabajo, se familiarizan con funciones más interesantes que resuelven sus problemas de una manera más conveniente. Así es como enriquecen su arsenal.
-
-  Aquí hay algunos consejos sobre cómo aprender sobre nuevas funciones:
-
-  * Siempre es necesario tener en cuenta el tipo de datos con el que se está trabajando. Las funciones necesarias se pueden encontrar en la sección correspondiente de la documentación. Por ejemplo, para trabajar con cadenas, es necesario estudiar las funciones de cadenas.
-  * De vez en cuando, es necesario abrir la sección de funciones estándar relacionadas con el tema que se está estudiando. Es necesario estudiarlas, sus firmas y formas de uso.
-  * Es necesario leer el código de otras personas con frecuencia, especialmente el código de bibliotecas que utilizamos. Siempre está disponible en GitHub.
-
-  Otra característica de las funciones de PHP de la biblioteca estándar es que están disponibles globalmente. Se pueden llamar en cualquier parte del programa. Sin embargo, esto no se aplica a las funciones escritas por uno mismo.
-
-  La mayoría de las funciones de la biblioteca estándar se centran en funcionalidades o tipos de datos específicos. Por ejemplo, hay un gran conjunto de funciones para el manejo de cadenas, números, etc. Algunas de ellas las veremos durante el proceso de aprendizaje.
-
-instructions: |
-
-  La función `gettype()` permite determinar el tipo de argumento pasado. El nombre del tipo se devuelve como una cadena. Por ejemplo, llamar a `gettype(10)` devolverá la cadena `"integer"` (integer - número entero).
-
-  Muestra en pantalla el tipo de valor de la variable `$motto`.
-
-tips:
-  - |
-    [Descripción de las funciones de cadenas](https://www.php.net/manual/es/ref.strings.php)
-
-definitions:
-  - name: Biblioteca estándar
-    description: conjunto de funciones útiles que se incluyen en el lenguaje de programación.
diff --git a/modules/35-calling-functions/900-stdlib/en/EXERCISE.md b/modules/35-calling-functions/900-stdlib/en/EXERCISE.md
deleted file mode 100644
index 92e043bd..00000000
--- a/modules/35-calling-functions/900-stdlib/en/EXERCISE.md
+++ /dev/null
@@ -1,4 +0,0 @@
-
-The `gettype()` function allows you to determine the type of the argument being passed. The name of the type is returned as a string. For example, a call to `gettype(10)` will return the string `"integer"`.
-
-Print the type of the value of the variable `$motto`.
diff --git a/modules/35-calling-functions/900-stdlib/en/README.md b/modules/35-calling-functions/900-stdlib/en/README.md
deleted file mode 100644
index 09159d8e..00000000
--- a/modules/35-calling-functions/900-stdlib/en/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
-
-PHP, like any other language, comes with a set of useful features. Altogether, they make up the so-called **standard library**. It usually contains thousands of functions you can't remember, and that you don't have to. It's assumed that any programmer knows where to look for their documentation and has a rough idea of what they want to achieve. And the rest is a matter of technique. Programming without the Internet is extremely difficult.
-
-To newcomers, it often looks like this: "Go I know not whither and fetch I know not what". In other words, most people have no idea how to learn about these functions when they don't know anything at all. Oddly enough, there's no way to know everything you need to know once and for all. As you grow as a developer, you'll learn all the exciting features that can solve your problems more elegantly, thus expanding your toolbox.
-
-Here are some tips to learn about new features:
-
-* Always keep track of what you're working with at the moment (the data type). You'll almost always find the function you need in the corresponding section of the documentation, e.g. you have to study string functions to work with strings.
-* Open the standard functions section of the topic you are studying every now and then and just run through them,, learning the signatures and ways to use them.
-* Read other people's code more often, especially code from the libraries you're using. It's all available on GitHub.
-
-Another feature of PHP functions from the Standard Library is that they're *available globally*. In other words, you can call them anywhere in your program (this doesn't work with functions you've written yourself). Most standard library functions are centered around some functionality or some type of data. For example, there's a large block of functions for processing strings, working with numbers, and so on. We'll go over some of them as you continue to study.
diff --git a/modules/35-calling-functions/900-stdlib/en/data.yml b/modules/35-calling-functions/900-stdlib/en/data.yml
deleted file mode 100644
index c10fba7c..00000000
--- a/modules/35-calling-functions/900-stdlib/en/data.yml
+++ /dev/null
@@ -1,9 +0,0 @@
----
-name: Standard Library
-tips:
-  - >
-    [Description of string
-    functions](https://www.php.net/manual/en/ref.strings.php)
-definitions:
-  - name: Standard Library
-    description: a set of useful features included with the programming language.
diff --git a/modules/35-calling-functions/900-stdlib/es/EXERCISE.md b/modules/35-calling-functions/900-stdlib/es/EXERCISE.md
deleted file mode 100644
index b5e6ec4a..00000000
--- a/modules/35-calling-functions/900-stdlib/es/EXERCISE.md
+++ /dev/null
@@ -1,4 +0,0 @@
-
-La función `gettype()` permite determinar el tipo de argumento pasado. El nombre del tipo se devuelve como una cadena. Por ejemplo, llamar a `gettype(10)` devolverá la cadena `"integer"` (integer - número entero).
-
-Muestra en pantalla el tipo de valor de la variable `$motto`.
diff --git a/modules/35-calling-functions/900-stdlib/es/README.md b/modules/35-calling-functions/900-stdlib/es/README.md
deleted file mode 100644
index dd84490c..00000000
--- a/modules/35-calling-functions/900-stdlib/es/README.md
+++ /dev/null
@@ -1,15 +0,0 @@
-PHP viene con un conjunto de funciones útiles. Juntas, forman la **biblioteca estándar**. Por lo general, incluye miles de funciones que no se pueden aprender todas, ni es necesario hacerlo. En esta lección, daremos recomendaciones sobre cómo trabajar con nuevas funciones.
-
-Se supone que cualquier programador sabe dónde buscar la documentación y tiene una idea aproximada de lo que quiere lograr. Por lo tanto, programar sin internet es extremadamente difícil.
-
-A menudo, los principiantes no saben a dónde ir ni qué buscar. Estos conocimientos y habilidades se adquieren con la experiencia. Durante el aprendizaje y el trabajo, se familiarizan con funciones más interesantes que resuelven sus problemas de una manera más conveniente. Así es como enriquecen su arsenal.
-
-Aquí hay algunos consejos sobre cómo aprender sobre nuevas funciones:
-
-* Siempre es necesario tener en cuenta el tipo de datos con el que se está trabajando. Las funciones necesarias se pueden encontrar en la sección correspondiente de la documentación. Por ejemplo, para trabajar con cadenas, es necesario estudiar las funciones de cadenas.
-* De vez en cuando, es necesario abrir la sección de funciones estándar relacionadas con el tema que se está estudiando. Es necesario estudiarlas, sus firmas y formas de uso.
-* Es necesario leer el código de otras personas con frecuencia, especialmente el código de bibliotecas que utilizamos. Siempre está disponible en GitHub.
-
-Otra característica de las funciones de PHP de la biblioteca estándar es que están disponibles globalmente. Se pueden llamar en cualquier parte del programa. Sin embargo, esto no se aplica a las funciones escritas por uno mismo.
-
-La mayoría de las funciones de la biblioteca estándar se centran en funcionalidades o tipos de datos específicos. Por ejemplo, hay un gran conjunto de funciones para el manejo de cadenas, números, etc. Algunas de ellas las veremos durante el proceso de aprendizaje.
diff --git a/modules/35-calling-functions/900-stdlib/es/data.yml b/modules/35-calling-functions/900-stdlib/es/data.yml
deleted file mode 100644
index 339745b2..00000000
--- a/modules/35-calling-functions/900-stdlib/es/data.yml
+++ /dev/null
@@ -1,11 +0,0 @@
----
-name: Biblioteca estándar
-tips:
-  - >
-    [Descripción de las funciones de
-    cadenas](https://www.php.net/manual/es/ref.strings.php)
-definitions:
-  - name: Biblioteca estándar
-    description: >-
-      conjunto de funciones útiles que se incluyen en el lenguaje de
-      programación.
diff --git a/modules/35-calling-functions/900-stdlib/index.php b/modules/35-calling-functions/900-stdlib/index.php
deleted file mode 100644
index fdaf42e5..00000000
--- a/modules/35-calling-functions/900-stdlib/index.php
+++ /dev/null
@@ -1,7 +0,0 @@
-<?php
-
-$motto = 'Family, Duty, Honor';
-
-// BEGIN
-print_r(gettype($motto));
-// END
diff --git a/modules/35-calling-functions/900-stdlib/ru/EXERCISE.md b/modules/35-calling-functions/900-stdlib/ru/EXERCISE.md
deleted file mode 100644
index 78912d36..00000000
--- a/modules/35-calling-functions/900-stdlib/ru/EXERCISE.md
+++ /dev/null
@@ -1,4 +0,0 @@
-
-Функция `gettype()` позволяет определить тип передаваемого аргумента. Название типа возвращается в виде строки. Например, вызов `gettype(10)` вернёт строку `"integer"` (integer — целое число).
-
-Выведите на экран тип значения переменной `$motto`.
diff --git a/modules/35-calling-functions/900-stdlib/ru/README.md b/modules/35-calling-functions/900-stdlib/ru/README.md
deleted file mode 100644
index 54a2a642..00000000
--- a/modules/35-calling-functions/900-stdlib/ru/README.md
+++ /dev/null
@@ -1,15 +0,0 @@
-PHP поставляется с набором полезных функций. Вместе они составляют **стандартную библиотеку**. Обычно в нее входят тысячи функций, которые невозможно выучить, что и не нужно делать. В этом уроке мы дадим рекомендации по работе с новыми функциями.
-
-Подразумевается, что любой программист знает, где искать документацию по ним и примерно представляет себе, чего он хочет достичь. Поэтому программировать без интернета крайне сложно.
-
-Часто новички не знают, куда нужно идти и что искать. Эти знания и навыки приходят с опытом. Во время обучения и работы они знакомятся с более интересными функциями, которые решают их задачи более удобным способом. Так они и пополняют свой арсенал.
-
-Вот некоторые советы, как узнавать о новых функциях:
-
-* Всегда нужно отслеживать, с каким типом данных идет работа. Необходимые функции можно найти в соответствующем разделе документации. Например, для работы со строками нужно изучать строковые функции
-* Периодически нужно открывать раздел со стандартными функциями по изучаемой тематике. Нужно изучать их, сигнатуры и способы использования
-* Необходимо часто читать чужой код, особенно, код библиотек, которые используются нами. Он всегда доступен на GitHub
-
-Еще одна особенность функций PHP из стандартной библиотеки в том, что они доступны глобально. Их можно вызывать в любом месте программы. Правда это не работает с функциями, написанными самостоятельно.
-
-Большинство функций стандартной библиотеки сосредоточено вокруг определенных функциональности или типа данных. Например, есть большой блок функций по обработке строк, с числами и так далее. По некоторым из них мы пройдемся в процессе обучения.
diff --git a/modules/35-calling-functions/900-stdlib/ru/data.yml b/modules/35-calling-functions/900-stdlib/ru/data.yml
deleted file mode 100644
index 4a714081..00000000
--- a/modules/35-calling-functions/900-stdlib/ru/data.yml
+++ /dev/null
@@ -1,10 +0,0 @@
----
-name: Стандартная библиотека
-tips:
-  - |
-    [Описание строковых функций](https://www.php.net/manual/ru/ref.strings.php)
-definitions:
-  - name: Стандартная библиотека
-    description: >-
-      набор полезных функций, входящий в комплект поставки языка
-      программирования.
diff --git a/modules/40-define-functions/300-parameters/Makefile b/modules/40-define-functions/100-define-function/Makefile
similarity index 100%
rename from modules/40-define-functions/300-parameters/Makefile
rename to modules/40-define-functions/100-define-function/Makefile
diff --git a/modules/40-define-functions/100-define/index.php b/modules/40-define-functions/100-define-function/Solution.php
similarity index 60%
rename from modules/40-define-functions/100-define/index.php
rename to modules/40-define-functions/100-define-function/Solution.php
index 7970eae4..7d4380b6 100644
--- a/modules/40-define-functions/100-define/index.php
+++ b/modules/40-define-functions/100-define-function/Solution.php
@@ -4,11 +4,11 @@
 // They are needed here for technical reasons
 // Just ignore them, they do not affect development
 
-namespace HexletBasics\DefineFunctions\Define;
+namespace HexletBasics\DefineFunctions\DefineFunction;
 
 // BEGIN
-function printMotto()
+function sayHello()
 {
-    print_r("Winter is coming");
+    print_r('Hello, World!');
 }
 // END
diff --git a/modules/40-define-functions/100-define-function/SolutionTest.php b/modules/40-define-functions/100-define-function/SolutionTest.php
new file mode 100644
index 00000000..887bfae6
--- /dev/null
+++ b/modules/40-define-functions/100-define-function/SolutionTest.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace HexletBasics\DefineFunctions\DefineFunction;
+
+use HexletBasics\Exercise\TestCase;
+
+class SolutionTest extends TestCase
+{
+    public function test()
+    {
+        $expected = 'Hello, World!';
+        $this->expectOutputString($expected);
+        sayHello();
+    }
+}
diff --git a/modules/40-define-functions/100-define/description.es.yml b/modules/40-define-functions/100-define-function/description.es.yml
similarity index 100%
rename from modules/40-define-functions/100-define/description.es.yml
rename to modules/40-define-functions/100-define-function/description.es.yml
diff --git a/modules/40-define-functions/100-define/en/EXERCISE.md b/modules/40-define-functions/100-define-function/en/EXERCISE.md
similarity index 100%
rename from modules/40-define-functions/100-define/en/EXERCISE.md
rename to modules/40-define-functions/100-define-function/en/EXERCISE.md
diff --git a/modules/40-define-functions/100-define/en/README.md b/modules/40-define-functions/100-define-function/en/README.md
similarity index 100%
rename from modules/40-define-functions/100-define/en/README.md
rename to modules/40-define-functions/100-define-function/en/README.md
diff --git a/modules/40-define-functions/100-define/en/data.yml b/modules/40-define-functions/100-define-function/en/data.yml
similarity index 100%
rename from modules/40-define-functions/100-define/en/data.yml
rename to modules/40-define-functions/100-define-function/en/data.yml
diff --git a/modules/40-define-functions/100-define/es/EXERCISE.md b/modules/40-define-functions/100-define-function/es/EXERCISE.md
similarity index 100%
rename from modules/40-define-functions/100-define/es/EXERCISE.md
rename to modules/40-define-functions/100-define-function/es/EXERCISE.md
diff --git a/modules/40-define-functions/100-define/es/README.md b/modules/40-define-functions/100-define-function/es/README.md
similarity index 100%
rename from modules/40-define-functions/100-define/es/README.md
rename to modules/40-define-functions/100-define-function/es/README.md
diff --git a/modules/40-define-functions/100-define/es/data.yml b/modules/40-define-functions/100-define-function/es/data.yml
similarity index 100%
rename from modules/40-define-functions/100-define/es/data.yml
rename to modules/40-define-functions/100-define-function/es/data.yml
diff --git a/modules/40-define-functions/100-define-function/ru/EXERCISE.md b/modules/40-define-functions/100-define-function/ru/EXERCISE.md
new file mode 100644
index 00000000..9cf719e4
--- /dev/null
+++ b/modules/40-define-functions/100-define-function/ru/EXERCISE.md
@@ -0,0 +1,9 @@
+Сайт выводит приветствие для каждого посетителя. Реализуйте функцию `sayHello()`, которая выводит на экран фразу `Hello, World!`.
+
+```php
+<?php
+
+sayHello(); // => Hello, World!
+```
+
+В задачах, в которых нужно реализовать функцию, эту функцию вызывать не нужно. Вызывать функцию будут автоматизированные тесты, которые проверяют ее работоспособность. Пример с вызовом выше показан только для того, чтобы вы понимали, как ваша функция будет использоваться.
diff --git a/modules/40-define-functions/100-define-function/ru/README.md b/modules/40-define-functions/100-define-function/ru/README.md
new file mode 100644
index 00000000..20a03ada
--- /dev/null
+++ b/modules/40-define-functions/100-define-function/ru/README.md
@@ -0,0 +1,127 @@
+До этого момента мы использовали только уже готовые функции: `print_r()`, `strlen()`, `round()` и другие. Но в PHP можно создавать свои собственные функции и пришла пора научиться это делать.
+
+## Зачем определять функции
+
+Допустим, у нас есть несколько похожих участков кода:
+
+```php
+<?php
+
+print_r("Hello, Hexlet!\n");
+print_r("Hello, world!\n");
+print_r("Hello, PHP!\n");
+```
+
+Чтобы не повторять один и тот же шаблон, мы можем оформить его в виде своей функции, которая принимает на вход один параметр и печатает нужную строчку на экран:
+
+```php
+<?php
+
+function sayHello($name)
+{
+    print_r("Hello, {$name}!\n");
+}
+```
+
+Теперь мы можем вызывать ее с разными аргументами:
+
+```php
+<?php
+
+sayHello('Hexlet'); // => Hello, Hexlet!
+sayHello('world');  // => Hello, world!
+sayHello('PHP');    // => Hello, PHP!
+```
+
+Вроде бы количество кода не стало меньше, но появилось кое-что другое. Если эта функция будет использоваться в разных местах, то при необходимости изменить текст, нам будет достаточно поправить только определение функции. И чем сложнее будет задача и чем чаще она будет использоваться в разных местах, тем важнее нужно выделять логику в свои функции.
+
+Определение собственных функций значительно упрощает поддержку программ еще и потому, что позволяет объединять сложные операции в одну. Например, отправка письма на сайте — это достаточно сложный процесс, который включает взаимодействие с внешними системами. Но вся сложность может быть скрыта за одной простой функцией `send($email, $title, $body)`. Один маленький вызов — и много логики внутри.
+
+## Синтаксис определения
+
+```php
+function имяФункции(параметры)
+{
+    тело
+}
+```
+
+```text
+function greet($name)             ← ключевое слово, имя функции и параметр
+{
+    return 'Hello, ' . $name;     ← тело функции
+}
+```
+
+Ключевое слово `function` начинает определение. В `имяФункции` допускается любое имя, как у переменной (но без знака `$`); в скобках указывается список параметров через запятую. Тело функции заключается в фигурные скобки, внутри пишется обычный PHP-код.
+
+В отличие от обычных данных, функции выполняют действия, поэтому их имена практически всегда должны быть глаголами: «построить что-то», «нарисовать что-то», «открыть что-то».
+
+Фигурные скобки показывают, какой код относится к телу функции. Посмотрите на пример:
+
+```php
+<?php
+
+function sayHi()
+{
+    print_r('Hi!');
+}
+
+print_r('Программа продолжается…');
+```
+
+Здесь функция `sayHi()` определена, но **`print_r('Программа продолжается…')`** не относится к функции, так как находится вне фигурных скобок. Он будет выполнен сразу при запуске программы, независимо от вызова `sayHi()`. Само определение не вызывает и не выполняет функцию — мы лишь говорим, что теперь такая функция существует.
+
+Чтобы `sayHi()` сработала, ее нужно явно вызвать:
+
+```php
+<?php
+
+function sayHi()
+{
+    print_r('Hi!');
+}
+
+sayHi(); // => Hi!
+print_r('Программа продолжается…');
+```
+
+Тело выполняется в тот момент, когда запускается функция. Причем каждый вызов функции запускает тело независимо от других вызовов. Тело может быть даже пустым:
+
+```php
+<?php
+
+// Минимальное определение функции, которая ничего не делает
+function noop() {}
+
+noop(); // Вызов есть, а смысла нет
+// Такая функция тоже бывает полезна,
+// но это относится к продвинутым темам
+```
+
+## Пример: функция для печати среднего арифметического
+
+Сейчас мы реализуем простую функцию, которая **вычисляет и печатает среднее арифметическое** двух чисел. Среднее арифметическое представляет собой сумму чисел, деленную на их количество. Например, среднее от 6 и 4 считается так: `(6 + 4) / 2 = 5`.
+
+```php
+<?php
+
+function printAverage($a, $b)
+{
+    $total = $a + $b;
+    $average = $total / 2;
+    print_r($average);
+}
+
+printAverage(6, 4); // => 5
+```
+
+Здесь `$a` и `$b` являются входными параметрами, `$total` содержит их сумму, `$average` получается делением суммы на 2, а `print_r()` выводит результат.
+
+При вызове `printAverage(6, 4)` на экран выведется `5`.
+
+## Переиспользование и читаемость
+
+Функции помогают избегать дублирования и делают программы более понятными. Название функции само по себе говорит, что она делает. Это особенно важно в больших проектах, где код читают другие программисты (или вы сами через месяц).
+
+Кстати, создание функции еще называют реализацией, определением и имплементацией. Такие слова часто встречаются на практике.
diff --git a/modules/40-define-functions/100-define/ru/data.yml b/modules/40-define-functions/100-define-function/ru/data.yml
similarity index 61%
rename from modules/40-define-functions/100-define/ru/data.yml
rename to modules/40-define-functions/100-define-function/ru/data.yml
index d4032eb1..e93d5487 100644
--- a/modules/40-define-functions/100-define/ru/data.yml
+++ b/modules/40-define-functions/100-define-function/ru/data.yml
@@ -3,4 +3,4 @@ name: Создание (определение) функций
 tips:
   - >
     [Именование в
-    программировании](https://ru.hexlet.io/blog/posts/naming-in-programming)
+    программировании](https://ru.hexlet.io/blog/posts/naming-in-programming?utm_source=code-basics&utm_medium=referral&utm_campaign=blog&utm_content=lesson)
diff --git a/modules/40-define-functions/100-define/SolutionTest.php b/modules/40-define-functions/100-define/SolutionTest.php
deleted file mode 100644
index 8a3a538a..00000000
--- a/modules/40-define-functions/100-define/SolutionTest.php
+++ /dev/null
@@ -1,17 +0,0 @@
-<?php
-
-namespace HexletBasics\DefineFunctions\Define;
-
-use PHPUnit\Framework\TestCase;
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        require 'index.php';
-
-        $expected = 'Winter is coming';
-        $this->expectOutputString($expected);
-        printMotto();
-    }
-}
diff --git a/modules/40-define-functions/100-define/assets/func_arg.png b/modules/40-define-functions/100-define/assets/func_arg.png
deleted file mode 100644
index 996bd114..00000000
Binary files a/modules/40-define-functions/100-define/assets/func_arg.png and /dev/null differ
diff --git a/modules/40-define-functions/100-define/ru/EXERCISE.md b/modules/40-define-functions/100-define/ru/EXERCISE.md
deleted file mode 100644
index b53e5363..00000000
--- a/modules/40-define-functions/100-define/ru/EXERCISE.md
+++ /dev/null
@@ -1,9 +0,0 @@
-Реализуйте функцию с именем `printMotto()`, которая выведет на экран фразу *Winter is coming*.
-
-```php
-<?php
-
-printMotto(); // => "Winter is coming"
-```
-
-В задачах, в которых нужно реализовать функцию, эту функцию вызывать не нужно. Вызывать функцию будут автоматизированные тесты, которые проверяют его работоспособность. Пример с вызовом выше показан только для того, чтобы вы понимали, как ваша функция будет использоваться.
diff --git a/modules/40-define-functions/100-define/ru/README.md b/modules/40-define-functions/100-define/ru/README.md
deleted file mode 100644
index 4552b862..00000000
--- a/modules/40-define-functions/100-define/ru/README.md
+++ /dev/null
@@ -1,68 +0,0 @@
-Напомним, что функции бывают встроенными и добавленными программистом. С первыми мы уже познакомились. А в этом уроке научимся создавать собственные.
-
-Определение собственных функций значительно упрощает написание и поддержку программ. Функции позволяют объединять сложные операции в одну. Например, отправка письма на сайте — это достаточно сложный процесс. Он включает в себя взаимодействие с внешними системами.
-
-Благодаря возможности определять функции, всю сложность можно скрыть за одной простой функцией:
-
-```php
-<?php
-
-// Гипотетический пример
-// Место откуда берется функция
-namespace Some\Email\Package\send;
-
-$email = 'support@hexlet.io';
-$title = 'Помогите';
-$body = 'Я написал историю успеха, как я могу получить скидку?';
-
-// Один маленький вызов — и много логики внутри
-send($email, $title, $body);
-```
-
-Внутри себя подобный вызов выполняет довольно много логики. Он соединяется с почтовым сервером, формирует правильный запрос на основе заголовка и тела сообщения. Затем он это отправляет и закрывает соединение.
-
-Создадим первую функцию. Ее задача — вывести на экран приветствие:
-
-```text
-Hello, Hexlet!
-```
-
-```php
-<?php
-
-// Определение функции
-// Определение не вызывает и не выполняет функцию
-// Мы лишь говорим, что теперь такая функция существует
-function showGreeting()
-{
-  $text = 'Hello, Hexlet!';
-  print_r($text);
-
-}
-
-// Вызов функции
-showGreeting(); // => 'Hello, Hexlet!'
-```
-
-В отличие от обычных данных, функции выполняют действия, поэтому их имена практически всегда должны быть глаголами: «построить что-то», «нарисовать что-то», «открыть что-то».
-
-Все, что описывается в фигурных скобках после имени функции, называется телом функции. Внутри тела можно описывать любой код. Можно сказать, что это маленькая самостоятельная программа, набор произвольных инструкций.
-
-Тело выполняется в тот момент, когда запускается функция. Причем каждый вызов функции запускает тело независимо от других вызовов.
-
-Тело функции может быть пустым:
-
-```php
-<?php
-
-// Минимальное определение функции, которая ничего не делает
-function noop() {}
-
-noop(); // Вызов есть, а смысла нет
-// Такая функция тоже бывает полезна,
-// но это относится к продвинутым темам
-```
-
-Создание функции еще называют реализацией, определением и имплементацией. Такие слова часто встречаются на практике.
-
-В задачах, в которых необходимо реализовать функцию, ее не нужно вызывать. Это делают автоматизированные тесты, которые проверяют работоспособность функции. Пример с вызовом показан выше, чтобы было понятно, как функция будет использоваться.
diff --git a/modules/40-define-functions/340-default-parameters/Makefile b/modules/40-define-functions/150-return/Makefile
similarity index 100%
rename from modules/40-define-functions/340-default-parameters/Makefile
rename to modules/40-define-functions/150-return/Makefile
diff --git a/modules/40-define-functions/150-return/Solution.php b/modules/40-define-functions/150-return/Solution.php
new file mode 100644
index 00000000..57cbbc71
--- /dev/null
+++ b/modules/40-define-functions/150-return/Solution.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace HexletBasics\DefineFunctions\ReturnInstruction;
+
+// BEGIN
+function truncate($text, $length)
+{
+    $cuttedString = substr($text, 0, $length);
+    return "{$cuttedString}...";
+}
+// END
diff --git a/modules/40-define-functions/150-return/SolutionTest.php b/modules/40-define-functions/150-return/SolutionTest.php
new file mode 100644
index 00000000..a239fe4b
--- /dev/null
+++ b/modules/40-define-functions/150-return/SolutionTest.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace HexletBasics\DefineFunctions\ReturnInstruction;
+
+use HexletBasics\Exercise\TestCase;
+
+class SolutionTest extends TestCase
+{
+    public function test()
+    {
+        $this->assertEquals('he...', truncate('hexlet', 2));
+        $this->assertEquals('it w...', truncate('it works!', 4));
+    }
+}
diff --git a/modules/40-define-functions/200-return/description.es.yml b/modules/40-define-functions/150-return/description.es.yml
similarity index 100%
rename from modules/40-define-functions/200-return/description.es.yml
rename to modules/40-define-functions/150-return/description.es.yml
diff --git a/modules/40-define-functions/200-return/en/EXERCISE.md b/modules/40-define-functions/150-return/en/EXERCISE.md
similarity index 100%
rename from modules/40-define-functions/200-return/en/EXERCISE.md
rename to modules/40-define-functions/150-return/en/EXERCISE.md
diff --git a/modules/40-define-functions/200-return/en/README.md b/modules/40-define-functions/150-return/en/README.md
similarity index 100%
rename from modules/40-define-functions/200-return/en/README.md
rename to modules/40-define-functions/150-return/en/README.md
diff --git a/modules/40-define-functions/200-return/en/data.yml b/modules/40-define-functions/150-return/en/data.yml
similarity index 100%
rename from modules/40-define-functions/200-return/en/data.yml
rename to modules/40-define-functions/150-return/en/data.yml
diff --git a/modules/40-define-functions/200-return/es/EXERCISE.md b/modules/40-define-functions/150-return/es/EXERCISE.md
similarity index 100%
rename from modules/40-define-functions/200-return/es/EXERCISE.md
rename to modules/40-define-functions/150-return/es/EXERCISE.md
diff --git a/modules/40-define-functions/200-return/es/README.md b/modules/40-define-functions/150-return/es/README.md
similarity index 100%
rename from modules/40-define-functions/200-return/es/README.md
rename to modules/40-define-functions/150-return/es/README.md
diff --git a/modules/40-define-functions/200-return/es/data.yml b/modules/40-define-functions/150-return/es/data.yml
similarity index 100%
rename from modules/40-define-functions/200-return/es/data.yml
rename to modules/40-define-functions/150-return/es/data.yml
diff --git a/modules/40-define-functions/150-return/ru/EXERCISE.md b/modules/40-define-functions/150-return/ru/EXERCISE.md
new file mode 100644
index 00000000..c338e463
--- /dev/null
+++ b/modules/40-define-functions/150-return/ru/EXERCISE.md
@@ -0,0 +1,33 @@
+Реализуйте функцию `truncate()`, которая обрезает переданную строку до указанного количества символов, добавляет в конце троеточие и возвращает получившуюся строку. Подобная логика часто используется на сайтах, чтобы отобразить длинный текст в сокращенном виде.
+
+Функция принимает два параметра:
+
+1. Строка, которую нужно обрезать
+2. Число символов, которые нужно оставить
+
+Пример того, как должна работать написанная вами функция:
+
+```php
+<?php
+
+// Передаем текст напрямую
+// Обрезаем текст, оставляя 2 символа
+truncate('hexlet', 2); // 'he...'
+
+// Через переменную
+$text = 'it works!';
+// Обрезаем текст, оставляя 4 символа
+truncate($text, 4); // 'it w...'
+```
+
+Выполнить задание можно различными способами, подскажем лишь один из них. Для решения этим способом вам понадобится взять подстроку из строки, переданной первым параметром в функцию. Используйте для этого функцию [substr()](https://www.php.net/manual/ru/function.substr.php). Подумайте, исходя из задания, с какого индекса и какой длины вам надо извлечь подстроку?
+
+```php
+<?php
+
+$word = 'welcome!';
+$length = 3;
+substr($word, 0, $length); // 'wel'
+```
+
+С точки зрения проверочной системы не имеет значения, каким из способов будет реализована функция `truncate()` внутри. Главное — чтобы она выполняла поставленную задачу.
diff --git a/modules/40-define-functions/150-return/ru/README.md b/modules/40-define-functions/150-return/ru/README.md
new file mode 100644
index 00000000..0a2620d1
--- /dev/null
+++ b/modules/40-define-functions/150-return/ru/README.md
@@ -0,0 +1,162 @@
+Функции, которые мы определяли в предыдущем уроке, заканчивали свою работу тем, что печатали на экран какие-то данные. Пользы от таких функций не очень много, так как результатом их работы невозможно воспользоваться внутри программы. В этом уроке мы научимся писать функции, которые **возвращают значения**. Такие функции отвечают на вопрос и отдают результат своей работы, как будто говорят: «Вот, держи, я посчитала».
+
+Например, функция может вернуть строку с обработанным текстом или число, вычисленное по формуле. Возвращенное значение можно использовать дальше. Его сохраняют в переменную, передают в другую функцию или выводят на экран.
+
+![Как работает функция суммирования в PHP](./assets/sum-php.jpg)
+
+Чтобы функция отдала результат, в ней используется специальное ключевое слово `return`. Оно завершает выполнение функции и указывает, что именно нужно вернуть.
+
+Вот пример функции, которая делает текст заглавным:
+
+```php
+<?php
+
+function shout($name)
+{
+    return strtoupper($name);
+}
+```
+
+Мы вызываем `shout()`, передаем туда имя и получаем строку в верхнем регистре. Эта строка является результатом функции:
+
+```php
+<?php
+
+$result = shout('hexlet');
+print_r($result); // => HEXLET
+
+$result2 = shout('code-basics');
+print_r($result2); // => CODE-BASICS
+```
+
+В отличие от `print_r()`, `return` ничего не печатает. Оно просто возвращает значение. Решение о том, что с ним делать, принимает вызывающий код.
+
+При вызове функции `shout('hexlet')` сначала выполняется выражение `strtoupper($name)`. Оно возвращает строку `'HEXLET'`. Затем `return` отдает это значение наружу, туда, откуда была вызвана функция. В нашем случае это значение сохраняется в переменную `$result`, а потом выводится на экран через `print_r()`.
+
+А что вернет функция, в которой нет `return`? Проверим на функции из прошлого урока, которая только печатает текст:
+
+```php
+<?php
+
+function greeting()
+{
+    print_r('Hello, Hexlet!');
+}
+
+$message = greeting();
+// Чтобы увидеть null, нужно воспользоваться функцией var_dump()
+var_dump($message); // => NULL
+```
+
+Функция без возврата всегда возвращает `null` — специальное значение, которое означает «ничего нет».
+
+## Возврат вычисленного выражения
+
+Функции не обязаны просто возвращать параметр. Обычно в `return` указывается **выражение**, которое сначала вычисляется, а потом результат передается наружу.
+
+```php
+<?php
+
+function fullName($first, $last)
+{
+    return ucfirst($first) . ' ' . ucfirst($last);
+}
+```
+
+В этом примере мы собираем полное имя из имени и фамилии. Функция `ucfirst()` делает первую букву строки заглавной. Сначала выполняются оба вызова `ucfirst()`, затем строки объединяются через `.`, и уже готовая строка возвращается:
+
+```php
+<?php
+
+$name = fullName('aria', 'stark');
+print_r($name); // => Aria Stark
+```
+
+Возвращать можно и значение переменной. Здесь нужно руководствоваться принципами читаемости кода:
+
+```php
+<?php
+
+function greeting()
+{
+    $message = 'Hello, Hexlet!';
+    return $message;
+}
+```
+
+Мы не возвращаем саму переменную. Всегда возвращается значение, которое находится в этой переменной.
+
+## Многострочные функции
+
+Иногда в теле функции нужно сделать несколько шагов, прежде чем получить результат. В таких случаях пишут несколько строк кода, а в конце используют `return`, чтобы вернуть итоговое значение.
+
+Например, напишем функцию, которая форматирует имя: удаляет пробелы по краям и переводит все буквы в верхний регистр.
+
+```php
+<?php
+
+function formatName($name)
+{
+    $clean = trim($name);
+    $uppercased = strtoupper($clean);
+    return $uppercased;
+}
+```
+
+Сначала убираем пробелы с помощью функции `trim()`, затем переводим в верхний регистр с помощью `strtoupper()` и возвращаем итоговое значение:
+
+```php
+<?php
+
+print_r(formatName('  hexlet  ')); // => HEXLET
+```
+
+Подобный код встречается в реальных программах постоянно. Например, когда пользователь регистрируется на сайте, он может ввести email с лишними пробелами или буквами в разном регистре: `  SuppORT@hexlet.IO`. Перед записью в базу данных такой email готовят точно так же: обрезают пробельные символы и приводят к нижнему регистру.
+
+## Код после `return`
+
+Когда PHP доходит до инструкции `return`, выполнение функции останавливается. Все, что написано после нее внутри функции, **не будет выполнено**:
+
+```php
+<?php
+
+function greeting()
+{
+    return 'Hello, Hexlet!';
+    print_r('Я никогда не выполнюсь');
+}
+```
+
+Поэтому `return` всегда пишут в конце логики. Однако таких концов внутри функции может быть много. Подробнее мы этого коснемся, когда доберемся до условных конструкций.
+
+Даже если функция возвращает данные, это не ограничивает ее в том, что она печатает. Кроме возврата данных мы можем и печатать:
+
+```php
+<?php
+
+function greeting()
+{
+    print_r('Я появлюсь в консоли');
+    return 'Hello, Hexlet!';
+}
+
+// И напечатает текст на экран, и вернет значение
+$message = greeting();
+```
+
+Вопрос на самопроверку. Что вернет вызов этой функции?
+
+```php
+<?php
+
+// Определение
+function run()
+{
+    // Возврат
+    return 5;
+    return 10;
+}
+
+// Использование
+run(); // => ?
+```
diff --git a/modules/40-define-functions/200-return/ru/assets/sum-php.jpg b/modules/40-define-functions/150-return/ru/assets/sum-php.jpg
similarity index 100%
rename from modules/40-define-functions/200-return/ru/assets/sum-php.jpg
rename to modules/40-define-functions/150-return/ru/assets/sum-php.jpg
diff --git a/modules/40-define-functions/150-return/ru/data.yml b/modules/40-define-functions/150-return/ru/data.yml
new file mode 100644
index 00000000..62b6f777
--- /dev/null
+++ b/modules/40-define-functions/150-return/ru/data.yml
@@ -0,0 +1,5 @@
+---
+name: Возврат значений
+tips:
+  - |
+    [Инструкция return](https://www.php.net/manual/ru/function.return.php)
diff --git a/modules/40-define-functions/500-reading-documentation/Makefile b/modules/40-define-functions/200-default-parameters/Makefile
similarity index 100%
rename from modules/40-define-functions/500-reading-documentation/Makefile
rename to modules/40-define-functions/200-default-parameters/Makefile
diff --git a/modules/40-define-functions/340-default-parameters/index.php b/modules/40-define-functions/200-default-parameters/Solution.php
similarity index 76%
rename from modules/40-define-functions/340-default-parameters/index.php
rename to modules/40-define-functions/200-default-parameters/Solution.php
index d4d986c5..5b270f3d 100644
--- a/modules/40-define-functions/340-default-parameters/index.php
+++ b/modules/40-define-functions/200-default-parameters/Solution.php
@@ -1,6 +1,6 @@
 <?php
 
-namespace HexletBasics\DefineFunctions\DefaultArguments;
+namespace HexletBasics\DefineFunctions\DefaultParameters;
 
 // BEGIN
 function getHiddenCard($cardNumber, $starsCount = 4)
diff --git a/modules/40-define-functions/200-default-parameters/SolutionTest.php b/modules/40-define-functions/200-default-parameters/SolutionTest.php
new file mode 100644
index 00000000..a8b86878
--- /dev/null
+++ b/modules/40-define-functions/200-default-parameters/SolutionTest.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace HexletBasics\DefineFunctions\DefaultParameters;
+
+use HexletBasics\Exercise\TestCase;
+
+class SolutionTest extends TestCase
+{
+    public function test()
+    {
+        $this->assertEquals('****1234', getHiddenCard('1234123412341234'));
+        $this->assertEquals('****4321', getHiddenCard('1234123412344321'));
+        $this->assertEquals('***4321', getHiddenCard('1234123412344321', 3));
+    }
+}
diff --git a/modules/40-define-functions/340-default-parameters/description.es.yml b/modules/40-define-functions/200-default-parameters/description.es.yml
similarity index 100%
rename from modules/40-define-functions/340-default-parameters/description.es.yml
rename to modules/40-define-functions/200-default-parameters/description.es.yml
diff --git a/modules/40-define-functions/340-default-parameters/en/EXERCISE.md b/modules/40-define-functions/200-default-parameters/en/EXERCISE.md
similarity index 100%
rename from modules/40-define-functions/340-default-parameters/en/EXERCISE.md
rename to modules/40-define-functions/200-default-parameters/en/EXERCISE.md
diff --git a/modules/40-define-functions/340-default-parameters/en/README.md b/modules/40-define-functions/200-default-parameters/en/README.md
similarity index 100%
rename from modules/40-define-functions/340-default-parameters/en/README.md
rename to modules/40-define-functions/200-default-parameters/en/README.md
diff --git a/modules/40-define-functions/340-default-parameters/en/data.yml b/modules/40-define-functions/200-default-parameters/en/data.yml
similarity index 100%
rename from modules/40-define-functions/340-default-parameters/en/data.yml
rename to modules/40-define-functions/200-default-parameters/en/data.yml
diff --git a/modules/40-define-functions/340-default-parameters/es/EXERCISE.md b/modules/40-define-functions/200-default-parameters/es/EXERCISE.md
similarity index 100%
rename from modules/40-define-functions/340-default-parameters/es/EXERCISE.md
rename to modules/40-define-functions/200-default-parameters/es/EXERCISE.md
diff --git a/modules/40-define-functions/340-default-parameters/es/README.md b/modules/40-define-functions/200-default-parameters/es/README.md
similarity index 100%
rename from modules/40-define-functions/340-default-parameters/es/README.md
rename to modules/40-define-functions/200-default-parameters/es/README.md
diff --git a/modules/40-define-functions/340-default-parameters/es/data.yml b/modules/40-define-functions/200-default-parameters/es/data.yml
similarity index 100%
rename from modules/40-define-functions/340-default-parameters/es/data.yml
rename to modules/40-define-functions/200-default-parameters/es/data.yml
diff --git a/modules/40-define-functions/200-default-parameters/ru/EXERCISE.md b/modules/40-define-functions/200-default-parameters/ru/EXERCISE.md
new file mode 100644
index 00000000..81034a7c
--- /dev/null
+++ b/modules/40-define-functions/200-default-parameters/ru/EXERCISE.md
@@ -0,0 +1,26 @@
+Реализуйте функцию `getHiddenCard()`, которая принимает на вход номер кредитки (состоящий из 16 цифр) в виде строки и возвращает его скрытую версию, которая может использоваться на сайте для отображения. Если исходная карта имела номер *2034399002125581*, то скрытая версия выглядит так *\*\*\*\*5581*. Другими словами, функция заменяет первые 12 символов, на звездочки. Количество звездочек регулируется вторым, необязательным, параметром. Значение по умолчанию — 4.
+
+```php
+<?php
+
+// Кредитка передается внутрь как строка
+// Второй параметр не передается, значит звездочек будет 4
+getHiddenCard('1234567812345678'); // "****5678"
+
+getHiddenCard('1234567812345678', 2); // "**5678"
+getHiddenCard('1234567812345678', 3); // "***5678"
+
+// Или используя переменные
+$cardNumber = '2034399002121100';
+getHiddenCard($cardNumber); // "****1100"
+getHiddenCard($cardNumber, 1); // "*1100"
+```
+
+Для выполнения задания вам понадобится функция [str_repeat()](https://www.php.net/manual/ru/function.str-repeat.php), которая повторяет строку указанное количество раз:
+
+```php
+<?php
+
+str_repeat('+', 5); // "+++++"
+str_repeat('o', 3); // "ooo"
+```
diff --git a/modules/40-define-functions/200-default-parameters/ru/README.md b/modules/40-define-functions/200-default-parameters/ru/README.md
new file mode 100644
index 00000000..d71dae13
--- /dev/null
+++ b/modules/40-define-functions/200-default-parameters/ru/README.md
@@ -0,0 +1,113 @@
+Функции могут принимать параметры. Иногда удобно задать значение сразу в определении функции, чтобы не указывать его при каждом вызове. Такое значение называется **значением по умолчанию**.
+
+Если аргумент не передан, используется это значение. Если аргумент указан, то он заменяет умолчание. С вызовом таких функций мы уже сталкивались, например, у встроенной функции `round()` второй параметр по умолчанию равен `0`. Теперь научимся определять их самостоятельно.
+
+## Пример: повторение текста
+
+Сделаем функцию, которая повторяет строку несколько раз. По умолчанию пусть будет один раз, но при желании можно указать другое количество:
+
+```php
+<?php
+
+function repeat($text, $times = 1)
+{
+    return str_repeat($text, $times);
+}
+
+print_r(repeat('Hi'));    // => Hi
+print_r(repeat('Hi', 3)); // => HiHiHi
+```
+
+В этом примере используется встроенная функция `str_repeat()`. Она работает так: берется исходная строка и повторяется указанное количество раз. Например, `str_repeat('A', 5)` вернет `'AAAAA'`. Эта функция часто применяется при генерации шаблонов, разделителей и повторяющихся фрагментов текста.
+
+```text
+function repeat($text, $times = 2)    ← $times имеет значение по умолчанию
+{
+    ...
+}
+
+repeat('go')        →  $times = 2  (по умолчанию)
+repeat('go', 5)     →  $times = 5  (явно указано)
+```
+
+Значение по умолчанию выглядит как обычное присваивание в определении. Оно срабатывает только в том случае, если параметр не передан. К этому нужно привыкнуть.
+
+Значение по умолчанию может быть даже в том случае, когда параметр один:
+
+```php
+<?php
+
+function myPrint($text = 'nothing')
+{
+    print_r($text);
+}
+
+myPrint();         // => "nothing"
+myPrint('Hexlet'); // => "Hexlet"
+```
+
+## Пример: склейка слов с разделителем
+
+По умолчанию слова соединяются пробелом, но можно указать другой символ:
+
+```php
+<?php
+
+function joinWords($word1, $word2, $sep = ' ')
+{
+    return $word1 . $sep . $word2;
+}
+
+print_r(joinWords('King', 'Road'));         // => King Road
+print_r(joinWords('Dragon', 'stone', '-')); // => Dragon-stone
+```
+
+## Пример: несколько параметров по умолчанию
+
+Функция может содержать более одного параметра со значениями по умолчанию. Например, сделаем функцию, которая строит строку-разделитель. По умолчанию символом является дефис, а длина равна 10:
+
+```php
+<?php
+
+function makeLine($symbol = '-', $length = 10)
+{
+    return str_repeat($symbol, $length);
+}
+
+print_r(makeLine());       // => ----------
+print_r(makeLine('*'));    // => **********
+print_r(makeLine('*', 5)); // => *****
+print_r(makeLine('#', 3)); // => ###
+```
+
+## Ограничение на порядок параметров
+
+Необязательные параметры всегда указываются в конце списка параметров. С точки зрения синтаксиса невозможно создать функцию, у которой после необязательного параметра идет обязательный:
+
+```php
+<?php
+
+// Такой код завершится с ошибкой
+function f($a = 5, $b = 10, $c = 100, $x)
+{
+  ...
+}
+
+// И такой
+function f($a = 5, $b = 10, $x, $c = 100)
+{
+  ...
+}
+
+// А вот такой сработает
+function f($x, $a = 5, $b = 10, $c = 100)
+{
+  ...
+}
+
+// И такой
+function f($x, $y, $a = 5, $b = 10, $c = 100)
+{
+  ...
+}
+```
diff --git a/modules/40-define-functions/340-default-parameters/ru/data.yml b/modules/40-define-functions/200-default-parameters/ru/data.yml
similarity index 100%
rename from modules/40-define-functions/340-default-parameters/ru/data.yml
rename to modules/40-define-functions/200-default-parameters/ru/data.yml
diff --git a/modules/40-define-functions/200-return/SolutionTest.php b/modules/40-define-functions/200-return/SolutionTest.php
deleted file mode 100644
index 62ea1bc5..00000000
--- a/modules/40-define-functions/200-return/SolutionTest.php
+++ /dev/null
@@ -1,16 +0,0 @@
-<?php
-
-namespace HexletBasics\DefineFunctions\ReturnInstruction;
-
-use PHPUnit\Framework\TestCase;
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        require 'index.php';
-
-        $expected = 'hurray! hurray! hurray!';
-        $this->assertEquals($expected, sayHurrayThreeTimes());
-    }
-}
diff --git a/modules/40-define-functions/200-return/index.php b/modules/40-define-functions/200-return/index.php
deleted file mode 100644
index 76ff85f7..00000000
--- a/modules/40-define-functions/200-return/index.php
+++ /dev/null
@@ -1,11 +0,0 @@
-<?php
-
-namespace HexletBasics\DefineFunctions\ReturnInstruction;
-
-// BEGIN
-function sayHurrayThreeTimes()
-{
-    $word = 'hurray!';
-    return "{$word} {$word} {$word}";
-}
-// END
diff --git a/modules/40-define-functions/200-return/ru/EXERCISE.md b/modules/40-define-functions/200-return/ru/EXERCISE.md
deleted file mode 100644
index 04778a80..00000000
--- a/modules/40-define-functions/200-return/ru/EXERCISE.md
+++ /dev/null
@@ -1,11 +0,0 @@
-
-Реализуйте функцию `sayHurrayThreeTimes()`, которая возвращает строку 'hurray! hurray! hurray!'.
-
-```php
-<?php
-
-$hurray = sayHurrayThreeTimes();
-print_r($hurray); // => 'hurray! hurray! hurray!'
-```
-
-Вам не нужно вызывать свою функцию, только определить её.
diff --git a/modules/40-define-functions/200-return/ru/README.md b/modules/40-define-functions/200-return/ru/README.md
deleted file mode 100644
index d3c8510d..00000000
--- a/modules/40-define-functions/200-return/ru/README.md
+++ /dev/null
@@ -1,140 +0,0 @@
-Функции, которые мы определяли в предыдущих уроках, заканчивали свою работу тем, что печатали на экран какие-то данные:
-
-```php
-<?php
-
-function greeting()
-{
-    print_r('Hello, Hexlet!');
-}
-```
-
-Пользы от таких функций не очень много, так как результатом их работы невозможно воспользоваться внутри программы. Чтобы это можно было сделать, нужно возвращать значение из функции, чему мы и научимся в этом уроке.
-
-Рассмотрим задачу обработки электронной почты. Когда пользователь регистрируется на каком-то сайте, он может ввести email любым способом:
-
-* Добавить случайно пробелы в начале или в конце `_support@hexlet.io__`
-* Использовать буквы в разном регистре `SUPPORT@hexlet.io`
-
-Если мы сохраним email в таком виде в базу данных, то пользователь не сможет войти на сайт. Такое возможно, если он будет вбивать адрес без пробелов и в другом регистре.
-
-Чтобы этого не произошло, email нужно подготовить к записи в базу. Его нужно привести к нижнему регистру и обрезать пробельные символы по краям строки. Такая задача решается в пару строчек:
-
-```php
-<?php
-
-function saveEmail()
-{
-    $email = "  SuppORT@hexlet.IO";
-    // Обрезаем пробельные символы
-    // Функция trim() удаляет пробелы из начала и конца строки
-    $trimmedEmail = trim($email);
-    $preparedEmail = strtolower($trimmedEmail);
-    print_r($preparedEmail);
-    // Здесь будет запись в базу данных
-}
-```
-
-Этот код стал возможен только благодаря возврату значения. Функции `trim()` и `strtolower()` ничего не печатают на экран. Они возвращают результат своей работы, и поэтому мы можем записать его в переменные.
-
-Если бы функции вместо возврата результата печатали на экран, мы бы не могли присвоить результат их работы переменной. Как мы не можем сделать с определенной выше функцией `greeting()`:
-
-```php
-<?php
-
-$message = greeting();
-// Чтобы увидеть null, нужно воспользоваться функцией var_dump()
-var_dump($message); // => NULL
-```
-
-Изменим функцию `greeting()` так, чтобы она начала возвращать данные вместо их печати. Для этого нам понадобится выполнить возврат вместо печати на экран:
-
-```php
-<?php
-
-function greeting()
-{
-    return 'Hello, Hexlet!';
-}
-```
-
-`return` — особая инструкция, которая берет выражение, записанное справа. Далее она отдает его наружу тому коду, который вызвал метод. Как только PHP натыкается на `return`, выполнение функции на этом завершается:
-
-![how sum function works in PHP](./assets/sum-php.jpg)
-
-```php
-<?php
-
-// Теперь мы можем использовать результат работы функции
-$message = greeting();
-print_r($message); // => 'Hello, Hexlet!'
-// И даже выполнить какие-то действия над результатом
-print_r(strtoupper($message)); // => 'HELLO, HEXLET!'
-```
-
-Любой код после `return` не выполняется:
-
-```php
-<?php
-
-function greeting()
-{
-    return 'Hello, Hexlet!';
-    print_r('Я никогда не выполнюсь');
-}
-```
-
-Даже если функция возвращает данные, это не ограничивает ее в том, что она печатает. Кроме возврата данных мы можем и печатать:
-
-```php
-<?php
-
-function greeting()
-{
-    print_r('Я появлюсь в консоли');
-    return 'Hello, Hexlet!';
-}
-// И напечатает текст на экран и вернет значение
-$message = greeting();
-```
-
-Возвращать можно не только конкретное значение. Так как `return` работает с выражениями, то справа от него может появиться почти всё что угодно. Здесь нужно руководствоваться принципами читаемости кода:
-
-```php
-<?php
-
-function greeting()
-{
-    $message = 'Hello, Hexlet!';
-    return $message;
-}
-```
-
-Здесь мы не возвращаем переменную. Всегда возвращается значение, которое находится в этой переменной. Ниже пример с вычислениями:
-
-```php
-<?php
-
-function doubleFive()
-{
-    // или return 5 + 5
-    $result = 5 + 5;
-    return $result;
-}
-```
-
-Вопрос на самопроверку. Что выведет этот код?
-
-```php
-<?php
-
-// Определение
-function run()
-{
-    // Возврат
-    return 5;
-    return 10;
-}
-// Использование
-run(); // => ?
-```
diff --git a/modules/40-define-functions/200-return/ru/assets/func_return.png b/modules/40-define-functions/200-return/ru/assets/func_return.png
deleted file mode 100644
index c0f696db..00000000
Binary files a/modules/40-define-functions/200-return/ru/assets/func_return.png and /dev/null differ
diff --git a/modules/40-define-functions/200-return/ru/data.yml b/modules/40-define-functions/200-return/ru/data.yml
deleted file mode 100644
index b9db59ab..00000000
--- a/modules/40-define-functions/200-return/ru/data.yml
+++ /dev/null
@@ -1,3 +0,0 @@
----
-name: Возврат значений
-tips: []
diff --git a/modules/45-logic/15-predicates/Makefile b/modules/40-define-functions/250-named-arguments/Makefile
similarity index 100%
rename from modules/45-logic/15-predicates/Makefile
rename to modules/40-define-functions/250-named-arguments/Makefile
diff --git a/modules/40-define-functions/250-named-arguments/Solution.php b/modules/40-define-functions/250-named-arguments/Solution.php
new file mode 100644
index 00000000..7aa577d2
--- /dev/null
+++ b/modules/40-define-functions/250-named-arguments/Solution.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace HexletBasics\DefineFunctions\NamedArguments;
+
+function trimAndRepeat($text, $offset = 0, $repetitions = 1)
+{
+    // BEGIN
+    return str_repeat(substr($text, $offset), $repetitions);
+    // END
+}
diff --git a/modules/40-define-functions/250-named-arguments/SolutionTest.php b/modules/40-define-functions/250-named-arguments/SolutionTest.php
new file mode 100644
index 00000000..6537fec7
--- /dev/null
+++ b/modules/40-define-functions/250-named-arguments/SolutionTest.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace HexletBasics\DefineFunctions\NamedArguments;
+
+use HexletBasics\Exercise\TestCase;
+
+class SolutionTest extends TestCase
+{
+    public function test()
+    {
+        $this->assertEquals('python', trimAndRepeat('python'));
+        $this->assertEquals('on', trimAndRepeat('python', offset: 4));
+        $this->assertEquals('pythonpython', trimAndRepeat('python', repetitions: 2));
+        $this->assertEquals('onon', trimAndRepeat('python', offset: 4, repetitions: 2));
+    }
+}
diff --git a/modules/40-define-functions/250-named-arguments/description.es.yml b/modules/40-define-functions/250-named-arguments/description.es.yml
new file mode 100644
index 00000000..f68282a5
--- /dev/null
+++ b/modules/40-define-functions/250-named-arguments/description.es.yml
@@ -0,0 +1,50 @@
+---
+
+name: Argumentos con nombre
+theory: |
+  A partir de PHP 8, los argumentos se pueden pasar por el nombre del parámetro. El nombre se escribe sin `$`, seguido de dos puntos:
+
+  ```php
+  <?php
+
+  function repeat($text, $times)
+  {
+      return str_repeat($text, $times);
+  }
+
+  repeat('Hi', 3);              // llamada posicional
+  repeat(text: 'Hi', times: 3); // llamada con nombre
+  repeat(times: 3, text: 'Hi'); // el orden no importa
+  repeat('Hi', times: 3);       // los posicionales van primero
+  ```
+
+  Los argumentos con nombre destacan cuando una función tiene varios parámetros opcionales y solo necesitas cambiar algunos:
+
+  ```php
+  <?php
+
+  // Sin argumentos con nombre: number_format(1234.567, 0, '.', ' ')
+  number_format(1234.567, thousands_separator: ' '); // => 1 235
+  ```
+
+instructions: |
+  Completa la función `trimAndRepeat()`. Recibe una cadena, un `offset` — el número de caracteres que hay que recortar por la izquierda (0 por defecto), y `repetitions` — cuántas veces hay que repetir la cadena (1 por defecto). La firma ya está definida en la plantilla. La función devuelve la cadena resultante:
+
+  ```php
+  <?php
+
+  $text = 'python';
+
+  trimAndRepeat($text, offset: 3, repetitions: 2); // honhon
+  trimAndRepeat($text, repetitions: 3); // pythonpythonpython
+  trimAndRepeat($text); // python
+  ```
+
+  ## Pista
+
+  * Usa `substr()` para recortar la cadena y `str_repeat()` para repetirla
+
+tips:
+  - >
+    [Argumentos con nombre en la
+    documentación](https://www.php.net/manual/es/functions.arguments.php#functions.named-arguments)
diff --git a/modules/40-define-functions/250-named-arguments/en/EXERCISE.md b/modules/40-define-functions/250-named-arguments/en/EXERCISE.md
new file mode 100644
index 00000000..518258da
--- /dev/null
+++ b/modules/40-define-functions/250-named-arguments/en/EXERCISE.md
@@ -0,0 +1,15 @@
+Finish the `trimAndRepeat()` function. It takes a string, an `offset` — the number of characters to cut off from the left (0 by default), and `repetitions` — how many times to repeat the string (1 by default). The signature is already defined in the template. The function returns the resulting string:
+
+```php
+<?php
+
+$text = 'python';
+
+trimAndRepeat($text, offset: 3, repetitions: 2); // honhon
+trimAndRepeat($text, repetitions: 3); // pythonpythonpython
+trimAndRepeat($text); // python
+```
+
+## Hint
+
+* Use `substr()` to cut the string and `str_repeat()` to repeat it
diff --git a/modules/40-define-functions/250-named-arguments/en/README.md b/modules/40-define-functions/250-named-arguments/en/README.md
new file mode 100644
index 00000000..7e474a97
--- /dev/null
+++ b/modules/40-define-functions/250-named-arguments/en/README.md
@@ -0,0 +1,24 @@
+Starting with PHP 8, arguments can be passed by parameter name. The name is written without `$`, followed by a colon:
+
+```php
+<?php
+
+function repeat($text, $times)
+{
+    return str_repeat($text, $times);
+}
+
+repeat('Hi', 3);              // positional call
+repeat(text: 'Hi', times: 3); // named call
+repeat(times: 3, text: 'Hi'); // order does not matter
+repeat('Hi', times: 3);       // positional arguments go first
+```
+
+Named arguments shine when a function has several optional parameters and you only need to override some of them:
+
+```php
+<?php
+
+// Without named arguments: number_format(1234.567, 0, '.', ' ')
+number_format(1234.567, thousands_separator: ' '); // => 1 235
+```
diff --git a/modules/40-define-functions/250-named-arguments/en/data.yml b/modules/40-define-functions/250-named-arguments/en/data.yml
new file mode 100644
index 00000000..94a8a2c2
--- /dev/null
+++ b/modules/40-define-functions/250-named-arguments/en/data.yml
@@ -0,0 +1,6 @@
+---
+name: Named arguments
+tips:
+  - >
+    [Named arguments in the
+    documentation](https://www.php.net/manual/en/functions.arguments.php#functions.named-arguments)
diff --git a/modules/40-define-functions/250-named-arguments/es/EXERCISE.md b/modules/40-define-functions/250-named-arguments/es/EXERCISE.md
new file mode 100644
index 00000000..061c63fd
--- /dev/null
+++ b/modules/40-define-functions/250-named-arguments/es/EXERCISE.md
@@ -0,0 +1,15 @@
+Completa la función `trimAndRepeat()`. Recibe una cadena, un `offset` — el número de caracteres que hay que recortar por la izquierda (0 por defecto), y `repetitions` — cuántas veces hay que repetir la cadena (1 por defecto). La firma ya está definida en la plantilla. La función devuelve la cadena resultante:
+
+```php
+<?php
+
+$text = 'python';
+
+trimAndRepeat($text, offset: 3, repetitions: 2); // honhon
+trimAndRepeat($text, repetitions: 3); // pythonpythonpython
+trimAndRepeat($text); // python
+```
+
+## Pista
+
+* Usa `substr()` para recortar la cadena y `str_repeat()` para repetirla
diff --git a/modules/40-define-functions/250-named-arguments/es/README.md b/modules/40-define-functions/250-named-arguments/es/README.md
new file mode 100644
index 00000000..c65fa549
--- /dev/null
+++ b/modules/40-define-functions/250-named-arguments/es/README.md
@@ -0,0 +1,24 @@
+A partir de PHP 8, los argumentos se pueden pasar por el nombre del parámetro. El nombre se escribe sin `$`, seguido de dos puntos:
+
+```php
+<?php
+
+function repeat($text, $times)
+{
+    return str_repeat($text, $times);
+}
+
+repeat('Hi', 3);              // llamada posicional
+repeat(text: 'Hi', times: 3); // llamada con nombre
+repeat(times: 3, text: 'Hi'); // el orden no importa
+repeat('Hi', times: 3);       // los posicionales van primero
+```
+
+Los argumentos con nombre destacan cuando una función tiene varios parámetros opcionales y solo necesitas cambiar algunos:
+
+```php
+<?php
+
+// Sin argumentos con nombre: number_format(1234.567, 0, '.', ' ')
+number_format(1234.567, thousands_separator: ' '); // => 1 235
+```
diff --git a/modules/40-define-functions/250-named-arguments/es/data.yml b/modules/40-define-functions/250-named-arguments/es/data.yml
new file mode 100644
index 00000000..aaa5d118
--- /dev/null
+++ b/modules/40-define-functions/250-named-arguments/es/data.yml
@@ -0,0 +1,6 @@
+---
+name: Argumentos con nombre
+tips:
+  - >
+    [Argumentos con nombre en la
+    documentación](https://www.php.net/manual/es/functions.arguments.php#functions.named-arguments)
diff --git a/modules/40-define-functions/250-named-arguments/ru/EXERCISE.md b/modules/40-define-functions/250-named-arguments/ru/EXERCISE.md
new file mode 100644
index 00000000..66000aae
--- /dev/null
+++ b/modules/40-define-functions/250-named-arguments/ru/EXERCISE.md
@@ -0,0 +1,24 @@
+Программа готовит текст уведомлений: убирает ненужные символы с начала и повторяет сообщение нужное количество раз. Допишите функцию `trimAndRepeat()`, которая принимает три параметра:
+
+* Строку
+* `offset` — число символов, на которое нужно обрезать строку слева
+* `repetitions` — сколько раз нужно повторить строку перед возвратом получившейся строки
+
+Число символов для среза по умолчанию равно 0, а количество повторений по умолчанию равно 1. Сигнатура функции с этими значениями уже задана в шаблоне, вам осталось дописать тело.
+
+Функция должна возвращать полученную строку.
+
+```php
+<?php
+
+$text = 'python';
+
+trimAndRepeat($text, offset: 3, repetitions: 2); // honhon
+trimAndRepeat($text, repetitions: 3); // pythonpythonpython
+trimAndRepeat($text); // python
+```
+
+## Подсказки
+
+* Обрезать строку слева поможет функция `substr()`, а повторить ее — `str_repeat()`
+* С точки зрения проверочной системы не имеет значения, каким из способов будет реализована функция `trimAndRepeat()` внутри. Главное — чтобы она выполняла поставленную задачу
diff --git a/modules/40-define-functions/250-named-arguments/ru/README.md b/modules/40-define-functions/250-named-arguments/ru/README.md
new file mode 100644
index 00000000..766215a3
--- /dev/null
+++ b/modules/40-define-functions/250-named-arguments/ru/README.md
@@ -0,0 +1,84 @@
+При вызове функции аргументы можно передавать двумя способами. В **позиционном вызове** значения идут строго по порядку. Первое попадает в первый параметр, второе во второй. **Именованные аргументы** появились в PHP 8 и позволяют при вызове явно указать имя параметра. Это удобно, когда у функции много параметров и нужно переопределить лишь некоторые. Остальные остаются со значениями по умолчанию.
+
+```php
+<?php
+
+function repeat($text, $times)
+{
+    return str_repeat($text, $times);
+}
+
+repeat('Hi', 3);              // позиционный вызов
+repeat(text: 'Hi', times: 3); // именованный вызов
+```
+
+Внутри используется встроенная функция `str_repeat()` — она повторяет строку указанное количество раз, поэтому `repeat('Hi', 3)` вернет `HiHiHi`.
+
+Оба варианта вызова делают одно и то же. Во втором случае мы явно написали, что `'Hi'` является значением `$text`, а `3` является значением `$times`. Имя параметра указывается без знака `$`, после имени ставится двоеточие. С точки зрения определения функции ничего не поменялось. Именованные аргументы работают для любой функции, и сама функция об этом ничего не знает. Она получает значения так, как они описаны в определении.
+
+```text
+function truncate($text, $length) { ... }
+
+Позиционные:  truncate('hello', 3)
+                       └──┬──┘  └┬┘
+                       $text   $length
+
+Именованные:  truncate(length: 3, text: 'hello')
+                       └───┬───┘  └─────┬─────┘
+                       $length        $text
+```
+
+Именованные аргументы можно указывать в любом порядке. Это не меняет результат работы функции, потому что значения связываются именно по имени параметра:
+
+```php
+<?php
+
+repeat(times: 3, text: 'Hi'); // => HiHiHi
+```
+
+Именованные аргументы можно комбинировать с позиционными, при этом позиционные идут первыми. Такой вызов позволяет указывать только те параметры, которые нужно переопределить:
+
+```php
+<?php
+
+repeat('Hi', times: 3); // позиционные + именованные => HiHiHi
+```
+
+## Когда использовать именованные аргументы
+
+Именованные аргументы полезны, когда у функции есть несколько параметров и не все из них нужно менять. В таких случаях можно указать только те параметры, которые важны в конкретном вызове, а остальные оставить со значениями по умолчанию.
+
+Вы уже знаете, что у встроенной функции `round()` второй параметр необязательный. В именованном вызове используются имена параметров из сигнатуры в документации — `round(int|float $num, int $precision = 0)`:
+
+```php
+<?php
+
+round(10.252, 1);                 // 10.3
+round(num: 10.252, precision: 1); // 10.3 — то же самое, но понятнее
+```
+
+Сила именованных аргументов проявляется, когда необязательных параметров несколько. Посмотрим на встроенную функцию `number_format()`, которая форматирует число. Ее упрощенная сигнатура выглядит так:
+
+```php
+number_format(
+    float $num,
+    int $decimals = 0,
+    string $decimal_separator = '.',
+    string $thousands_separator = ','
+)
+```
+
+Допустим, мы хотим поменять только разделитель тысяч, а точность и десятичный разделитель оставить по умолчанию:
+
+```php
+<?php
+
+// Без именованных аргументов придется явно повторить
+// значения всех параметров, которые идут раньше
+number_format(1234.567, 0, '.', ' ');              // => 1 235
+
+// С именованными — указываем только нужный
+number_format(1234.567, thousands_separator: ' '); // => 1 235
+```
+
+Разделитель указывать стало проще, даже несмотря на то, что перед ним в списке параметров идут еще два. Именованные аргументы делают вызовы понятнее. Читая код, сразу видно, какое значение к какому параметру относится.
diff --git a/modules/40-define-functions/250-named-arguments/ru/data.yml b/modules/40-define-functions/250-named-arguments/ru/data.yml
new file mode 100644
index 00000000..ac1151f4
--- /dev/null
+++ b/modules/40-define-functions/250-named-arguments/ru/data.yml
@@ -0,0 +1,6 @@
+---
+name: Именованные аргументы
+tips:
+  - >
+    [Именованные аргументы в
+    документации](https://www.php.net/manual/ru/functions.arguments.php#functions.named-arguments)
diff --git a/modules/40-define-functions/300-parameters/SolutionTest.php b/modules/40-define-functions/300-parameters/SolutionTest.php
deleted file mode 100644
index f5468f49..00000000
--- a/modules/40-define-functions/300-parameters/SolutionTest.php
+++ /dev/null
@@ -1,16 +0,0 @@
-<?php
-
-namespace HexletBasics\DefineFunctions\Parameters;
-
-use PHPUnit\Framework\TestCase;
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        require 'index.php';
-
-        $this->assertEquals('Hex...', truncate('Hexlet', 3));
-        $this->assertEquals('Hello...', truncate('Hello world', 5));
-    }
-}
diff --git a/modules/40-define-functions/300-parameters/description.es.yml b/modules/40-define-functions/300-parameters/description.es.yml
deleted file mode 100644
index 4be527b6..00000000
--- a/modules/40-define-functions/300-parameters/description.es.yml
+++ /dev/null
@@ -1,111 +0,0 @@
----
-
-name: Parámetros de funciones
-theory: |
-  Las funciones no solo pueden devolver valores, sino también recibirlos como parámetros. Ya nos hemos encontrado con parámetros de funciones:
-
-  ```php
-  <?php
-
-  // Recibe un parámetro de cualquier tipo
-  print_r('soy un parámetro');
-  // Recibe dos parámetros numéricos:
-  // El primero es el número a redondear
-  // El segundo es el número de decimales a dejar
-  round(10.1245, 3); // 10.125
-  // Recibe tres parámetros de tipo cadena:
-  // El primero es lo que buscamos
-  // El segundo es por qué lo reemplazamos
-  // El tercero es la cadena en la que se realiza el reemplazo
-  str_replace('go', 'mo', 'google'); // 'moogle'
-  ```
-
-  En esta lección aprenderemos a crear funciones que reciben parámetros. Supongamos que tenemos la tarea de implementar la función `getLastChar()`. Esta función devuelve el último carácter de una cadena que se pasa como parámetro. Así es como se usaría esta función:
-
-  ```php
-  <?php
-
-  // Pasando parámetros directamente sin variables
-  getLastChar('Hexlet'); // 't'
-  // Pasando parámetros a través de variables
-  $name1 = 'Hexlet';
-  getLastChar($name1); // 't'
-  $name2 = 'Goo';
-  getLastChar($name2); // 'o'
-  ```
-
-  De la descripción y los ejemplos de código podemos hacer las siguientes conclusiones:
-
-  * Necesitamos definir la función `getLastChar()`
-  * La función debe recibir un parámetro de tipo cadena
-  * La función debe devolver un valor de tipo cadena
-
-  Definición de la función:
-
-  ```php
-  <?php
-
-  function getLastChar($str)
-  {
-      // Calculamos el índice del último carácter como la longitud de la cadena - 1
-      return $str[strlen($str) - 1];
-  }
-  ```
-
-  Vamos a analizarlo. Entre paréntesis se especifica el nombre del parámetro (`$str`). Como dentro de la función no sabemos con qué valor específico estamos trabajando, los parámetros siempre se describen como variables.
-
-  El nombre del parámetro puede ser cualquier cosa, no está relacionado con la forma en que se llama a la función. Lo importante es que este nombre refleje el significado del valor que contiene. El valor específico del parámetro dependerá de cómo se llame a esta función.
-
-  Este parámetro es obligatorio. Si intentamos llamar a la función sin él, el intérprete mostrará un error:
-
-  ```sh
-  getLastChar(); // este código no tiene sentido
-  ArgumentCountError: Too few arguments to function getLastChar(), 0 passed
-  ```
-
-  También se pueden especificar dos, tres o más parámetros. Se separan por comas:
-
-  ```php
-  <?php
-
-  // Función para encontrar el número medio
-  function average($x, $y)
-  {
-      return ($x + $y) / 2;
-  }
-  average(1, 5); // 3
-  average(1, 2); // 1.5
-  ```
-
-instructions: |
-  Implementa la función `truncate()`, que recorta la cadena pasada como argumento hasta el número de caracteres especificado, agrega puntos suspensivos al final y devuelve la cadena resultante. Esta lógica se utiliza a menudo en sitios web para mostrar texto largo de forma abreviada. La función recibe dos parámetros:
-
-  1. La cadena que se debe recortar
-  2. El número de caracteres que se deben dejar
-
-  ```php
-  <?php
-
-  // Pasando el texto directamente
-  // Recortar el texto dejando 2 caracteres
-  truncate('hexlet', 2)  // 'he...'
-
-  // A través de una variable
-  $text = '¡funciona!'
-  // Recortar el texto dejando 4 caracteres
-  $result = truncate($text, 4);
-  print_r($result); // => '¡fun...'
-  ```
-
-  Puedes implementar esta función de diferentes maneras, solo te daremos una pista. Para resolverlo de esta manera, necesitarás extraer una subcadena de la cadena pasada como primer parámetro a la función `truncate()`. Para hacer esto, utiliza la función [substr()](https://www.php.net/manual/es/function.substr.php). Piensa, en función de la tarea, desde qué índice y con qué longitud debes extraer la subcadena.
-
-    ```php
-    <?php
-
-    $word = 'bienvenido';
-    // Puedes pasar los parámetros a la función a través de variables
-    $length = 3;
-    substr($word, 0, $length); // 'bie'
-    ```
-
-  Desde el punto de vista del sistema de evaluación, no importa qué método utilices para implementar la función `truncate()` internamente, lo importante es que cumpla con la tarea planteada.
diff --git a/modules/40-define-functions/300-parameters/en/EXERCISE.md b/modules/40-define-functions/300-parameters/en/EXERCISE.md
deleted file mode 100644
index 3d8fdefa..00000000
--- a/modules/40-define-functions/300-parameters/en/EXERCISE.md
+++ /dev/null
@@ -1,32 +0,0 @@
-
-Implement a function, `truncate()`, which trims a string passed to the function to a specified number of characters, adds a dash at the end, and returns the resulting string. This kind of logic is often used on websites to display long text in short form. The function takes two parameters:
-
-1. The string that needs to be trimmed
-2. The number of characters to keep.
-
-```php
-<?php
-
-// Passing text directly
-// Trim the text, leaving 2 characters
-truncate('hexlet', 2)  // 'he...'
-
-// Through a variable
-$text = 'it works!'
-// Trim the text, leaving 4 characters
-$result = truncate($text, 4);
-print_r($result); // => 'it w...'
-```
-
-This function can be implemented in different ways, we'll tell you just one of them. To do it this way, you need to take a substring from the string passed as the first parameter to the `truncate()` function. Use the [substr()](https://www.php.net/manual/en/function.substr.php)  function to do this. Think, based on the assignment, which index should you extract the substring from, and how long should it be?
-
-  ```php
-  <?php
-
-  $word = 'welcome';
-  // You can pass parameters to the function via variables
-  $length = 3;
-  substr($word, 0, $length); // 'wel'
-  ```
-
-From the point of view of the testing system, it doesn't matter which way the `truncate()` function is implemented internally, as long as it performs the task at hand
diff --git a/modules/40-define-functions/300-parameters/en/README.md b/modules/40-define-functions/300-parameters/en/README.md
deleted file mode 100644
index 24d7ae0c..00000000
--- a/modules/40-define-functions/300-parameters/en/README.md
+++ /dev/null
@@ -1,73 +0,0 @@
-Functions can not only return values, but also accept them as parameters. We've encountered function parameters many times before:
-
-```php
-<?php
-
-// Accepts one parameter of any type as input
-print_r('I'm a parameter');
-// Accepts two numeric parameters as input
-// the first is a rounded number,
-// the second is the number of decimal places to leave
-round(10.1245, 3); // 10.125
-// Accepts three string parameters as input
-// the first one is what we're looking for, the second one is what we're changing it to
-// the third is the string that we're making replacements to
-str_replace('go', 'mo', 'google'); // 'moogle'
-```
-
-In this lesson, we'll learn how to create functions that take parameters as input. Suppose we need to implement a function called `getLastChar()`, which returns the last character in the string passed to it as a parameter. Here's what using this function would look like:
-
-```php
-<?php
-
-// Passing parameters directly without variables
-getLastChar('Hexlet'); // 't'
-
-// Passing parameters through variables
-$name1 = 'Hexlet';
-getLastChar($name1); // 't'
-$name2 = 'Goo';
-getLastChar($name2); // 'o'
-```
-
-We can draw the following conclusions from the description and examples:
-
-* We need to define the `getLastChar()` function
-* The function must accept one parameter as input, a string
-* The function must return a string
-
-Defining the function:
-
-```php
-<?php
-
-function getLastChar($str)
-{
-    // Calculate the index of the last character as the length of the string minus - 1
-    return $str[strlen($str) - 1];
-}
-```
-
-Let's break it down. The name of the parameter (`$str`) is given in parentheses. Since we don't know which value is being worked with within functions, parameters are always described as variables. The name of the parameter can be anything, it's not related to how the function is called. The main thing is that the name should reflect the meaning of the meaning contained within. The specific value of the parameter will depend on the call to this function.
-
-This parameter is mandatory. If you try to call a function without a parameter, the interpreter will give an error:
-
-```bash
-getLastChar(); // this code doesn't make sense
-ArgumentCountError: Too few arguments to function getLastChar(), 0 passed
-```
-
-You can specify two, three or more parameters in exactly the same way. Each parameter is separated from each other with a comma.
-
-```php
-<?php
-
-// function to find the average number
-function average($x, $y)
-{
-    return ($x + $y) / 2;
-}
-
-average(1, 5); // 3
-average(1, 2); // 1.5
-```
diff --git a/modules/40-define-functions/300-parameters/en/data.yml b/modules/40-define-functions/300-parameters/en/data.yml
deleted file mode 100644
index 9f891982..00000000
--- a/modules/40-define-functions/300-parameters/en/data.yml
+++ /dev/null
@@ -1,2 +0,0 @@
----
-name: Function Parameters
diff --git a/modules/40-define-functions/300-parameters/es/EXERCISE.md b/modules/40-define-functions/300-parameters/es/EXERCISE.md
deleted file mode 100644
index b0b40139..00000000
--- a/modules/40-define-functions/300-parameters/es/EXERCISE.md
+++ /dev/null
@@ -1,31 +0,0 @@
-Implementa la función `truncate()`, que recorta la cadena pasada como argumento hasta el número de caracteres especificado, agrega puntos suspensivos al final y devuelve la cadena resultante. Esta lógica se utiliza a menudo en sitios web para mostrar texto largo de forma abreviada. La función recibe dos parámetros:
-
-1. La cadena que se debe recortar
-2. El número de caracteres que se deben dejar
-
-```php
-<?php
-
-// Pasando el texto directamente
-// Recortar el texto dejando 2 caracteres
-truncate('hexlet', 2)  // 'he...'
-
-// A través de una variable
-$text = '¡funciona!'
-// Recortar el texto dejando 4 caracteres
-$result = truncate($text, 4);
-print_r($result); // => '¡fun...'
-```
-
-Puedes implementar esta función de diferentes maneras, solo te daremos una pista. Para resolverlo de esta manera, necesitarás extraer una subcadena de la cadena pasada como primer parámetro a la función `truncate()`. Para hacer esto, utiliza la función [substr()](https://www.php.net/manual/es/function.substr.php). Piensa, en función de la tarea, desde qué índice y con qué longitud debes extraer la subcadena.
-
-  ```php
-  <?php
-
-  $word = 'bienvenido';
-  // Puedes pasar los parámetros a la función a través de variables
-  $length = 3;
-  substr($word, 0, $length); // 'bie'
-  ```
-
-Desde el punto de vista del sistema de evaluación, no importa qué método utilices para implementar la función `truncate()` internamente, lo importante es que cumpla con la tarea planteada.
diff --git a/modules/40-define-functions/300-parameters/es/README.md b/modules/40-define-functions/300-parameters/es/README.md
deleted file mode 100644
index 6fa8b3e7..00000000
--- a/modules/40-define-functions/300-parameters/es/README.md
+++ /dev/null
@@ -1,77 +0,0 @@
-Las funciones no solo pueden devolver valores, sino también recibirlos como parámetros. Ya nos hemos encontrado con parámetros de funciones:
-
-```php
-<?php
-
-// Recibe un parámetro de cualquier tipo
-print_r('soy un parámetro');
-// Recibe dos parámetros numéricos:
-// El primero es el número a redondear
-// El segundo es el número de decimales a dejar
-round(10.1245, 3); // 10.125
-// Recibe tres parámetros de tipo cadena:
-// El primero es lo que buscamos
-// El segundo es por qué lo reemplazamos
-// El tercero es la cadena en la que se realiza el reemplazo
-str_replace('go', 'mo', 'google'); // 'moogle'
-```
-
-En esta lección aprenderemos a crear funciones que reciben parámetros. Supongamos que tenemos la tarea de implementar la función `getLastChar()`. Esta función devuelve el último carácter de una cadena que se pasa como parámetro. Así es como se usaría esta función:
-
-```php
-<?php
-
-// Pasando parámetros directamente sin variables
-getLastChar('Hexlet'); // 't'
-// Pasando parámetros a través de variables
-$name1 = 'Hexlet';
-getLastChar($name1); // 't'
-$name2 = 'Goo';
-getLastChar($name2); // 'o'
-```
-
-De la descripción y los ejemplos de código podemos hacer las siguientes conclusiones:
-
-* Necesitamos definir la función `getLastChar()`
-* La función debe recibir un parámetro de tipo cadena
-* La función debe devolver un valor de tipo cadena
-
-Definición de la función:
-
-```php
-<?php
-
-function getLastChar($str)
-{
-    // Calculamos el índice del último carácter como la longitud de la cadena - 1
-    return $str[strlen($str) - 1];
-}
-```
-
-Vamos a analizarlo. Entre paréntesis se especifica el nombre del parámetro (`$str`). Como dentro de la función no sabemos con qué valor específico estamos trabajando, los parámetros siempre se describen como variables.
-
-El nombre del parámetro puede ser cualquier cosa, no está relacionado con la forma en que se llama a la función. Lo importante es que este nombre refleje el significado del valor que contiene. El valor específico del parámetro dependerá de cómo se llame a esta función.
-
-Este parámetro es obligatorio. Si intentamos llamar a la función sin él, el intérprete mostrará un error:
-
-```php
-getLastChar(); // este código no tiene sentido
-```
-
-```text
-ArgumentCountError: Too few arguments to function getLastChar(), 0 passed
-```
-
-También se pueden especificar dos, tres o más parámetros. Se separan por comas:
-
-```php
-<?php
-
-// Función para encontrar el número medio
-function average($x, $y)
-{
-    return ($x + $y) / 2;
-}
-average(1, 5); // 3
-average(1, 2); // 1.5
-```
diff --git a/modules/40-define-functions/300-parameters/es/data.yml b/modules/40-define-functions/300-parameters/es/data.yml
deleted file mode 100644
index a89a53db..00000000
--- a/modules/40-define-functions/300-parameters/es/data.yml
+++ /dev/null
@@ -1,2 +0,0 @@
----
-name: Parámetros de funciones
diff --git a/modules/40-define-functions/300-parameters/index.php b/modules/40-define-functions/300-parameters/index.php
deleted file mode 100644
index 51588f51..00000000
--- a/modules/40-define-functions/300-parameters/index.php
+++ /dev/null
@@ -1,12 +0,0 @@
-<?php
-
-namespace HexletBasics\DefineFunctions\Parameters;
-
-// BEGIN
-function truncate($str, $length)
-{
-    $cuttedString = substr($str, 0, $length);
-    return "{$cuttedString}...";
-}
-
-// END
diff --git a/modules/40-define-functions/300-parameters/ru/EXERCISE.md b/modules/40-define-functions/300-parameters/ru/EXERCISE.md
deleted file mode 100644
index c574e365..00000000
--- a/modules/40-define-functions/300-parameters/ru/EXERCISE.md
+++ /dev/null
@@ -1,31 +0,0 @@
-Реализуйте функцию `truncate()`, которая обрезает переданную в функцию строку до указанного количества символов, добавляет в конце троеточие и возвращает получившуюся строку. Подобная логика часто используется на сайтах, чтобы отобразить длинный текст в сокращенном виде. Функция принимает два параметра:
-
-1. Строка, которую нужно обрезать
-2. Число символов, которые нужно оставить
-
-```php
-<?php
-
-// Передаём текст напрямую
-// Обрезаем текст, оставляя 2 символа
-truncate('hexlet', 2)  // 'he...'
-
-// Через переменную
-$text = 'it works!'
-// Обрезаем текст, оставляя 4 символа
-$result = truncate($text, 4);
-print_r($result); // => 'it w...'
-```
-
-Реализовать эту функцию можно различными способами, подскажем лишь один из них. Для решения этим способом вам понадобится взять подстроку из строки, переданной первым параметром в функцию `truncate()`. Используйте для этого функцию [substr()](https://www.php.net/manual/ru/function.substr.php). Подумайте, исходя из задания, с какого индекса и какой длины вам надо извлечь подстроку?
-
-  ```php
-  <?php
-
-  $word = 'welcome';
-  // Передавать параметры в функцию можно через переменные
-  $length = 3;
-  substr($word, 0, $length); // 'wel'
-  ```
-
-С точки зрения проверочной системы не имеет значения, каким из способов будет реализована функция `truncate()` внутри, главное – чтобы она выполняла поставленную задачу
diff --git a/modules/40-define-functions/300-parameters/ru/README.md b/modules/40-define-functions/300-parameters/ru/README.md
deleted file mode 100644
index 5d48d4d8..00000000
--- a/modules/40-define-functions/300-parameters/ru/README.md
+++ /dev/null
@@ -1,77 +0,0 @@
-Функции могут не только возвращать значения, но и принимать их в виде параметров. С параметрами функций мы уже сталкивались:
-
-```php
-<?php
-
-// Принимает на вход один параметр любого типа
-print_r('я параметр');
-// Принимает на вход два числовых параметра:
-// Первый — округляемое число
-// Второй — число знаков после запятой, которые нужно оставить
-round(10.1245, 3); // 10.125
-// Принимает на вход три строковых параметра:
-// Первый — что ищем
-// Второй — на что меняем
-// Третий — строка, в которой производим замену
-str_replace('go', 'mo', 'google'); // 'moogle'
-```
-
-В этом уроке мы научимся создавать функции, которые принимают на вход параметры. Представим, что перед нами стоит задача – реализовать функцию `getLastChar()`. Она возвращает последний символ в строке, переданной на вход как параметр. Вот как будет выглядеть использование этой функции:
-
-```php
-<?php
-
-// Передача параметров напрямую без переменных
-getLastChar('Hexlet'); // 't'
-// Передача параметров через переменные
-$name1 = 'Hexlet';
-getLastChar($name1); // 't'
-$name2 = 'Goo';
-getLastChar($name2); // 'o'
-```
-
-Из описания и примеров кода мы можем сделать следующие выводы:
-
-* Нам нужно определить функцию `getLastChar()`
-* Функция должна принимать на вход один параметр строкового типа
-* Функция должна возвращать значение строкового типа
-
-Определение функции:
-
-```php
-<?php
-
-function getLastChar($str)
-{
-    // Вычисляем индекс последнего символа как длина строки - 1
-    return $str[strlen($str) - 1];
-}
-```
-
-Разберем его. В скобках указывается имя параметра (`$str`). Так как внутри функции мы не знаем, с каким конкретно значением идет работа, то параметры всегда описываются как переменные.
-
-Имя параметра может быть любым, оно не связано с тем, как вызывается функция. Главное, чтобы это имя отражало смысл значения, которое содержится внутри. Конкретное значение параметра будет зависеть от вызова этой функции.
-
-Этот параметр является обязательным. Если попробовать вызвать функцию без него, то интерпретатор выдаст ошибку:
-
-```php
-getLastChar(); // такой код не имеет смысла
-```
-
-```text
-ArgumentCountError: Too few arguments to function getLastChar(), 0 passed
-```
-
-Так же можно указывать два, три и более параметров. Они отделяются запятыми:
-
-```php
-<?php
-
-// Функция по нахождению среднего числа
-function average($x, $y)
-{
-    return ($x + $y) / 2;
-}
-average(1, 5); // 3
-average(1, 2); // 1.5
-```
diff --git a/modules/40-define-functions/300-parameters/ru/data.yml b/modules/40-define-functions/300-parameters/ru/data.yml
deleted file mode 100644
index 1dfceb3d..00000000
--- a/modules/40-define-functions/300-parameters/ru/data.yml
+++ /dev/null
@@ -1,2 +0,0 @@
----
-name: Параметры функций
diff --git a/modules/45-logic/29-logical-operators-2/Makefile b/modules/40-define-functions/300-type-annotations/Makefile
similarity index 100%
rename from modules/45-logic/29-logical-operators-2/Makefile
rename to modules/40-define-functions/300-type-annotations/Makefile
diff --git a/modules/40-define-functions/300-type-annotations/Solution.php b/modules/40-define-functions/300-type-annotations/Solution.php
new file mode 100644
index 00000000..269e7836
--- /dev/null
+++ b/modules/40-define-functions/300-type-annotations/Solution.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace HexletBasics\DefineFunctions\TypeAnnotations;
+
+// BEGIN
+function wordMultiply(string $text, int $repetitions): string
+{
+    return str_repeat($text, $repetitions);
+}
+// END
diff --git a/modules/40-define-functions/300-type-annotations/SolutionTest.php b/modules/40-define-functions/300-type-annotations/SolutionTest.php
new file mode 100644
index 00000000..4b7c9323
--- /dev/null
+++ b/modules/40-define-functions/300-type-annotations/SolutionTest.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace HexletBasics\DefineFunctions\TypeAnnotations;
+
+use HexletBasics\Exercise\TestCase;
+
+class SolutionTest extends TestCase
+{
+    public function test()
+    {
+        $reflection = new \ReflectionFunction(__NAMESPACE__ . '\wordMultiply');
+        $parameterTypes = array_map(
+            fn ($parameter) => $parameter->getType()?->getName(),
+            $reflection->getParameters()
+        );
+        $this->assertEquals(['string', 'int'], $parameterTypes, 'You should add type declarations for parameters!');
+        $this->assertEquals('string', $reflection->getReturnType()?->getName(), 'You should add a return type declaration!');
+
+        $this->assertEquals('python', wordMultiply('python', 1));
+        $this->assertEquals('pythonpythonpython', wordMultiply('python', 3));
+        $this->assertEquals('', wordMultiply('java', 0));
+    }
+}
diff --git a/modules/40-define-functions/300-type-annotations/description.es.yml b/modules/40-define-functions/300-type-annotations/description.es.yml
new file mode 100644
index 00000000..2f23b237
--- /dev/null
+++ b/modules/40-define-functions/300-type-annotations/description.es.yml
@@ -0,0 +1,54 @@
+---
+
+name: Declaraciones de tipos
+theory: |
+  PHP admite **declaraciones de tipos** (también conocidas como type hints): puedes indicar los tipos de los parámetros y del valor de retorno de una función. Los tipos de los parámetros se escriben antes del nombre del parámetro, y el tipo de retorno va después de la lista de parámetros, separado por dos puntos:
+
+  ```php
+  <?php
+
+  function add(int $a, int $b): int
+  {
+      return $a + $b;
+  }
+
+  print_r(add(2, 3)); // => 5
+  ```
+
+  A diferencia de muchos lenguajes, PHP comprueba los tipos en tiempo de ejecución. Un valor incompatible provoca un `TypeError`, mientras que los valores compatibles se convierten automáticamente (`add('2', 3)` devuelve `5`).
+
+  En esta etapa, basta con los tipos simples: `int`, `float`, `string`, `bool`. Si una función no devuelve nada, el tipo de retorno es `void`:
+
+  ```php
+  <?php
+
+  function printGreeting(string $name): void
+  {
+      print_r("Hello, {$name}!");
+  }
+  ```
+
+  Las declaraciones de tipos son opcionales, pero hacen el código más claro para las personas, los editores y las herramientas de análisis estático. Usarlas se considera una buena práctica.
+
+instructions: |
+  Implementa la función `wordMultiply()`. Recibe una cadena y un número, y devuelve la cadena repetida esa cantidad de veces. Si se pasa cero, devuelve una cadena vacía:
+
+  ```php
+  <?php
+
+  $text = 'php';
+  print_r(wordMultiply($text, 2)); // => phpphp
+  print_r(wordMultiply($text, 0)); // =>
+  ```
+
+  Añade declaraciones de tipos a la definición de la función.
+
+  ## Pistas
+
+  * No olvides la declaración del tipo de retorno
+  * Usa `str_repeat()` para repetir la cadena
+
+tips:
+  - >
+    [Declaraciones de tipos en la
+    documentación](https://www.php.net/manual/es/language.types.declarations.php)
diff --git a/modules/40-define-functions/300-type-annotations/en/EXERCISE.md b/modules/40-define-functions/300-type-annotations/en/EXERCISE.md
new file mode 100644
index 00000000..529a0350
--- /dev/null
+++ b/modules/40-define-functions/300-type-annotations/en/EXERCISE.md
@@ -0,0 +1,16 @@
+Implement the `wordMultiply()` function. It takes a string and a number, and returns the string repeated that many times. If zero is passed, it returns an empty string:
+
+```php
+<?php
+
+$text = 'php';
+print_r(wordMultiply($text, 2)); // => phpphp
+print_r(wordMultiply($text, 0)); // =>
+```
+
+Add type declarations to the function definition.
+
+## Hints
+
+* Don't forget the return type declaration
+* Use `str_repeat()` to repeat the string
diff --git a/modules/40-define-functions/300-type-annotations/en/README.md b/modules/40-define-functions/300-type-annotations/en/README.md
new file mode 100644
index 00000000..a83f78b0
--- /dev/null
+++ b/modules/40-define-functions/300-type-annotations/en/README.md
@@ -0,0 +1,27 @@
+PHP supports **type declarations** (also known as type hints): you can specify the types of parameters and the return value of a function. Parameter types are written before the parameter name, the return type goes after the parameter list, separated by a colon:
+
+```php
+<?php
+
+function add(int $a, int $b): int
+{
+    return $a + $b;
+}
+
+print_r(add(2, 3)); // => 5
+```
+
+Unlike many languages, PHP checks types at runtime. An incompatible value causes a `TypeError`, while compatible values are coerced automatically (`add('2', 3)` returns `5`).
+
+At this stage, the simple types are enough: `int`, `float`, `string`, `bool`. If a function returns nothing, the return type is `void`:
+
+```php
+<?php
+
+function printGreeting(string $name): void
+{
+    print_r("Hello, {$name}!");
+}
+```
+
+Type declarations are optional, but they make the code clearer for people, editors, and static analysis tools. Using them is considered good practice.
diff --git a/modules/40-define-functions/300-type-annotations/en/data.yml b/modules/40-define-functions/300-type-annotations/en/data.yml
new file mode 100644
index 00000000..3f6c927a
--- /dev/null
+++ b/modules/40-define-functions/300-type-annotations/en/data.yml
@@ -0,0 +1,6 @@
+---
+name: Type declarations
+tips:
+  - >
+    [Type declarations in the
+    documentation](https://www.php.net/manual/en/language.types.declarations.php)
diff --git a/modules/40-define-functions/300-type-annotations/es/EXERCISE.md b/modules/40-define-functions/300-type-annotations/es/EXERCISE.md
new file mode 100644
index 00000000..580515ae
--- /dev/null
+++ b/modules/40-define-functions/300-type-annotations/es/EXERCISE.md
@@ -0,0 +1,16 @@
+Implementa la función `wordMultiply()`. Recibe una cadena y un número, y devuelve la cadena repetida esa cantidad de veces. Si se pasa cero, devuelve una cadena vacía:
+
+```php
+<?php
+
+$text = 'php';
+print_r(wordMultiply($text, 2)); // => phpphp
+print_r(wordMultiply($text, 0)); // =>
+```
+
+Añade declaraciones de tipos a la definición de la función.
+
+## Pistas
+
+* No olvides la declaración del tipo de retorno
+* Usa `str_repeat()` para repetir la cadena
diff --git a/modules/40-define-functions/300-type-annotations/es/README.md b/modules/40-define-functions/300-type-annotations/es/README.md
new file mode 100644
index 00000000..c82bbbb7
--- /dev/null
+++ b/modules/40-define-functions/300-type-annotations/es/README.md
@@ -0,0 +1,27 @@
+PHP admite **declaraciones de tipos** (también conocidas como type hints): puedes indicar los tipos de los parámetros y del valor de retorno de una función. Los tipos de los parámetros se escriben antes del nombre del parámetro, y el tipo de retorno va después de la lista de parámetros, separado por dos puntos:
+
+```php
+<?php
+
+function add(int $a, int $b): int
+{
+    return $a + $b;
+}
+
+print_r(add(2, 3)); // => 5
+```
+
+A diferencia de muchos lenguajes, PHP comprueba los tipos en tiempo de ejecución. Un valor incompatible provoca un `TypeError`, mientras que los valores compatibles se convierten automáticamente (`add('2', 3)` devuelve `5`).
+
+En esta etapa, basta con los tipos simples: `int`, `float`, `string`, `bool`. Si una función no devuelve nada, el tipo de retorno es `void`:
+
+```php
+<?php
+
+function printGreeting(string $name): void
+{
+    print_r("Hello, {$name}!");
+}
+```
+
+Las declaraciones de tipos son opcionales, pero hacen el código más claro para las personas, los editores y las herramientas de análisis estático. Usarlas se considera una buena práctica.
diff --git a/modules/40-define-functions/300-type-annotations/es/data.yml b/modules/40-define-functions/300-type-annotations/es/data.yml
new file mode 100644
index 00000000..ecd01ec6
--- /dev/null
+++ b/modules/40-define-functions/300-type-annotations/es/data.yml
@@ -0,0 +1,6 @@
+---
+name: Declaraciones de tipos
+tips:
+  - >
+    [Declaraciones de tipos en la
+    documentación](https://www.php.net/manual/es/language.types.declarations.php)
diff --git a/modules/40-define-functions/300-type-annotations/ru/EXERCISE.md b/modules/40-define-functions/300-type-annotations/ru/EXERCISE.md
new file mode 100644
index 00000000..3f2aa9e9
--- /dev/null
+++ b/modules/40-define-functions/300-type-annotations/ru/EXERCISE.md
@@ -0,0 +1,21 @@
+Приложение создает текстовые разделители из повторяющихся символов — например, `-------` или `=====`. Реализуйте функцию `wordMultiply()`. Она должна принимать два параметра:
+
+* Строку
+* Число, которое обозначает, сколько раз нужно повторить строку
+
+И возвращает строку, которая повторяется n-раз. Если передается ноль, то возвращается пустая строка.
+
+```php
+<?php
+
+$text = 'php';
+print_r(wordMultiply($text, 2)); // => phpphp
+print_r(wordMultiply($text, 0)); // =>
+```
+
+Укажите объявления типов при определении функции.
+
+## Подсказки
+
+* Не забудьте, что тип также нужно указать и у возвращаемого значения
+* Повторить строку поможет функция `str_repeat()`
diff --git a/modules/40-define-functions/300-type-annotations/ru/README.md b/modules/40-define-functions/300-type-annotations/ru/README.md
new file mode 100644
index 00000000..1382028b
--- /dev/null
+++ b/modules/40-define-functions/300-type-annotations/ru/README.md
@@ -0,0 +1,115 @@
+В PHP в функцию можно передать любые значения. Иногда это усложняет понимание кода: не всегда ясно, что именно ожидает функция и что она возвращает. Чтобы сделать код понятнее, в PHP есть **объявления типов** (их еще называют аннотациями типов или type hints). С их помощью можно явно указать, какие значения принимает функция и какой результат она возвращает. Таким образом мы решаем сразу несколько задач:
+
+- Улучшаем работу редактора кода, получаем подсказки, лучше автодополнение и тому подобное.
+- Помогаем ИИ-агентам быстрее видеть структуру и принимать более правильные решения, минимизируя случайные ошибки.
+- Появляется возможность проверять корректность программы без ее запуска, за счет статической проверки. Такая проверка не гарантирует, что логика программы написана правильно, но, по крайней мере, в ней не будет ошибок типов.
+
+## Как указывать типы параметров
+
+Объявление типов описывает два элемента. Типы параметров указываются прямо в определении функции перед именем каждого параметра. Тип возвращаемого результата указывается после списка параметров через двоеточие.
+
+Разберем на примере функции, которая вычисляет сумму двух переданных значений:
+
+```php
+<?php
+
+function add(int $a, int $b): int
+{
+    return $a + $b;
+}
+
+print_r(add(2, 3)); // => 5
+```
+
+```text
+function concat(string $a, string $b): string
+                │         │            │
+                │         │            └── тип возвращаемого значения
+                │         └── тип параметра $b
+                └── тип параметра $a
+```
+
+Теперь редактор кода будет подсказывать, что функция `add()` принимает два числа и возвращает число. Если попытаться передать неподходящее значение, редактор подсветит это как проблему и предупредит.
+
+Кстати, такие записи вы уже видели. В уроке про необязательные параметры мы разбирали сигнатуру функции `round()` из документации — `round(int|float $num, int $precision = 0): float`. Это и есть объявления типов.
+
+## Типы проверяются при выполнении
+
+В отличие от многих языков, PHP не только подсказывает типы редактору, но и проверяет их во время работы программы. Если передать значение несовместимого типа, программа завершится с ошибкой `TypeError`:
+
+```php
+<?php
+
+add('abc', 3);
+// TypeError: add(): Argument #1 ($a) must be of type int, string given
+```
+
+При этом PHP остается языком со слабой типизацией, и совместимые значения он приводит автоматически. Строка `'2'` выглядит как число, поэтому такой вызов сработает:
+
+```php
+<?php
+
+add('2', 3); // => 5
+```
+
+Это то же самое поведение, которое мы разбирали в уроке про слабую типизацию.
+
+## Какие типы используются в объявлениях
+
+На этом этапе достаточно знать объявления для простых, примитивных типов данных:
+
+- `int` для целых чисел, `float` для чисел с плавающей точкой
+- `string` для строк
+- `bool` для логических значений (true или false)
+
+```php
+<?php
+
+function describe(string $name, int $age, float $height): string
+{
+    return "{$name}, {$age} лет, рост {$height}";
+}
+
+print_r(describe('Anna', 25, 1.70));
+// => Anna, 25 лет, рост 1.7
+```
+
+Если функция ничего не возвращает, то в качестве возвращаемого типа указывается `void`. Например, функция может только печатать текст на экран:
+
+```php
+<?php
+
+function printGreeting(string $name): void
+{
+    print_r("Hello, {$name}!");
+}
+
+printGreeting('Anna');
+// => Hello, Anna!
+```
+
+## Пример с параметрами по умолчанию
+
+Объявления типов работают одинаково как для обязательных параметров, так и для тех, у которых есть значение по умолчанию. Сначала указывается тип, потом имя параметра и через `=` стандартное значение:
+
+```php
+<?php
+
+function greet(string $name, string $greeting = 'Hello'): string
+{
+    return "{$greeting}, {$name}";
+}
+
+print_r(greet('Anna'));         // => Hello, Anna
+print_r(greet('Kirill', 'Hi')); // => Hi, Kirill
+```
+
+В этом примере `$name` является обязательным параметром, а `$greeting` имеет значение по умолчанию. Объявления показывают типы обоих параметров и возвращаемого результата.
+
+## Объявления типов и проверка кода
+
+Кроме проверки во время выполнения, существуют инструменты **статической проверки кода**, то есть проверки, выполняемой без запуска. «Статическая» значит, что проверка происходит еще до запуска программы. Инструмент читает исходный код и сверяет, соответствуют ли переданные значения указанным типам. Например, если функция принимает строку, а вы передадите число, то при статической проверке это будет показано как ошибка.
+
+Особенно удобно, когда такие ошибки подсвечивает редактор прямо во время написания кода. Это позволяет сразу увидеть проблему и исправить ее, не дожидаясь запуска программы. Благодаря этому многие неожиданные ошибки отлавливаются заранее и в работающем коде их становится меньше.
+
+Объявления типов не являются обязательными. Функции можно писать и без них, PHP все равно будет работать. Но когда объявления есть, код становится понятнее для людей и удобнее для редакторов. Указание типов в своем коде считается хорошей практикой.
diff --git a/modules/40-define-functions/300-type-annotations/ru/data.yml b/modules/40-define-functions/300-type-annotations/ru/data.yml
new file mode 100644
index 00000000..b7924f91
--- /dev/null
+++ b/modules/40-define-functions/300-type-annotations/ru/data.yml
@@ -0,0 +1,6 @@
+---
+name: Объявления типов
+tips:
+  - >
+    [Объявления типов в
+    документации](https://www.php.net/manual/ru/language.types.declarations.php)
diff --git a/modules/40-define-functions/340-default-parameters/SolutionTest.php b/modules/40-define-functions/340-default-parameters/SolutionTest.php
deleted file mode 100644
index b776f354..00000000
--- a/modules/40-define-functions/340-default-parameters/SolutionTest.php
+++ /dev/null
@@ -1,21 +0,0 @@
-<?php
-
-namespace HexletBasics\DefineFunctions\DefaultArguments;
-
-use PHPUnit\Framework\TestCase;
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        require 'index.php';
-
-        $expected1 = '****1234';
-        $actual1 = getHiddenCard('1234123412341234');
-        $this->assertEquals($expected1, $actual1);
-
-        $expected2 = '**4321';
-        $actual2 = getHiddenCard('1234123412344321', 2);
-        $this->assertEquals($expected2, $actual2);
-    }
-}
diff --git a/modules/40-define-functions/340-default-parameters/ru/EXERCISE.md b/modules/40-define-functions/340-default-parameters/ru/EXERCISE.md
deleted file mode 100644
index 9b3f1030..00000000
--- a/modules/40-define-functions/340-default-parameters/ru/EXERCISE.md
+++ /dev/null
@@ -1,21 +0,0 @@
-
-Реализуйте функцию `getHiddenCard()`, который принимает на вход номер кредитки (состоящий из 16 цифр) в виде строки и возвращает его скрытую версию, которая может использоваться на сайте для отображения. Если исходная карта имела номер *2034399002125581*,  то скрытая версия выглядит так *\*\*\*\*5581*. Другими словами, функция заменяет первые 12 символов, на звездочки. Количество звездочек регулируется вторым необязательным параметром. Значение по умолчанию — 4.
-
-```php
-<?php
-
-// Кредитка передается внутрь как строка
-getHiddenCard("1234567812345678", 2); // "**5678"
-getHiddenCard("1234567812345678", 3); // "***5678"
-getHiddenCard('1234567812345678'); // "****5678"
-getHiddenCard('2034399002121100', 1); // "*1100"
-```
-
-Для выполнения задания вам понадобится функция [str_repeat()](https://www.php.net/manual/ru/function.str-repeat.php), которая повторяет строку указанное количество раз
-
-```php
-<?php
-
-str_repeat('+', 5); // "+++++"
-str_repeat('o', 3); // "ooo"
-```
diff --git a/modules/40-define-functions/340-default-parameters/ru/README.md b/modules/40-define-functions/340-default-parameters/ru/README.md
deleted file mode 100644
index c14cdf5b..00000000
--- a/modules/40-define-functions/340-default-parameters/ru/README.md
+++ /dev/null
@@ -1,74 +0,0 @@
-В программировании большое количество функций и методов имеют параметры, которые редко меняются. В таких случаях этим параметрам задают значения по умолчанию, которые можно поменять по необходимости. В этом уроке мы узнаем, как задавать значения по умолчанию. С помощью этого можно сократить количество одинакового кода:
-
-```php
-<?php
-
-// Функция возведения в степень
-// Второй параметр имеет значение по умолчанию 2
-function myPow($x, $base = 2)
-{
-    return $x ** $base;
-}
-
-// Три во второй степени (двойка задана по умолчанию)
-myPow(3); // 3 * 3 = 9
-// Три в третьей степени
-myPow(3, 3); // 3 * 3 * 3 = 27
-```
-
-Значение по умолчанию выглядит как обычное присваивание в определении. Оно срабатывает только в том случае, если параметр не передан. К этому нужно привыкнуть.
-
-Значение по умолчанию может быть даже в том случае, когда параметр один:
-
-```php
-<?php
-
-function myPrint($text = 'nothing')
-{
-    print_r($text);
-}
-
-myPrint(); // => "nothing"
-myPrint("Hexlet"); // => "Hexlet"
-```
-
-Параметров со значениями по умолчанию может быть сколько угодно:
-
-```php
-<?php
-
-function f($a = 5, $b = 10, $c = 100)
-{
-  ...
-}
-```
-
-У значений по умолчанию есть одно ограничение. Они должны идти в самом конце списка параметров. С точки зрения синтаксиса невозможно создать функцию, у которой после необязательного параметра идет обязательный:
-
-```php
-<?php
-
-// Такой код завершится с ошибкой
-function f($a = 5, $b = 10, $c = 100, $x)
-{
-  ...
-}
-
-// И такой
-function f($a = 5, $b = 10, $x, $c = 100)
-{
-  ...
-}
-
-// А вот такой сработает
-function f($x, $a = 5, $b = 10, $c = 100)
-{
-  ...
-}
-
-// И такой
-function f($x, $y, $a = 5, $b = 10, $c = 100)
-{
-  ...
-}
-```
diff --git a/modules/45-logic/70-logic-weak-typing/Makefile b/modules/40-define-functions/350-modules/Makefile
similarity index 100%
rename from modules/45-logic/70-logic-weak-typing/Makefile
rename to modules/40-define-functions/350-modules/Makefile
diff --git a/modules/40-define-functions/350-modules/Solution.php b/modules/40-define-functions/350-modules/Solution.php
new file mode 100644
index 00000000..a07898c6
--- /dev/null
+++ b/modules/40-define-functions/350-modules/Solution.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace HexletBasics\DefineFunctions\Modules;
+
+function amountPerPerson(float $total, int $people, int $tipPercent): int
+{
+    // BEGIN
+    $withTip = $total * (1 + $tipPercent / 100);
+    return (int) ceil($withTip / $people);
+    // END
+}
diff --git a/modules/40-define-functions/350-modules/SolutionTest.php b/modules/40-define-functions/350-modules/SolutionTest.php
new file mode 100644
index 00000000..3536fbfd
--- /dev/null
+++ b/modules/40-define-functions/350-modules/SolutionTest.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace HexletBasics\DefineFunctions\Modules;
+
+use HexletBasics\Exercise\TestCase;
+
+class SolutionTest extends TestCase
+{
+    public function test()
+    {
+        $this->assertEquals(75, amountPerPerson(300, 4, 0));
+        $this->assertEquals(90, amountPerPerson(300, 4, 20));
+        $this->assertEquals(129, amountPerPerson(350, 3, 10));
+        $this->assertEquals(34, amountPerPerson(100, 3, 0));
+    }
+}
diff --git a/modules/40-define-functions/350-modules/description.es.yml b/modules/40-define-functions/350-modules/description.es.yml
new file mode 100644
index 00000000..42043eb9
--- /dev/null
+++ b/modules/40-define-functions/350-modules/description.es.yml
@@ -0,0 +1,55 @@
+---
+
+name: Módulos
+theory: |
+  A medida que un programa crece, el código se divide en archivos separados. En PHP, un archivo se conecta con la instrucción `require` — después de eso, todas sus funciones quedan disponibles:
+
+  ```php
+  <?php
+  // Solution.php
+
+  require 'helpers.php';
+
+  sayHi(); // => Hi!
+  ```
+
+  Las pruebas de este curso usan el mismo mecanismo: cargan tu solución con `require 'Solution.php';`.
+
+  `include` se diferencia de `require` en cómo se gestiona un archivo inexistente: `include` emite una advertencia y el programa continúa, mientras que `require` se detiene con un error. `require_once` carga un archivo solo una vez, lo cual es importante para archivos con funciones: volver a declarar una función provoca un error.
+
+  A diferencia de muchos lenguajes, las funciones integradas de PHP están disponibles en todas partes sin necesidad de importar nada. Por ejemplo, `floor()` redondea un número hacia abajo y `ceil()` hacia arriba:
+
+  ```php
+  <?php
+
+  print_r(floor(7.9)); // => 7
+  print_r(ceil(7.1));  // => 8
+  ```
+
+  Para evitar conflictos de nombres, PHP tiene **espacios de nombres** — has visto la línea `namespace HexletBasics\...;` al principio de cada ejercicio. Se estudian en detalle más adelante, en Hexlet.
+
+instructions: |
+  Implementa la función `amountPerPerson()`. Recibe el total de la cuenta de un restaurante, el número de personas y el porcentaje de propina, y devuelve la cantidad que paga cada persona. El resultado se redondea hacia arriba — nadie debe pagar de menos.
+
+  Usa la función integrada `ceil()` para redondear. Está disponible de inmediato — no hay que cargar nada.
+
+  ```php
+  <?php
+
+  // Cuenta 300, 4 personas, propina del 20% — 360 en total, cada uno paga 90
+  print_r(amountPerPerson(300, 4, 20)); // => 90
+
+  // Cuenta 350, 3 personas, propina del 10% — 385 en total, cada uno paga 129
+  print_r(amountPerPerson(350, 3, 10)); // => 129
+  ```
+
+  ## Pista
+
+  * Primero calcula el total con la propina, luego divídelo entre el número de personas y redondea hacia arriba
+  * `ceil()` devuelve un `float`, mientras que la función debe devolver un `int` — la conversión de tipos te ayudará
+
+tips:
+  - |
+    [La instrucción require](https://www.php.net/manual/es/function.require.php)
+  - |
+    [La instrucción include](https://www.php.net/manual/es/function.include.php)
diff --git a/modules/40-define-functions/350-modules/en/EXERCISE.md b/modules/40-define-functions/350-modules/en/EXERCISE.md
new file mode 100644
index 00000000..a300ed2d
--- /dev/null
+++ b/modules/40-define-functions/350-modules/en/EXERCISE.md
@@ -0,0 +1,18 @@
+Implement the `amountPerPerson()` function. It takes a restaurant bill total, the number of people, and a tip percentage, and returns the amount each person pays. The result is rounded up — no one should underpay.
+
+Use the built-in `ceil()` function for rounding. It is available right away — nothing needs to be loaded.
+
+```php
+<?php
+
+// Bill 300, 4 people, 20% tip — 360 in total, everyone pays 90
+print_r(amountPerPerson(300, 4, 20)); // => 90
+
+// Bill 350, 3 people, 10% tip — 385 in total, everyone pays 129
+print_r(amountPerPerson(350, 3, 10)); // => 129
+```
+
+## Hint
+
+* First calculate the total with the tip, then divide it by the number of people and round up
+* `ceil()` returns a `float`, while the function must return an `int` — type casting will help
diff --git a/modules/40-define-functions/350-modules/en/README.md b/modules/40-define-functions/350-modules/en/README.md
new file mode 100644
index 00000000..2b442f61
--- /dev/null
+++ b/modules/40-define-functions/350-modules/en/README.md
@@ -0,0 +1,25 @@
+As a program grows, the code is split into separate files. In PHP, a file is connected with the `require` statement — after that, all functions from it become available:
+
+```php
+<?php
+// Solution.php
+
+require 'helpers.php';
+
+sayHi(); // => Hi!
+```
+
+The tests in this course use the same mechanism: they load your solution with `require 'Solution.php';`.
+
+`include` differs from `require` in how a missing file is handled: `include` emits a warning and the program keeps running, while `require` stops with an error. `require_once` loads a file only once, which matters for files with functions: redeclaring a function causes an error.
+
+Unlike many languages, PHP's built-in functions are available everywhere without any imports. For example, `floor()` rounds a number down, and `ceil()` rounds it up:
+
+```php
+<?php
+
+print_r(floor(7.9)); // => 7
+print_r(ceil(7.1));  // => 8
+```
+
+To deal with name conflicts, PHP has **namespaces** — you have seen the `namespace HexletBasics\...;` line at the beginning of every exercise. They are studied in detail later, at Hexlet.
diff --git a/modules/40-define-functions/350-modules/en/data.yml b/modules/40-define-functions/350-modules/en/data.yml
new file mode 100644
index 00000000..fc8464ad
--- /dev/null
+++ b/modules/40-define-functions/350-modules/en/data.yml
@@ -0,0 +1,7 @@
+---
+name: Modules
+tips:
+  - |
+    [The require statement](https://www.php.net/manual/en/function.require.php)
+  - |
+    [The include statement](https://www.php.net/manual/en/function.include.php)
diff --git a/modules/40-define-functions/350-modules/es/EXERCISE.md b/modules/40-define-functions/350-modules/es/EXERCISE.md
new file mode 100644
index 00000000..7b0552ca
--- /dev/null
+++ b/modules/40-define-functions/350-modules/es/EXERCISE.md
@@ -0,0 +1,18 @@
+Implementa la función `amountPerPerson()`. Recibe el total de la cuenta de un restaurante, el número de personas y el porcentaje de propina, y devuelve la cantidad que paga cada persona. El resultado se redondea hacia arriba — nadie debe pagar de menos.
+
+Usa la función integrada `ceil()` para redondear. Está disponible de inmediato — no hay que cargar nada.
+
+```php
+<?php
+
+// Cuenta 300, 4 personas, propina del 20% — 360 en total, cada uno paga 90
+print_r(amountPerPerson(300, 4, 20)); // => 90
+
+// Cuenta 350, 3 personas, propina del 10% — 385 en total, cada uno paga 129
+print_r(amountPerPerson(350, 3, 10)); // => 129
+```
+
+## Pista
+
+* Primero calcula el total con la propina, luego divídelo entre el número de personas y redondea hacia arriba
+* `ceil()` devuelve un `float`, mientras que la función debe devolver un `int` — la conversión de tipos te ayudará
diff --git a/modules/40-define-functions/350-modules/es/README.md b/modules/40-define-functions/350-modules/es/README.md
new file mode 100644
index 00000000..912c16ea
--- /dev/null
+++ b/modules/40-define-functions/350-modules/es/README.md
@@ -0,0 +1,25 @@
+A medida que un programa crece, el código se divide en archivos separados. En PHP, un archivo se conecta con la instrucción `require` — después de eso, todas sus funciones quedan disponibles:
+
+```php
+<?php
+// Solution.php
+
+require 'helpers.php';
+
+sayHi(); // => Hi!
+```
+
+Las pruebas de este curso usan el mismo mecanismo: cargan tu solución con `require 'Solution.php';`.
+
+`include` se diferencia de `require` en cómo se gestiona un archivo inexistente: `include` emite una advertencia y el programa continúa, mientras que `require` se detiene con un error. `require_once` carga un archivo solo una vez, lo cual es importante para archivos con funciones: volver a declarar una función provoca un error.
+
+A diferencia de muchos lenguajes, las funciones integradas de PHP están disponibles en todas partes sin necesidad de importar nada. Por ejemplo, `floor()` redondea un número hacia abajo y `ceil()` hacia arriba:
+
+```php
+<?php
+
+print_r(floor(7.9)); // => 7
+print_r(ceil(7.1));  // => 8
+```
+
+Para evitar conflictos de nombres, PHP tiene **espacios de nombres** — has visto la línea `namespace HexletBasics\...;` al principio de cada ejercicio. Se estudian en detalle más adelante, en Hexlet.
diff --git a/modules/40-define-functions/350-modules/es/data.yml b/modules/40-define-functions/350-modules/es/data.yml
new file mode 100644
index 00000000..01ba90f1
--- /dev/null
+++ b/modules/40-define-functions/350-modules/es/data.yml
@@ -0,0 +1,7 @@
+---
+name: Módulos
+tips:
+  - |
+    [La instrucción require](https://www.php.net/manual/es/function.require.php)
+  - |
+    [La instrucción include](https://www.php.net/manual/es/function.include.php)
diff --git a/modules/40-define-functions/350-modules/ru/EXERCISE.md b/modules/40-define-functions/350-modules/ru/EXERCISE.md
new file mode 100644
index 00000000..12b8b6c9
--- /dev/null
+++ b/modules/40-define-functions/350-modules/ru/EXERCISE.md
@@ -0,0 +1,18 @@
+Реализуйте функцию `amountPerPerson()`. Она принимает сумму счета в ресторане, количество человек и процент чаевых, а возвращает сумму, которую платит каждый. Итог округляется вверх — никто не должен недоплачивать.
+
+Для округления используйте встроенную функцию `ceil()`. Она доступна сразу — подключать ничего не нужно.
+
+```php
+<?php
+
+// Счет 300, 4 человека, чаевые 20% — итого 360, каждый платит 90
+print_r(amountPerPerson(300, 4, 20)); // => 90
+
+// Счет 350, 3 человека, чаевые 10% — итого 385, каждый платит 129
+print_r(amountPerPerson(350, 3, 10)); // => 129
+```
+
+## Подсказка
+
+* Сначала посчитайте итоговую сумму с чаевыми, затем разделите на количество человек и округлите вверх
+* `ceil()` возвращает число типа `float`, а функция должна вернуть `int` — пригодится приведение типов
diff --git a/modules/40-define-functions/350-modules/ru/README.md b/modules/40-define-functions/350-modules/ru/README.md
new file mode 100644
index 00000000..2cc9b068
--- /dev/null
+++ b/modules/40-define-functions/350-modules/ru/README.md
@@ -0,0 +1,88 @@
+Пока программа маленькая, весь код можно хранить в одном файле. Такой подход удобен для простых примеров и небольших задач. Но со временем программа начинает расти. Когда кода становится много, ориентироваться в одном файле становится сложно. Между тем реальные приложения состоят из десятков тысяч строк (как минимум) и сотен файлов.
+
+Чтобы разделить программу на отдельные логические части, код раскладывают по файлам. Во многих языках такие файлы называются модулями. В PHP модуль — это обычный файл с кодом и расширением `.php`. А язык предоставляет механизм для обращения к функциям и константам из других файлов — подключение файлов.
+
+## Как подключить файл
+
+Инструкция `require` подключает указанный файл и делает его содержимое доступным:
+
+```php
+<?php
+// helpers.php
+
+function sayHi(): void
+{
+    print_r('Hi!');
+}
+```
+
+```php
+<?php
+// Solution.php
+
+require 'helpers.php';
+
+sayHi(); // => Hi!
+```
+
+После подключения все функции из файла `helpers.php` доступны так, как будто они были определены прямо в текущем файле.
+
+Кстати, вы уже видели этот механизм в действии. Автоматизированные тесты в этом курсе подключают файл с вашим решением строкой `require 'Solution.php';` — и после этого могут вызывать функции, которые вы определили.
+
+## require, include и require_once
+
+У `require` есть близнец — инструкция `include`. Разница проявляется, когда подключаемый файл не найден: `include` выведет предупреждение, и программа продолжит работу, а `require` остановит выполнение с ошибкой. Если без подключаемого кода программа не имеет смысла, используют `require`.
+
+Есть и третий вариант — `require_once`. Он подключает файл только один раз, даже если инструкция встречается в программе многократно. Это важно для файлов с функциями: повторное определение функции с тем же именем приводит к ошибке.
+
+## Встроенные функции доступны без подключения
+
+Стандартная библиотека PHP устроена проще, чем во многих других языках: встроенные функции доступны в любом месте программы сразу, без какого-либо подключения. Например, функции округления: `floor()` округляет число вниз до ближайшего целого, `ceil()` округляет вверх:
+
+```php
+<?php
+
+print_r(floor(7.9)); // => 7
+print_r(ceil(7.1));  // => 8
+print_r(ceil(7.0));  // => 7
+```
+
+Разница заметна, когда число не целое. `floor(7.9)` дает 7, а не 8, потому что 7 — ближайшее целое снизу.
+
+Встроенные функции, конечно, доступны и в теле своих функций:
+
+```php
+<?php
+
+// Вычисляет количество поездок, необходимых для перевозки всех предметов
+function tripsNeeded(int $items, int $capacity): int
+{
+    return (int) ceil($items / $capacity);
+}
+
+print_r(tripsNeeded(10, 3)); // => 4
+```
+
+Обратите внимание: `ceil()` возвращает число типа `float`, поэтому результат приводится к `int` — так, как мы делали в уроке про преобразование типов.
+
+## Конфликты имен
+
+В больших программах разные части кода могут содержать функции с одинаковыми названиями. В PHP нельзя определить две функции с одним именем в одном пространстве — программа завершится с ошибкой `Cannot redeclare function`.
+
+Для борьбы с конфликтами имен в PHP существуют **пространства имен** (namespaces). Вы видели их в начале каждого задания этого курса — строка `namespace HexletBasics\...;` как раз объявляет пространство имен. Благодаря им мы можем создавать сколько угодно функций с одинаковыми именами, главное чтобы они находились в разных пространствах. Это работает даже со встроенными функциями:
+
+```php
+<?php
+
+namespace App\Custom;
+
+function floor(float $number): string
+{
+    return 'custom floor';
+}
+
+print_r(floor(3.7));  // => custom floor
+print_r(\floor(3.7)); // => 3
+```
+
+Внутри пространства `App\Custom` имя `floor` ссылается на нашу функцию. Встроенная функция при этом никуда не делась — она доступна по полному имени `\floor()`, где обратный слеш означает глобальное пространство. Это особенно важно при использовании сторонних библиотек, потому что разные разработчики могут выбирать одинаковые имена для функций. Подробно пространства имен изучаются дальше, на Хекслете.
diff --git a/modules/40-define-functions/350-modules/ru/data.yml b/modules/40-define-functions/350-modules/ru/data.yml
new file mode 100644
index 00000000..88b35ae1
--- /dev/null
+++ b/modules/40-define-functions/350-modules/ru/data.yml
@@ -0,0 +1,7 @@
+---
+name: Модули
+tips:
+  - |
+    [Инструкция require](https://www.php.net/manual/ru/function.require.php)
+  - |
+    [Инструкция include](https://www.php.net/manual/ru/function.include.php)
diff --git a/modules/50-loops/26-conditions-inside-loops/Makefile b/modules/40-define-functions/400-packages/Makefile
similarity index 100%
rename from modules/50-loops/26-conditions-inside-loops/Makefile
rename to modules/40-define-functions/400-packages/Makefile
diff --git a/modules/40-define-functions/400-packages/Solution.php b/modules/40-define-functions/400-packages/Solution.php
new file mode 100644
index 00000000..5bde319b
--- /dev/null
+++ b/modules/40-define-functions/400-packages/Solution.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace HexletBasics\DefineFunctions\Packages;
+
+// BEGIN
+function generatePin(): string
+{
+    $d1 = rand(0, 9);
+    $d2 = rand(0, 9);
+    $d3 = rand(0, 9);
+    $d4 = rand(0, 9);
+    return "{$d1}{$d2}{$d3}{$d4}";
+}
+// END
diff --git a/modules/40-define-functions/400-packages/SolutionTest.php b/modules/40-define-functions/400-packages/SolutionTest.php
new file mode 100644
index 00000000..1d7c817c
--- /dev/null
+++ b/modules/40-define-functions/400-packages/SolutionTest.php
@@ -0,0 +1,25 @@
+<?php
+
+namespace HexletBasics\DefineFunctions\Packages;
+
+use HexletBasics\Exercise\TestCase;
+
+class SolutionTest extends TestCase
+{
+    public function test()
+    {
+        $reflection = new \ReflectionFunction(__NAMESPACE__ . '\generatePin');
+        $this->assertEquals('string', $reflection->getReturnType()?->getName(), 'You should add a return type declaration!');
+
+        foreach ([1, 7, 42] as $seed) {
+            srand($seed);
+            $result = generatePin();
+
+            srand($seed);
+            $expected = sprintf('%d%d%d%d', rand(0, 9), rand(0, 9), rand(0, 9), rand(0, 9));
+
+            $this->assertSame($expected, $result);
+            $this->assertSame(4, strlen($result));
+        }
+    }
+}
diff --git a/modules/40-define-functions/400-packages/description.es.yml b/modules/40-define-functions/400-packages/description.es.yml
new file mode 100644
index 00000000..25c814b6
--- /dev/null
+++ b/modules/40-define-functions/400-packages/description.es.yml
@@ -0,0 +1,49 @@
+---
+
+name: Paquetes
+theory: |
+  En el ecosistema PHP, la unidad de reutilización y distribución de código es el **paquete** (paquete de Composer). Los paquetes se gestionan con **Composer**, el gestor de paquetes de PHP. Un proyecto describe sus dependencias en el archivo `composer.json`:
+
+  ```json
+  {
+      "name": "hexlet-basics/exercises-php",
+      "require": {
+          "php": "^8.4",
+          "nesbot/carbon": "^3.0"
+      }
+  }
+  ```
+
+  El nombre de un paquete consta de dos partes separadas por una barra: el nombre del editor (vendor) y el nombre del propio paquete, por ejemplo `nesbot/carbon`. El comando `composer install` descarga los paquetes en el directorio `vendor/`. Una sola línea los hace disponibles todos — este mecanismo se llama autocarga (autoloading):
+
+  ```php
+  <?php
+
+  require __DIR__ . '/vendor/autoload.php';
+  ```
+
+  La fuente principal de paquetes es el registro [Packagist](https://packagist.org/), con cientos de miles de paquetes listos para usar. Por ejemplo, PHPUnit, que comprueba tus soluciones en este curso, también es un paquete de Composer. Las funciones integradas como `strlen()` o `rand()` no necesitan instalación — vienen con el propio lenguaje.
+
+instructions: |
+  Implementa la función `generatePin()`. Devuelve un código PIN aleatorio de cuatro dígitos en forma de cadena.
+
+  Cada dígito del código PIN es un número entero aleatorio independiente de 0 a 9.
+
+  ```php
+  <?php
+
+  print_r(generatePin()); // => por ejemplo, "4823" o "0571"
+  print_r(generatePin()); // => por ejemplo, "1942" o "0037"
+  ```
+
+  Añade la declaración del tipo de retorno.
+
+  ## Pista
+
+  Genera cada uno de los cuatro dígitos con `rand(0, 9)` y construye la cadena usando interpolación.
+
+tips:
+  - |
+    [Composer](https://getcomposer.org/)
+  - |
+    [El registro de paquetes Packagist](https://packagist.org/)
diff --git a/modules/40-define-functions/400-packages/en/EXERCISE.md b/modules/40-define-functions/400-packages/en/EXERCISE.md
new file mode 100644
index 00000000..f04beba6
--- /dev/null
+++ b/modules/40-define-functions/400-packages/en/EXERCISE.md
@@ -0,0 +1,16 @@
+Implement the `generatePin()` function. It returns a random four-digit PIN code as a string.
+
+Each digit of the PIN code is an independent random integer from 0 to 9.
+
+```php
+<?php
+
+print_r(generatePin()); // => e.g. "4823" or "0571"
+print_r(generatePin()); // => e.g. "1942" or "0037"
+```
+
+Add a return type declaration.
+
+## Hint
+
+Generate each of the four digits with `rand(0, 9)` and build the string using interpolation.
diff --git a/modules/40-define-functions/400-packages/en/README.md b/modules/40-define-functions/400-packages/en/README.md
new file mode 100644
index 00000000..684b4640
--- /dev/null
+++ b/modules/40-define-functions/400-packages/en/README.md
@@ -0,0 +1,21 @@
+In the PHP ecosystem, the unit of code reuse and distribution is a **package** (a Composer package). Packages are managed by **Composer** — the PHP package manager. A project describes its dependencies in the `composer.json` file:
+
+```json
+{
+    "name": "hexlet-basics/exercises-php",
+    "require": {
+        "php": "^8.4",
+        "nesbot/carbon": "^3.0"
+    }
+}
+```
+
+A package name consists of two parts separated by a slash: the vendor name and the package name itself, e.g. `nesbot/carbon`. The `composer install` command downloads the packages into the `vendor/` directory. A single line makes all of them available — this mechanism is called autoloading:
+
+```php
+<?php
+
+require __DIR__ . '/vendor/autoload.php';
+```
+
+The main source of packages is the [Packagist](https://packagist.org/) registry with hundreds of thousands of ready-made packages. For example, PHPUnit, which checks your solutions in this course, is a Composer package too. Built-in functions like `strlen()` or `rand()` need no installation — they ship with the language itself.
diff --git a/modules/40-define-functions/400-packages/en/data.yml b/modules/40-define-functions/400-packages/en/data.yml
new file mode 100644
index 00000000..749c1546
--- /dev/null
+++ b/modules/40-define-functions/400-packages/en/data.yml
@@ -0,0 +1,7 @@
+---
+name: Packages
+tips:
+  - |
+    [Composer](https://getcomposer.org/)
+  - |
+    [The Packagist package registry](https://packagist.org/)
diff --git a/modules/40-define-functions/400-packages/es/EXERCISE.md b/modules/40-define-functions/400-packages/es/EXERCISE.md
new file mode 100644
index 00000000..435e5c20
--- /dev/null
+++ b/modules/40-define-functions/400-packages/es/EXERCISE.md
@@ -0,0 +1,16 @@
+Implementa la función `generatePin()`. Devuelve un código PIN aleatorio de cuatro dígitos en forma de cadena.
+
+Cada dígito del código PIN es un número entero aleatorio independiente de 0 a 9.
+
+```php
+<?php
+
+print_r(generatePin()); // => por ejemplo, "4823" o "0571"
+print_r(generatePin()); // => por ejemplo, "1942" o "0037"
+```
+
+Añade la declaración del tipo de retorno.
+
+## Pista
+
+Genera cada uno de los cuatro dígitos con `rand(0, 9)` y construye la cadena usando interpolación.
diff --git a/modules/40-define-functions/400-packages/es/README.md b/modules/40-define-functions/400-packages/es/README.md
new file mode 100644
index 00000000..88606da7
--- /dev/null
+++ b/modules/40-define-functions/400-packages/es/README.md
@@ -0,0 +1,21 @@
+En el ecosistema PHP, la unidad de reutilización y distribución de código es el **paquete** (paquete de Composer). Los paquetes se gestionan con **Composer**, el gestor de paquetes de PHP. Un proyecto describe sus dependencias en el archivo `composer.json`:
+
+```json
+{
+    "name": "hexlet-basics/exercises-php",
+    "require": {
+        "php": "^8.4",
+        "nesbot/carbon": "^3.0"
+    }
+}
+```
+
+El nombre de un paquete consta de dos partes separadas por una barra: el nombre del editor (vendor) y el nombre del propio paquete, por ejemplo `nesbot/carbon`. El comando `composer install` descarga los paquetes en el directorio `vendor/`. Una sola línea los hace disponibles todos — este mecanismo se llama autocarga (autoloading):
+
+```php
+<?php
+
+require __DIR__ . '/vendor/autoload.php';
+```
+
+La fuente principal de paquetes es el registro [Packagist](https://packagist.org/), con cientos de miles de paquetes listos para usar. Por ejemplo, PHPUnit, que comprueba tus soluciones en este curso, también es un paquete de Composer. Las funciones integradas como `strlen()` o `rand()` no necesitan instalación — vienen con el propio lenguaje.
diff --git a/modules/40-define-functions/400-packages/es/data.yml b/modules/40-define-functions/400-packages/es/data.yml
new file mode 100644
index 00000000..1d2f89d9
--- /dev/null
+++ b/modules/40-define-functions/400-packages/es/data.yml
@@ -0,0 +1,7 @@
+---
+name: Paquetes
+tips:
+  - |
+    [Composer](https://getcomposer.org/)
+  - |
+    [El registro de paquetes Packagist](https://packagist.org/)
diff --git a/modules/40-define-functions/400-packages/ru/EXERCISE.md b/modules/40-define-functions/400-packages/ru/EXERCISE.md
new file mode 100644
index 00000000..54415fcc
--- /dev/null
+++ b/modules/40-define-functions/400-packages/ru/EXERCISE.md
@@ -0,0 +1,16 @@
+Реализуйте функцию `generatePin()`. Она возвращает случайный четырехзначный PIN-код в виде строки.
+
+Каждый разряд PIN-кода — независимое случайное целое число от 0 до 9.
+
+```php
+<?php
+
+print_r(generatePin()); // => например, "4823" или "0571"
+print_r(generatePin()); // => например, "1942" или "0037"
+```
+
+Укажите объявление типа возвращаемого значения.
+
+## Подсказка
+
+Сгенерируйте каждую из четырех цифр через `rand(0, 9)` и соберите строку через интерполяцию.
diff --git a/modules/40-define-functions/400-packages/ru/README.md b/modules/40-define-functions/400-packages/ru/README.md
new file mode 100644
index 00000000..48f53f4a
--- /dev/null
+++ b/modules/40-define-functions/400-packages/ru/README.md
@@ -0,0 +1,48 @@
+По мере роста программы увеличивается не только количество строк кода, но и количество файлов. Кроме того, удобный код хочется переиспользовать в разных проектах, а не копировать из одного в другой.
+
+В Python для группировки модулей используют пакеты-директории. В экосистеме PHP единицей переиспользования и распространения служит **пакет** (Composer-пакет). Пакет — это набор PHP-файлов с функциями и классами, который публикуют и устанавливают целиком.
+
+## Composer
+
+Пакетами управляет **Composer** — менеджер пакетов PHP. Проект описывает свои зависимости в файле `composer.json`:
+
+```json
+{
+    "name": "hexlet-basics/exercises-php",
+    "require": {
+        "php": "^8.4",
+        "nesbot/carbon": "^3.0"
+    }
+}
+```
+
+Команда `composer install` скачивает все перечисленные пакеты и складывает их в директорию `vendor/`. Добавить новый пакет можно командой `composer require`, например:
+
+```bash
+composer require nesbot/carbon
+```
+
+## Имя пакета
+
+Имя пакета состоит из двух частей, разделенных слешем: `nesbot/carbon`. Первая часть — имя издателя (vendor), вторая — имя самого пакета. Такая схема решает конфликты имен: разные разработчики могут опубликовать пакеты с одинаковым названием, и они не будут мешать друг другу — точно так же, как пространства имен позволяют существовать одинаковым функциям.
+
+## Автозагрузка
+
+Установленные пакеты попадают в директорию `vendor/`, но подключать каждый файл вручную через `require` не нужно. Composer генерирует специальный файл-автозагрузчик, и одной строки достаточно, чтобы стали доступны все установленные пакеты:
+
+```php
+<?php
+
+require __DIR__ . '/vendor/autoload.php';
+
+// Дальше можно использовать функции и классы
+// из любого установленного пакета
+```
+
+Этот механизм называется автозагрузкой (autoloading). Именно так устроены реальные PHP-проекты: в начале программы подключается автозагрузчик, а дальше код просто использует то, что нужно.
+
+## Реестр Packagist
+
+Пакеты не пишут с нуля под каждую задачу — основным источником служит реестр [Packagist](https://packagist.org/), где опубликованы сотни тысяч готовых пакетов: для работы с датами, сетью, тестами и почти любой другой задачей. Например, PHPUnit, который проверяет ваши решения в этом курсе, — тоже Composer-пакет.
+
+Особняком стоит стандартная библиотека PHP. Встроенные функции, такие как `strlen()`, `round()` или `rand()`, не нужно устанавливать — они поставляются вместе с самим языком и доступны сразу, без Composer и автозагрузки.
diff --git a/modules/40-define-functions/400-packages/ru/data.yml b/modules/40-define-functions/400-packages/ru/data.yml
new file mode 100644
index 00000000..9543c83d
--- /dev/null
+++ b/modules/40-define-functions/400-packages/ru/data.yml
@@ -0,0 +1,7 @@
+---
+name: Пакеты
+tips:
+  - |
+    [Composer](https://getcomposer.org/)
+  - |
+    [Реестр пакетов Packagist](https://packagist.org/)
diff --git a/modules/40-define-functions/500-reading-documentation/SolutionTest.php b/modules/40-define-functions/500-reading-documentation/SolutionTest.php
deleted file mode 100644
index 4b6720a8..00000000
--- a/modules/40-define-functions/500-reading-documentation/SolutionTest.php
+++ /dev/null
@@ -1,18 +0,0 @@
-<?php
-
-namespace HexletBasics\DefineFunctions\ReadingDocumentation;
-
-use PHPUnit\Framework\TestCase;
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        require 'index.php';
-
-        $this->assertEquals(10.0, getAge(10));
-        $this->assertEquals(9.0, getAge(9.1));
-        $this->assertEquals(8.0, getAge(8.9));
-        $this->assertEquals(8.0, getAge(8.5));
-    }
-}
diff --git a/modules/40-define-functions/500-reading-documentation/description.es.yml b/modules/40-define-functions/500-reading-documentation/description.es.yml
deleted file mode 100644
index efabd3db..00000000
--- a/modules/40-define-functions/500-reading-documentation/description.es.yml
+++ /dev/null
@@ -1,54 +0,0 @@
----
-
-name: Lectura de la documentación
-theory: |
-
-  Saber leer la documentación es una de las habilidades más importantes para cualquier desarrollador.
-
-  _A pesar de que existe una traducción, recomiendo aprender a utilizar la documentación en inglés. Las bibliotecas que se utilizan en cientos de proyectos reales casi siempre tienen solo descripciones en inglés._
-
-  La sección principal a la que los programadores vuelven constantemente es el manual de funciones del lenguaje. En primer lugar, hay muchas funciones y es imposible recordar todo. En segundo lugar, en PHP el problema de la inconsistencia de los parámetros y los valores de retorno de las funciones es especialmente agudo. Por lo tanto, constantemente hay que recordar su orden.
-
-  Para describir las funciones se utiliza una notación propia (su propia sintaxis). Se parece un poco a PHP, pero aún así es diferente, en otras palabras, no es código PHP, sino solo una descripción de la firma de la función. Veamos la función `round()`, que redondea un número:
-
-  ```
-  round(int|float $num, int $precision = 0, int $mode = PHP_ROUND_HALF_UP): float
-  ```
-
-  El propósito de este formato es mostrar de manera visual los tipos, la cantidad y los valores predeterminados de los parámetros de entrada, así como el tipo del parámetro de salida. Este último siempre se encuentra en la posición más a la derecha, justo después de los dos puntos. En este caso, el tipo de valor de retorno es `float`.
-
-  La enumeración de los parámetros se realiza separándolos por comas entre paréntesis después del nombre de la función. Antes de cada nombre de parámetro se encuentra su tipo. Por ejemplo, el tipo del parámetro `$num` es `float`. El valor predeterminado se establece mediante una asignación, por ejemplo, `$precision` tiene un valor predeterminado de cero.
-
-  Los parámetros con valores predeterminados son parámetros opcionales de la función, y se separan por comas entre sí. Para la función anterior, estos son `$precision` y `$mode`. `$mode`, a su vez, tiene un valor predeterminado igual al valor de la constante `PHP_ROUND_HALF_UP`. Si algún parámetro tiene un valor igual al valor de una constante, significa que en la documentación de esta función hay una enumeración y descripción de todas las constantes posibles que se pueden utilizar como valor de este parámetro.
-
-  Basándonos en lo dicho anteriormente, podemos llamar a la función de la siguiente manera:
-
-  ```php
-  <?php
-
-  round(5.3); // 5.0
-  round(8.333, 1); // 8.3
-  round(8.333, 2, PHP_ROUND_HALF_UP); // 8.33
-  ```
-
-instructions: |
-
-  Implementa la función `getAge()`, que redondea la edad hacia abajo. Es decir, si una persona tiene diez años y medio, la función debe devolver `10`.
-
-  Utiliza la función estándar `floor()`, que redondea un número hacia abajo.
-
-  ```php
-  <?php
-
-  getAge(10);  // 10.0
-  getAge(9.1); // 9.0
-  getAge(8.9); // 8.0
-  ```
-
-tips:
-  - |
-    [Documentación de PHP en español](https://php.net/manual/es/)
-  - |
-    [Manual de funciones](https://php.net/manual/es/funcref.php)
-  - |
-    [Función floor()](https://www.php.net/manual/es/function.floor.php)
diff --git a/modules/40-define-functions/500-reading-documentation/en/EXERCISE.md b/modules/40-define-functions/500-reading-documentation/en/EXERCISE.md
deleted file mode 100644
index 0265c670..00000000
--- a/modules/40-define-functions/500-reading-documentation/en/EXERCISE.md
+++ /dev/null
@@ -1,12 +0,0 @@
-
-Implement a function called `getAge()`, which rounds down someone's age. That is, if a person is ten and a half years old, the function should return `10`.
-
-Use the standard `floor()` function, which rounds down the number.
-
-```php
-<?php
-
-getAge(10);  // 10.0
-getAge(9.1); // 9.0
-getAge(8.9); // 8.0
-```
diff --git a/modules/40-define-functions/500-reading-documentation/en/README.md b/modules/40-define-functions/500-reading-documentation/en/README.md
deleted file mode 100644
index 7985a11a..00000000
--- a/modules/40-define-functions/500-reading-documentation/en/README.md
+++ /dev/null
@@ -1,25 +0,0 @@
-Reading documentation is one of the most important skills for any developer.
-
-The main section that programmers come back to all the time is the list of functions in the language. First, there are many of these functions and it's impossible to remember them all. Second, in PHP especially, there's a problem with inconsistency of parameters and function return values. So you constantly have to remember their order.
-
-It uses its own syntax to describe functions. It looks a bit like PHP itself, but it's different, in other words, it's not PHP code, only a description of a function signature. Consider the `round()` function, which rounds a number:
-
-```php
-round ( float $val [, int $precision = 0 [, int $mode = PHP_ROUND_HALF_UP ]] ) : float
-```
-
-The purpose of this format is to show the types, numbers, and default values of the input parameters, as well as the type of the output parameter. The last one is always in the rightmost position, right after the colon. In this case, the return value type is `float`.
-
-The parameters are listed in parentheses after the function name, and separated by commas. Each parameter name is preceded by its type. For example, the `$val` parameter is a `float` parameter. The default value is set by assignment, e.g. `$precision` defaults to zero.
-
-Square brackets _[]_ show optional function parameters, and they're also separated by commas. For the function above, these are `$precision` and `$mode`. `$mode`, in turn, defaults to the value of the `PHP_ROUND_HALF_UP` constant. If any parameter is equal to the value of a  constant, then the documentation for that function lists and describes all possible constants that can be used as the value of that parameter
-
-Based on the above, we can call the function as follows:
-
-```php
-<?php
-
-round(5.3); // 5.0
-round(8.333, 1); // 8.3
-round(8.333, 2, PHP_ROUND_HALF_UP); // 8.33
-```
diff --git a/modules/40-define-functions/500-reading-documentation/en/data.yml b/modules/40-define-functions/500-reading-documentation/en/data.yml
deleted file mode 100644
index 5456bf8a..00000000
--- a/modules/40-define-functions/500-reading-documentation/en/data.yml
+++ /dev/null
@@ -1,7 +0,0 @@
----
-name: Reading documentation
-tips:
-  - |
-    [Function directory](https://www.php.net/manual/en/funcref.php)
-  - |
-    [floor() function](https://www.php.net/manual/en/function.floor.php)
diff --git a/modules/40-define-functions/500-reading-documentation/es/EXERCISE.md b/modules/40-define-functions/500-reading-documentation/es/EXERCISE.md
deleted file mode 100644
index 4777afee..00000000
--- a/modules/40-define-functions/500-reading-documentation/es/EXERCISE.md
+++ /dev/null
@@ -1,12 +0,0 @@
-
-Implementa la función `getAge()`, que redondea la edad hacia abajo. Es decir, si una persona tiene diez años y medio, la función debe devolver `10`.
-
-Utiliza la función estándar `floor()`, que redondea un número hacia abajo.
-
-```php
-<?php
-
-getAge(10);  // 10.0
-getAge(9.1); // 9.0
-getAge(8.9); // 8.0
-```
diff --git a/modules/40-define-functions/500-reading-documentation/es/README.md b/modules/40-define-functions/500-reading-documentation/es/README.md
deleted file mode 100644
index 48e892a4..00000000
--- a/modules/40-define-functions/500-reading-documentation/es/README.md
+++ /dev/null
@@ -1,28 +0,0 @@
-
-Saber leer la documentación es una de las habilidades más importantes para cualquier desarrollador.
-
-_A pesar de que existe una traducción, recomiendo aprender a utilizar la documentación en inglés. Las bibliotecas que se utilizan en cientos de proyectos reales casi siempre tienen solo descripciones en inglés._
-
-La sección principal a la que los programadores vuelven constantemente es el manual de funciones del lenguaje. En primer lugar, hay muchas funciones y es imposible recordar todo. En segundo lugar, en PHP el problema de la inconsistencia de los parámetros y los valores de retorno de las funciones es especialmente agudo. Por lo tanto, constantemente hay que recordar su orden.
-
-Para describir las funciones se utiliza una notación propia (su propia sintaxis). Se parece un poco a PHP, pero aún así es diferente, en otras palabras, no es código PHP, sino solo una descripción de la firma de la función. Veamos la función `round()`, que redondea un número:
-
-```php
-round(int|float $num, int $precision = 0, int $mode = PHP_ROUND_HALF_UP): float
-```
-
-El propósito de este formato es mostrar de manera visual los tipos, la cantidad y los valores predeterminados de los parámetros de entrada, así como el tipo del parámetro de salida. Este último siempre se encuentra en la posición más a la derecha, justo después de los dos puntos. En este caso, el tipo de valor de retorno es `float`.
-
-La enumeración de los parámetros se realiza separándolos por comas entre paréntesis después del nombre de la función. Antes de cada nombre de parámetro se encuentra su tipo. Por ejemplo, el tipo del parámetro `$num` es `float`. El valor predeterminado se establece mediante una asignación, por ejemplo, `$precision` tiene un valor predeterminado de cero.
-
-Los parámetros con valores predeterminados son parámetros opcionales de la función, y se separan por comas entre sí. Para la función anterior, estos son `$precision` y `$mode`. `$mode`, a su vez, tiene un valor predeterminado igual al valor de la constante `PHP_ROUND_HALF_UP`. Si algún parámetro tiene un valor igual al valor de una constante, significa que en la documentación de esta función hay una enumeración y descripción de todas las constantes posibles que se pueden utilizar como valor de este parámetro.
-
-Basándonos en lo dicho anteriormente, podemos llamar a la función de la siguiente manera:
-
-```php
-<?php
-
-round(5.3); // 5.0
-round(8.333, 1); // 8.3
-round(8.333, 2, PHP_ROUND_HALF_UP); // 8.33
-```
diff --git a/modules/40-define-functions/500-reading-documentation/es/data.yml b/modules/40-define-functions/500-reading-documentation/es/data.yml
deleted file mode 100644
index 336e07ae..00000000
--- a/modules/40-define-functions/500-reading-documentation/es/data.yml
+++ /dev/null
@@ -1,9 +0,0 @@
----
-name: Lectura de la documentación
-tips:
-  - |
-    [Documentación de PHP en español](https://php.net/manual/es/)
-  - |
-    [Manual de funciones](https://php.net/manual/es/funcref.php)
-  - |
-    [Función floor()](https://www.php.net/manual/es/function.floor.php)
diff --git a/modules/40-define-functions/500-reading-documentation/index.php b/modules/40-define-functions/500-reading-documentation/index.php
deleted file mode 100644
index 38d2a601..00000000
--- a/modules/40-define-functions/500-reading-documentation/index.php
+++ /dev/null
@@ -1,10 +0,0 @@
-<?php
-
-namespace HexletBasics\DefineFunctions\ReadingDocumentation;
-
-// BEGIN
-function getAge($val)
-{
-    return floor($val);
-}
-// END
diff --git a/modules/40-define-functions/500-reading-documentation/ru/EXERCISE.md b/modules/40-define-functions/500-reading-documentation/ru/EXERCISE.md
deleted file mode 100644
index 578eded9..00000000
--- a/modules/40-define-functions/500-reading-documentation/ru/EXERCISE.md
+++ /dev/null
@@ -1,12 +0,0 @@
-
-Реализуйте функцию `getAge()`, которая округляет возраст в нижнюю сторону. То есть если человеку десять с половиной лет, то функция должна вернуть `10`.
-
-Используйте для этого стандартную функцию `floor()`, которая округляет число в меньшую сторону.
-
-```php
-<?php
-
-getAge(10);  // 10.0
-getAge(9.1); // 9.0
-getAge(8.9); // 8.0
-```
diff --git a/modules/40-define-functions/500-reading-documentation/ru/README.md b/modules/40-define-functions/500-reading-documentation/ru/README.md
deleted file mode 100644
index a8f4d90f..00000000
--- a/modules/40-define-functions/500-reading-documentation/ru/README.md
+++ /dev/null
@@ -1,28 +0,0 @@
-
-Умение читать документацию — один из важнейших навыков любого разработчика.
-
-_Несмотря на наличие перевода, я рекомендую учиться пользоваться англоязычной документацией. Библиотеки, которые сотнями используются в реальных проектах, почти всегда имеют только англоязычное описание._
-
-Основной раздел, к которому программисты возвращаются постоянно — справочник функций языка. Во-первых, этих функций много и невозможно запомнить всё. Во-вторых, в PHP особенно остро стоит проблема несогласованности параметров и возвращаемых значений функций. Поэтому постоянно приходится вспоминать их порядок.
-
-Для описания функций используется собственная нотация (свой собственный синтаксис). Она немного напоминает сам PHP, но всё же отличается от него, другими словами — это не код на PHP, а только лишь описание сигнатуры функции. Рассмотрим функцию `round()`, которая округляет число:
-
-```php
-round(int|float $num, int $precision = 0, int $mode = PHP_ROUND_HALF_UP): float
-```
-
-Задача этого формата — наглядно показать типы, количество и значения по умолчанию входящих параметров, а также тип выходного параметра. Последний всегда стоит в самой правой позиции, прямо после знака двоеточия. В данном случае тип возвращаемого значения `float`.
-
-Перечисление параметров идет через запятую в скобках после названия функции. Перед каждым именем параметра стоит его тип. Например, тип параметра `$num` — это `float`. Значение по умолчанию задается как присваивание, например `$precision` по умолчанию равно нулю.
-
-Параметры со значением по умолчанию — это необязательные параметры функции, запятые отделяют их друг от друга. Для функции выше это `$precision` и `$mode`. `$mode`, в свою очередь, по умолчанию равен значению константы `PHP_ROUND_HALF_UP`. Если какой-либо параметр равен значению константы, значит в документации этой функции есть перечисление и описание всех возможных констант, которые могут быть использованы как значение этого параметра.
-
-Основываясь на сказанном выше, мы можем вызвать функцию следующим образом:
-
-```php
-<?php
-
-round(5.3); // 5.0
-round(8.333, 1); // 8.3
-round(8.333, 2, PHP_ROUND_HALF_UP); // 8.33
-```
diff --git a/modules/40-define-functions/500-reading-documentation/ru/data.yml b/modules/40-define-functions/500-reading-documentation/ru/data.yml
deleted file mode 100644
index 49ef06db..00000000
--- a/modules/40-define-functions/500-reading-documentation/ru/data.yml
+++ /dev/null
@@ -1,9 +0,0 @@
----
-name: Чтение документации
-tips:
-  - |
-    [Документация PHP на русском языке](https://php.net/manual/ru/)
-  - |
-    [Справочник функций](https://php.net/manual/ru/funcref.php)
-  - |
-    [Функция floor()](https://www.php.net/manual/ru/function.floor.php)
diff --git a/modules/45-logic/10-bool-type/index.php b/modules/45-logic/10-bool-type/Solution.php
similarity index 70%
rename from modules/45-logic/10-bool-type/index.php
rename to modules/45-logic/10-bool-type/Solution.php
index 89077b5c..f8642f5f 100644
--- a/modules/45-logic/10-bool-type/index.php
+++ b/modules/45-logic/10-bool-type/Solution.php
@@ -3,7 +3,7 @@
 namespace HexletBasics\Logic\BoolType;
 
 // BEGIN
-function isPensioner($age)
+function isPensioner(int $age): bool
 {
     return $age >= 60;
 }
diff --git a/modules/45-logic/10-bool-type/SolutionTest.php b/modules/45-logic/10-bool-type/SolutionTest.php
index 3efb6d06..48000215 100644
--- a/modules/45-logic/10-bool-type/SolutionTest.php
+++ b/modules/45-logic/10-bool-type/SolutionTest.php
@@ -2,14 +2,12 @@
 
 namespace HexletBasics\Logic\BoolType;
 
-use PHPUnit\Framework\TestCase;
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        require 'index.php';
-
         $this->assertFalse(isPensioner(23));
         $this->assertFalse(isPensioner(59));
         $this->assertTrue(isPensioner(60));
diff --git a/modules/45-logic/10-bool-type/ru/README.md b/modules/45-logic/10-bool-type/ru/README.md
index 3b74a07f..835792b1 100644
--- a/modules/45-logic/10-bool-type/ru/README.md
+++ b/modules/45-logic/10-bool-type/ru/README.md
@@ -1,51 +1,87 @@
-Кроме арифметических операций в математике есть операции сравнения, например, `5 > 4` или `3 < 1`. Они есть и в программировании. Допустим, когда мы заходим на сайт, введенные логин и пароль сравниваются с теми, какие есть в базе. Если они есть, нас пускают внутрь — аутентифицируют. В этом уроке разберем операции сравнения.
+Кроме арифметических операций в математике есть операции сравнения, например, `5 > 4` или `3 < 1`. Они есть и в программировании. Сравнения часто применяются в реальных задачах, связанных с числами. Например, когда мы оформляем покупку в интернет-магазине, система проверяет: хватает ли у пользователя денег на счете, чтобы оплатить товар. Если сумма на счете больше или равна цене товара, заказ подтверждается. При нехватке средств появляется соответствующее сообщение.
 
-Языки программирования адаптировали все математические операции сравнения в неизменном виде, кроме операторов равенства и неравенства. В математике для этого используется обычное равно `=`, но в программировании такое встречается редко.
+## Сравнение в программировании
 
-Во многих языках символ `=` используется, чтобы присвоить переменным значения. Поэтому в php сравнивают с помощью `==`.
+Начнем с примера, в котором сравнивается два числа:
 
-Список операций сравнения:
+```php
+<?php
+
+var_dump(5 > 4); // => bool(true)
+var_dump(4 > 4); // => bool(false)
+```
+
+Результатом сравнения является значение типа `bool`. У этого типа есть всего два возможных варианта `true` и `false`. Это специальные значения языка. Их можно использовать напрямую:
+
+```php
+<?php
+
+var_dump(true);  // => bool(true)
+var_dump(false); // => bool(false)
+```
+
+Обратите внимание на новую функцию `var_dump()`. Привычная нам `print_r()` плохо подходит для вывода логических значений: `true` она печатает как `1`, а `false` — как пустую строку. Функция `var_dump()` выводит и тип, и значение, поэтому для значений типа `bool` используют ее.
 
-* `<` — меньше
-* `<=` — меньше или равно
-* `>` — больше
-* `>=` — больше или равно
-* `==` — равно
-* `!=` — не равно
+На практике значения `true` и `false` редко используют напрямую, но на их основе строится логика поведения программы. Мы с этим сталкиваемся буквально каждый день, когда вводим пинкоды и пароли, когда выполняем какие-то действия, результатом которых могут быть разные варианты. Все эти варианты прописаны внутри программы в виде условных выражений. Программа рассуждает примерно так: *если так-то делай раз, если по-другому, то делай два*.
 
+В PHP доступны следующие операции сравнения:
 
-Эти операции применяются не только к числам. Например, с помощью оператора равенства можно сравнить строки: `password == text` — это сравнение идентичности строк, которые записаны в разных переменных.
+* `<` и `<=` обозначают «меньше» и «меньше или равно»
+* `>` и `>=` обозначают «больше» и «больше или равно»
+* `==` и `!=` обозначают «равно» и «не равно»
+* `===` и `!==` обозначают «строго равно» и «строго не равно»
 
-## Логический тип
+Языки программирования адаптировали все математические операции сравнения в неизменном виде, кроме операторов равенства и неравенства. В математике для этого используется обычное равно `=`, но в программировании символ `=`, чаще всего, используется, чтобы присвоить переменным значения. Поэтому в PHP сравнивают с помощью `==` и `===`.
 
-Логическая операция типа `5 > 4` или `password == text` — это выражение. Его результат — специальное значение `True` («истина») или `False` («ложь»). Это новый для нас тип данных — `bool`:
+Чем различаются эти два оператора? Вспомните урок про слабую типизацию: PHP пытается автоматически преобразовывать типы. Оператор `==` сравнивает значения после такого преобразования, поэтому, например, `0 == '0'` оказывается истиной. Оператор `===` сравнивает строго, без преобразования: значения равны, только если совпадают и тип, и само значение. Неявные преобразования приводят к трудноуловимым ошибкам, поэтому в PHP принято использовать строгие операторы `===` и `!==` — так мы и будем делать в этом курсе.
+
+Несколько примеров:
 
 ```php
 <?php
 
-$result = 5 > 4;
-print_r($result); // => true
-print_r('one' !== 'one'); // => false
+var_dump(5 >= 3);  // => bool(true)
+var_dump(7 < 0);   // => bool(false)
+var_dump(5 > 5);   // => bool(false)
+var_dump(5 >= 5);  // => bool(true)
+var_dump(2 === 5); // => bool(false)
+var_dump(2 !== 5); // => bool(true)
 ```
 
-Он содержит всего лишь два этих значения. Наряду со строками (string) и целыми и рациональными числами, булев тип (bool) — это один из примитивных типов данных в PHP.
+Когда в сравнении используют конкретные значения, то эта операция кажется бессмысленной, мы и так знаем ее результат сравнения и он всегда один и тот же, потому что если 3 больше 2, то это не меняется. Но все меняется, когда значения могут меняться. Попробуем написать простую функцию, которая принимает на вход возраст ребенка и определяет, младенец ли он. Младенцами считаются дети до двух лет (два не включается).
+
+```php
+<?php
+
+function isInfant(int $age): bool
+{
+    return $age < 2;
+}
 
-## Предикаты
+var_dump(isInfant(3)); // => bool(false)
+var_dump(isInfant(2)); // => bool(false)
+var_dump(isInfant(1)); // => bool(true)
+var_dump(isInfant(0)); // => bool(true)
+```
 
-Попробуем написать простую функцию, которая принимает на вход возраст ребенка и определяет, младенец ли он. Младенцами считаются дети до года.
+Когда функции возвращают результат сравнения, они обычно отвечают на вопрос «да» или «нет». Такие функции называют **предикатами**. Их легко узнать по тому, что они возвращают логическое значение `true` или `false`. Часто в их названии есть вопрос или утверждение, которое можно проверить. В PHP предикаты, как правило, начинаются с префикса `is`, `has` или `can`, но не ограничены этими словами. Примеры:
 
-Любая операция — это выражение, поэтому единственной строчкой функции пишем «вернуть то значение, которое получится в результате сравнения `age < 1`». В зависимости от того, какой аргумент пришел, сравнение будет истинным (`True`) или ложным (`False`), а `return` вернет этот результат:
+* `isInfant()` — «младенец ли?»
+* `hasChildren()` — «есть ли дети?»
+* `isEmpty()` — «пустой ли?»
+* `hasErrors()` — «есть ли ошибки?»
+
+Вот функция, проверяющая, является ли число отрицательным:
 
 ```php
 <?php
 
-function isInfant($age)
+// Проверяем, меньше ли число нуля
+function isNegative(int $number): bool
 {
-    return $age < 1;
+    return $number < 0;
 }
 
-// Для вывода bool используем var_dump(), а не print_r()
-var_dump(isInfant(3));   // => bool(false)
-var_dump(isInfant(0.5)); // => bool(true)
-
+var_dump(isNegative(-5)); // => bool(true)
+var_dump(isNegative(7));  // => bool(false)
 ```
diff --git a/modules/45-logic/10-bool-type/ru/data.yml b/modules/45-logic/10-bool-type/ru/data.yml
index f5764e1b..61fc5342 100644
--- a/modules/45-logic/10-bool-type/ru/data.yml
+++ b/modules/45-logic/10-bool-type/ru/data.yml
@@ -1,5 +1,13 @@
 ---
 name: Логический тип
+tips:
+  - |
+    [Тип bool в PHP](https://www.php.net/manual/ru/language.types.boolean.php)
+  - >
+    [Именование в
+    программировании](https://ru.hexlet.io/blog/posts/naming-in-programming?utm_source=code-basics&utm_medium=referral&utm_campaign=blog&utm_content=lesson)
 definitions:
   - name: Логический тип (bool)
-    description: 'тип данных с двумя возможными значениями: true (истина) и false (ложь).'
+    description: 'тип данных с двумя возможными значениями: `true` (истина) и `false` (ложь).'
+  - name: Предикат
+    description: выражение, отвечающее на вопрос «да» или «нет» с помощью типа bool.
diff --git a/modules/50-loops/28-build-strings/Makefile b/modules/45-logic/15-bool-strings/Makefile
similarity index 100%
rename from modules/50-loops/28-build-strings/Makefile
rename to modules/45-logic/15-bool-strings/Makefile
diff --git a/modules/45-logic/15-bool-strings/Solution.php b/modules/45-logic/15-bool-strings/Solution.php
new file mode 100644
index 00000000..d0fca7f2
--- /dev/null
+++ b/modules/45-logic/15-bool-strings/Solution.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace HexletBasics\Logic\BoolStrings;
+
+// BEGIN
+function isLongWord(string $word): bool
+{
+    return strlen($word) > 5;
+}
+// END
diff --git a/modules/45-logic/15-bool-strings/SolutionTest.php b/modules/45-logic/15-bool-strings/SolutionTest.php
new file mode 100644
index 00000000..410ec753
--- /dev/null
+++ b/modules/45-logic/15-bool-strings/SolutionTest.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace HexletBasics\Logic\BoolStrings;
+
+use HexletBasics\Exercise\TestCase;
+
+class SolutionTest extends TestCase
+{
+    public function test()
+    {
+        $this->assertFalse(isLongWord('apple'));
+        $this->assertTrue(isLongWord('banana'));
+        $this->assertTrue(isLongWord('pineapple'));
+    }
+}
diff --git a/modules/45-logic/15-bool-strings/description.es.yml b/modules/45-logic/15-bool-strings/description.es.yml
new file mode 100644
index 00000000..87d1bea6
--- /dev/null
+++ b/modules/45-logic/15-bool-strings/description.es.yml
@@ -0,0 +1,49 @@
+---
+
+name: Comparación de cadenas
+theory: |
+  Las operaciones de comparación funcionan tanto con números como con cadenas. En PHP las cadenas se comparan lexicográficamente: carácter por carácter, de izquierda a derecha, según los códigos de los caracteres.
+
+  ```php
+  <?php
+
+  var_dump('apple' < 'banana'); // => bool(true)
+  var_dump('cat' > 'dog');      // => bool(false)
+  ```
+
+  Aquí `'apple' < 'banana'` porque el código de `a` (97) es menor que el código de `b` (98). El código de un carácter se puede consultar con la función `ord()`. La comparación distingue entre mayúsculas y minúsculas: el código de `'Z'` (90) es menor que el de `'a'` (97).
+
+  Las comparaciones son expresiones, por lo que se pueden combinar con otras expresiones, por ejemplo con la función `strlen()`, que devuelve la longitud de una cadena:
+
+  ```php
+  <?php
+
+  var_dump(strlen('apple') > 3); // => bool(true)
+  var_dump(strlen('hi') > 3);    // => bool(false)
+  ```
+
+  PHP también tiene muchas funciones predicado integradas para cadenas, por ejemplo:
+
+  ```php
+  <?php
+
+  var_dump(str_starts_with('hello', 'he')); // => bool(true)
+  var_dump(str_ends_with('hello', 'lo'));   // => bool(true)
+  var_dump(str_contains('hello', 'ell'));   // => bool(true)
+  ```
+
+instructions: |
+  Al registrarse en un sitio web, el programa comprueba que la contraseña sea lo suficientemente larga: más de 5 caracteres. Escribe una función `isLongWord()` que devuelva `true` si la longitud de la palabra dada es mayor que 5 caracteres, y `false` en caso contrario.
+
+  Ejemplo:
+
+  ```php
+  <?php
+
+  var_dump(isLongWord('apple'));  // => bool(false)
+  var_dump(isLongWord('banana')); // => bool(true)
+  ```
+
+tips:
+  - |
+    [Operadores de comparación en PHP](https://www.php.net/manual/es/language.operators.comparison.php)
diff --git a/modules/45-logic/15-bool-strings/en/EXERCISE.md b/modules/45-logic/15-bool-strings/en/EXERCISE.md
new file mode 100644
index 00000000..f3f3414d
--- /dev/null
+++ b/modules/45-logic/15-bool-strings/en/EXERCISE.md
@@ -0,0 +1,10 @@
+When registering on a website, the program checks that the password is long enough — more than 5 characters. Write a function `isLongWord()` that returns `true` if the length of the given word is more than 5 characters, and `false` otherwise.
+
+Example:
+
+```php
+<?php
+
+var_dump(isLongWord('apple'));  // => bool(false)
+var_dump(isLongWord('banana')); // => bool(true)
+```
diff --git a/modules/45-logic/15-bool-strings/en/README.md b/modules/45-logic/15-bool-strings/en/README.md
new file mode 100644
index 00000000..331c8bd5
--- /dev/null
+++ b/modules/45-logic/15-bool-strings/en/README.md
@@ -0,0 +1,29 @@
+Comparison operations work with strings as well as numbers. In PHP, strings are compared lexicographically: character by character, left to right, using character codes.
+
+```php
+<?php
+
+var_dump('apple' < 'banana'); // => bool(true)
+var_dump('cat' > 'dog');      // => bool(false)
+```
+
+Here `'apple' < 'banana'` because the code of `a` (97) is less than the code of `b` (98). You can check a character code with the `ord()` function. The comparison is case-sensitive: the code of `'Z'` (90) is less than the code of `'a'` (97).
+
+Comparisons are expressions, so you can combine them with other expressions, for example with the `strlen()` function that returns the length of a string:
+
+```php
+<?php
+
+var_dump(strlen('apple') > 3); // => bool(true)
+var_dump(strlen('hi') > 3);    // => bool(false)
+```
+
+PHP also has many built-in predicate functions for strings, for example:
+
+```php
+<?php
+
+var_dump(str_starts_with('hello', 'he')); // => bool(true)
+var_dump(str_ends_with('hello', 'lo'));   // => bool(true)
+var_dump(str_contains('hello', 'ell'));   // => bool(true)
+```
diff --git a/modules/45-logic/15-bool-strings/en/data.yml b/modules/45-logic/15-bool-strings/en/data.yml
new file mode 100644
index 00000000..15841c55
--- /dev/null
+++ b/modules/45-logic/15-bool-strings/en/data.yml
@@ -0,0 +1,5 @@
+---
+name: Comparing strings
+tips:
+  - |
+    [Comparison operators in PHP](https://www.php.net/manual/en/language.operators.comparison.php)
diff --git a/modules/45-logic/15-bool-strings/es/EXERCISE.md b/modules/45-logic/15-bool-strings/es/EXERCISE.md
new file mode 100644
index 00000000..a24be8f4
--- /dev/null
+++ b/modules/45-logic/15-bool-strings/es/EXERCISE.md
@@ -0,0 +1,10 @@
+Al registrarse en un sitio web, el programa comprueba que la contraseña sea lo suficientemente larga: más de 5 caracteres. Escribe una función `isLongWord()` que devuelva `true` si la longitud de la palabra dada es mayor que 5 caracteres, y `false` en caso contrario.
+
+Ejemplo:
+
+```php
+<?php
+
+var_dump(isLongWord('apple'));  // => bool(false)
+var_dump(isLongWord('banana')); // => bool(true)
+```
diff --git a/modules/45-logic/15-bool-strings/es/README.md b/modules/45-logic/15-bool-strings/es/README.md
new file mode 100644
index 00000000..ba3af525
--- /dev/null
+++ b/modules/45-logic/15-bool-strings/es/README.md
@@ -0,0 +1,29 @@
+Las operaciones de comparación funcionan tanto con números como con cadenas. En PHP las cadenas se comparan lexicográficamente: carácter por carácter, de izquierda a derecha, según los códigos de los caracteres.
+
+```php
+<?php
+
+var_dump('apple' < 'banana'); // => bool(true)
+var_dump('cat' > 'dog');      // => bool(false)
+```
+
+Aquí `'apple' < 'banana'` porque el código de `a` (97) es menor que el código de `b` (98). El código de un carácter se puede consultar con la función `ord()`. La comparación distingue entre mayúsculas y minúsculas: el código de `'Z'` (90) es menor que el de `'a'` (97).
+
+Las comparaciones son expresiones, por lo que se pueden combinar con otras expresiones, por ejemplo con la función `strlen()`, que devuelve la longitud de una cadena:
+
+```php
+<?php
+
+var_dump(strlen('apple') > 3); // => bool(true)
+var_dump(strlen('hi') > 3);    // => bool(false)
+```
+
+PHP también tiene muchas funciones predicado integradas para cadenas, por ejemplo:
+
+```php
+<?php
+
+var_dump(str_starts_with('hello', 'he')); // => bool(true)
+var_dump(str_ends_with('hello', 'lo'));   // => bool(true)
+var_dump(str_contains('hello', 'ell'));   // => bool(true)
+```
diff --git a/modules/45-logic/15-bool-strings/es/data.yml b/modules/45-logic/15-bool-strings/es/data.yml
new file mode 100644
index 00000000..fd59b4fa
--- /dev/null
+++ b/modules/45-logic/15-bool-strings/es/data.yml
@@ -0,0 +1,5 @@
+---
+name: Comparación de cadenas
+tips:
+  - |
+    [Operadores de comparación en PHP](https://www.php.net/manual/es/language.operators.comparison.php)
diff --git a/modules/45-logic/15-bool-strings/ru/EXERCISE.md b/modules/45-logic/15-bool-strings/ru/EXERCISE.md
new file mode 100644
index 00000000..3180190a
--- /dev/null
+++ b/modules/45-logic/15-bool-strings/ru/EXERCISE.md
@@ -0,0 +1,10 @@
+При регистрации на сайте программа проверяет, что пароль достаточно длинный — больше 5 символов. Напишите функцию `isLongWord()`, которая возвращает `true`, если длина переданного слова больше 5 символов, и `false` в противном случае.
+
+Пример работы:
+
+```php
+<?php
+
+var_dump(isLongWord('apple'));  // => bool(false)
+var_dump(isLongWord('banana')); // => bool(true)
+```
diff --git a/modules/45-logic/15-bool-strings/ru/README.md b/modules/45-logic/15-bool-strings/ru/README.md
new file mode 100644
index 00000000..38877ddc
--- /dev/null
+++ b/modules/45-logic/15-bool-strings/ru/README.md
@@ -0,0 +1,70 @@
+Операции сравнения работают с числами и со строками. В PHP строки сравниваются лексикографически: посимвольно слева направо по числовым кодам символов.
+
+```php
+<?php
+
+var_dump('apple' < 'banana');  // => bool(true)
+var_dump('cat' > 'dog');       // => bool(false)
+var_dump('abc' === 'abc');     // => bool(true)
+var_dump('hello' !== 'world'); // => bool(true)
+```
+
+Здесь `'apple' < 'banana'`, потому что код `a` (97) меньше кода `b` (98), и именно первый символ решает исход сравнения. Код символа можно посмотреть с помощью функции `ord()`:
+
+```php
+<?php
+
+print_r(ord('a')); // => 97
+print_r(ord('b')); // => 98
+```
+
+Сравнение чувствительно к регистру: код `'Z'` (90) меньше кода `'a'` (97). Пример сравнения, где первые буквы разного регистра:
+
+```php
+<?php
+
+var_dump('Zebra' < 'apple');  // => bool(true)  — 'Z'(90) < 'a'(97)
+var_dump('apple' < 'Banana'); // => bool(false) — 'a'(97) > 'B'(66)
+var_dump('Apple' < 'apple');  // => bool(true)  — 'A'(65) < 'a'(97)
+```
+
+Напишем функцию, которая проверяет, начинается ли слово с заданной буквы. Для этого возьмем первый символ строки и сравним его с нужной буквой:
+
+```php
+<?php
+
+function startsWithLetter(string $word, string $letter): bool
+{
+    return $word[0] === $letter;
+}
+
+var_dump(startsWithLetter('apple', 'a'));  // => bool(true)
+var_dump(startsWithLetter('banana', 'a')); // => bool(false)
+```
+
+Операции сравнения представляют собой такие же выражения, как и арифметические. В них можно подставлять готовые значения и другие выражения, как в примере выше: `$word[0]`. Например, вместо числа можно использовать результат работы функции `strlen()`, которая возвращает длину строки:
+
+```php
+<?php
+
+var_dump(strlen('apple') > 3); // => bool(true), потому что strlen('apple') — это 5
+var_dump(strlen('hi') > 3);    // => bool(false), потому что strlen('hi') — это 2
+```
+
+В примере выше сначала выполняется функция `strlen('apple')`, результатом будет число `5`. Потом это число сравнивается с `3`. Другими словами, сначала считаются аргументы выражения (например, длина строки), а потом выполняется операция сравнения.
+
+Так можно комбинировать разные операции, получая более сложные проверки.
+
+## Полезные предикаты
+
+В PHP есть много встроенных функций-предикатов для работы со строками. Они возвращают `true` или `false` и помогают проверять разные свойства строки. Ниже приведены самые часто используемые:
+
+```php
+<?php
+
+var_dump(str_starts_with('hello', 'he')); // => bool(true) — строка начинается с 'he'
+var_dump(str_ends_with('hello', 'lo'));   // => bool(true) — строка заканчивается на 'lo'
+var_dump(str_contains('hello', 'ell'));   // => bool(true) — строка содержит 'ell'
+```
+
+Такие функции позволяют проверять строки на нужные условия прямо в коде, без написания дополнительных функций.
diff --git a/modules/45-logic/15-bool-strings/ru/data.yml b/modules/45-logic/15-bool-strings/ru/data.yml
new file mode 100644
index 00000000..6124b194
--- /dev/null
+++ b/modules/45-logic/15-bool-strings/ru/data.yml
@@ -0,0 +1,5 @@
+---
+name: Сравнение строк
+tips:
+  - |
+    [Операторы сравнения в PHP](https://www.php.net/manual/ru/language.operators.comparison.php)
diff --git a/modules/45-logic/15-predicates/SolutionTest.php b/modules/45-logic/15-predicates/SolutionTest.php
deleted file mode 100644
index 032dbf69..00000000
--- a/modules/45-logic/15-predicates/SolutionTest.php
+++ /dev/null
@@ -1,17 +0,0 @@
-<?php
-
-namespace HexletBasics\Logic\Predicates;
-
-use PHPUnit\Framework\TestCase;
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        require 'index.php';
-
-        $this->assertFalse(isMister('8234782'));
-        $this->assertFalse(isMister('Joker'));
-        $this->assertTrue(isMister('Mister'));
-    }
-}
diff --git a/modules/45-logic/15-predicates/description.es.yml b/modules/45-logic/15-predicates/description.es.yml
deleted file mode 100644
index fa0a0558..00000000
--- a/modules/45-logic/15-predicates/description.es.yml
+++ /dev/null
@@ -1,45 +0,0 @@
----
-
-name: Predicados
-theory: |
-
-  Recordemos la función `isInfant()` del tema anterior:
-
-  ```php
-  <?php
-
-  function isInfant($age)
-  {
-      return $age < 1;
-  }
-
-  var_dump(isInfant(3));
-  ```
-
-  Estas funciones se llaman **predicados**. Los predicados son funciones que responden a una pregunta y siempre devuelven `true` o `false`.
-
-  En todos los lenguajes de programación, los predicados se nombran de manera especial para facilitar su análisis. En PHP, los predicados suelen comenzar con los prefijos `is`, `has` o `can`, pero no se limitan a estas palabras. Ejemplos:
-
-  * `isInfant()` — "¿es un bebé?"
-  * `hasChildren()` — "¿tiene hijos?"
-  * `isEmpty()` — "¿está vacío?"
-  * `hasErrors()` — "¿tiene errores?"
-
-instructions: |
-
-  Escribe una función `isMister()` que tome una cadena de texto y verifique si es la palabra `'Mister'`.
-
-  ```php
-  <?php
-
-  isMister('Mister'); // true
-  isMister('Missis'); // false
-  ```
-
-tips:
-  - |
-    [Naming en programación](https://codica.la/blog/naming-in-programming)
-
-definitions:
-  - name: Predicado
-    description: una expresión que responde a una pregunta "sí" o "no" utilizando el tipo bool.
diff --git a/modules/45-logic/15-predicates/en/EXERCISE.md b/modules/45-logic/15-predicates/en/EXERCISE.md
deleted file mode 100644
index e7ee1327..00000000
--- a/modules/45-logic/15-predicates/en/EXERCISE.md
+++ /dev/null
@@ -1,9 +0,0 @@
-
-Write the function `isMister()` that takes a string and checks if it's the word `'Mister'`.
-
-```php
-<?php
-
-isMister('Mister'); // true
-isMister('Missis'); // false
-```
diff --git a/modules/45-logic/15-predicates/en/README.md b/modules/45-logic/15-predicates/en/README.md
deleted file mode 100644
index 67102aae..00000000
--- a/modules/45-logic/15-predicates/en/README.md
+++ /dev/null
@@ -1,47 +0,0 @@
-
-Remember the `isInfant()` function from the last lesson?
-
-```php
-<?php
-
-function isInfant($age)
-{
-    return $age < 1;
-}
-
-var_dump(isInfant(3));
-```
-
-```text
-bool(false)
-```
-
-This kind of function is called a predicate. Predicate functions answer a question and always (without exception!) return either `true` or `false`.
-
-Predicates usually have handy names in every language so that they're easily analyzed. In PHP, predicates usually begin with, but are not limited to, the prefixes `is`, `has` or `can`. Examples:
-
-  * `isInfant()` — «is an infant?»
-  * `hasChildren()` — «does they have children?»
-  * `isEmpty()` — «is it empty?»
-  * `hasErrors()` — «are there any errors?»
-
-A function can only be considered a predicate **if** it returns a bool.
-
----
-
-Let's write one more predicate function. It takes a string and checks if it's the word  `'Castle'`:
-
-```php
-<?php
-
-function isCastle($type)
-{
-    return $type === 'Castle';
-}
-
-var_dump(isCastle('Sea'));
-```
-
-```text
-bool(false)
-```
diff --git a/modules/45-logic/15-predicates/en/data.yml b/modules/45-logic/15-predicates/en/data.yml
deleted file mode 100644
index 21fda252..00000000
--- a/modules/45-logic/15-predicates/en/data.yml
+++ /dev/null
@@ -1,11 +0,0 @@
----
-name: Predicates
-tips:
-  - >
-    [Naming in
-    programming](https://hexlet.io/blog/posts/code-complete-naming-in-programming)
-definitions:
-  - name: A predicate
-    description: >-
-      is an expression that answers a yes or no question using the bool data
-      type.
diff --git a/modules/45-logic/15-predicates/es/EXERCISE.md b/modules/45-logic/15-predicates/es/EXERCISE.md
deleted file mode 100644
index 2be62fa3..00000000
--- a/modules/45-logic/15-predicates/es/EXERCISE.md
+++ /dev/null
@@ -1,9 +0,0 @@
-
-Escribe una función `isMister()` que tome una cadena de texto y verifique si es la palabra `'Mister'`.
-
-```php
-<?php
-
-isMister('Mister'); // true
-isMister('Missis'); // false
-```
diff --git a/modules/45-logic/15-predicates/es/README.md b/modules/45-logic/15-predicates/es/README.md
deleted file mode 100644
index 3e2e9e15..00000000
--- a/modules/45-logic/15-predicates/es/README.md
+++ /dev/null
@@ -1,22 +0,0 @@
-
-Recordemos la función `isInfant()` del tema anterior:
-
-```php
-<?php
-
-function isInfant($age)
-{
-    return $age < 1;
-}
-
-var_dump(isInfant(3));
-```
-
-Estas funciones se llaman **predicados**. Los predicados son funciones que responden a una pregunta y siempre devuelven `true` o `false`.
-
-En todos los lenguajes de programación, los predicados se nombran de manera especial para facilitar su análisis. En PHP, los predicados suelen comenzar con los prefijos `is`, `has` o `can`, pero no se limitan a estas palabras. Ejemplos:
-
-* `isInfant()` — "¿es un bebé?"
-* `hasChildren()` — "¿tiene hijos?"
-* `isEmpty()` — "¿está vacío?"
-* `hasErrors()` — "¿tiene errores?"
diff --git a/modules/45-logic/15-predicates/es/data.yml b/modules/45-logic/15-predicates/es/data.yml
deleted file mode 100644
index 3be2e097..00000000
--- a/modules/45-logic/15-predicates/es/data.yml
+++ /dev/null
@@ -1,10 +0,0 @@
----
-name: Predicados
-tips:
-  - |
-    [Naming en programación](https://codica.la/blog/naming-in-programming)
-definitions:
-  - name: Predicado
-    description: >-
-      una expresión que responde a una pregunta "sí" o "no" utilizando el tipo
-      bool.
diff --git a/modules/45-logic/15-predicates/index.php b/modules/45-logic/15-predicates/index.php
deleted file mode 100644
index 042c3da1..00000000
--- a/modules/45-logic/15-predicates/index.php
+++ /dev/null
@@ -1,10 +0,0 @@
-<?php
-
-namespace HexletBasics\Logic\Predicates;
-
-// BEGIN
-function isMister($str)
-{
-    return $str === 'Mister';
-}
-// END
diff --git a/modules/45-logic/15-predicates/ru/EXERCISE.md b/modules/45-logic/15-predicates/ru/EXERCISE.md
deleted file mode 100644
index 076d692d..00000000
--- a/modules/45-logic/15-predicates/ru/EXERCISE.md
+++ /dev/null
@@ -1,9 +0,0 @@
-
-Напишите функцию `isMister()`, которая принимает строку и проверяет, является ли она словом `'Mister'`.
-
-```php
-<?php
-
-isMister('Mister'); // true
-isMister('Missis'); // false
-```
diff --git a/modules/45-logic/15-predicates/ru/README.md b/modules/45-logic/15-predicates/ru/README.md
deleted file mode 100644
index 16d70f84..00000000
--- a/modules/45-logic/15-predicates/ru/README.md
+++ /dev/null
@@ -1,22 +0,0 @@
-
-Вспомним функцию `isInfant()` из прошлого урока:
-
-```php
-<?php
-
-function isInfant($age)
-{
-    return $age < 1;
-}
-
-var_dump(isInfant(3));
-```
-
-Подобные функции называют **предикатами**. Функции-предикаты отвечают на какой-то вопрос и всегда возвращают либо `true`, либо `false`.
-
-Предикаты во всех языках принято именовать особым образом для простоты анализа. В PHP предикаты, как правило, начинаются с префикса `is`, `has` или `can`, но не ограничены этими словами. Примеры:
-
-* `isInfant()` — «младенец ли?»
-* `hasChildren()` — «есть ли дети?»
-* `isEmpty()` — «пустой ли?»
-* `hasErrors()` — «есть ли ошибки?»
diff --git a/modules/45-logic/15-predicates/ru/data.yml b/modules/45-logic/15-predicates/ru/data.yml
deleted file mode 100644
index 18ecbd6c..00000000
--- a/modules/45-logic/15-predicates/ru/data.yml
+++ /dev/null
@@ -1,9 +0,0 @@
----
-name: Предикаты
-tips:
-  - >
-    [Именование в
-    программировании](https://ru.hexlet.io/blog/posts/naming-in-programming?utm_source=code-basics&utm_medium=referral&utm_campaign=blog&utm_content=lesson)
-definitions:
-  - name: Предикат
-    description: выражение, отвечающее на вопрос «да» или «нет» с помощью типа bool.
diff --git a/modules/45-logic/20-logic-combine-expressions/index.php b/modules/45-logic/20-logic-combine-expressions/Solution.php
similarity index 67%
rename from modules/45-logic/20-logic-combine-expressions/index.php
rename to modules/45-logic/20-logic-combine-expressions/Solution.php
index ba0434ee..3311690e 100644
--- a/modules/45-logic/20-logic-combine-expressions/index.php
+++ b/modules/45-logic/20-logic-combine-expressions/Solution.php
@@ -3,7 +3,7 @@
 namespace HexletBasics\Logic\CombineExpressions;
 
 // BEGIN
-function isInternationalPhone($phone)
+function isInternationalPhone(string $phone): bool
 {
     return $phone[0] === '+';
 }
diff --git a/modules/45-logic/20-logic-combine-expressions/SolutionTest.php b/modules/45-logic/20-logic-combine-expressions/SolutionTest.php
index 28b950a9..d47c6117 100644
--- a/modules/45-logic/20-logic-combine-expressions/SolutionTest.php
+++ b/modules/45-logic/20-logic-combine-expressions/SolutionTest.php
@@ -2,13 +2,12 @@
 
 namespace HexletBasics\Logic\CombineExpressions;
 
-use PHPUnit\Framework\TestCase;
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        require 'index.php';
         $this->assertFalse(isInternationalPhone('89602223423'));
         $this->assertTrue(isInternationalPhone('+79602223423'));
     }
diff --git a/modules/45-logic/20-logic-combine-expressions/ru/README.md b/modules/45-logic/20-logic-combine-expressions/ru/README.md
index f6e77052..4c04af53 100644
--- a/modules/45-logic/20-logic-combine-expressions/ru/README.md
+++ b/modules/45-logic/20-logic-combine-expressions/ru/README.md
@@ -1,52 +1,58 @@
-**Логические операции** — это выражения, значит, их можно комбинировать с другими выражениями. Например, мы хотим проверить четность числа — кратность двум. В программировании используют такой подход: проверяют остаток от деления на два:
+**Логические операции** являются выражениями, поэтому их можно комбинировать с другими выражениями. Например, мы хотим проверить четность числа, то есть его кратность двум. В программировании для этого проверяют остаток от деления на два. Если остаток равен `0`, число четное. Если остаток не равен `0`, число нечетное.
 
-* если остаток `0` — число четное
-* если остаток не `0` — число нечетное
+![even-or-odd](./assets/even-or-odd.jpg)
 
-Остаток от деления — простая, но важная концепция в арифметике, алгебре, в теории чисел и криптографии. Нужно разделить число на несколько равных групп, и если в конце что-то останется — это остаток от деления.
+Остаток от деления является простой, но важной концепцией в арифметике, алгебре, в теории чисел и криптографии. Нужно разделить число на несколько равных групп, и если в конце что-то останется, это и есть остаток от деления.
 
 Делим конфеты поровну между людьми:
 
-* 7 конфет, 2 человека: 2 x 3 + остаток 1 — 7 не кратно 2
-* 21 конфету, 3 человека: 3 x 7 + остаток 0 — 21 кратно 3
-* 19 конфет, 5 человек: 5 x 3 + остаток 4 — 19 не кратно 5
+* 7 конфет, 2 человека: 2 x 3 + остаток 1 (7 не кратно 2)
+* 21 конфету, 3 человека: 3 x 7 + остаток 0 (21 кратно 3)
+* 19 конфет, 5 человек: 5 x 3 + остаток 4 (19 не кратно 5)
 
-Оператор `%` вычисляет **остаток от деления**:
+Оператор `%` вычисляет остаток от деления:
 
 * `7 % 2` → `1`
 * `21 % 3` → `0`
 * `19 % 5` → `4`
 
-С помощью него напишем функцию проверки четности:
+Скомбинируем в одном выражении логический оператор «проверка равенства» `===` и арифметический оператор `%` и напишем функцию проверки четности:
 
 ```php
 <?php
 
-function isEven($number)
+function isEven(int $number): bool
 {
     return $number % 2 === 0;
 }
 
-isEven(10); // true
-isEven(3);  // false
+var_dump(isEven(10)); // => bool(true)
+var_dump(isEven(3));  // => bool(false)
 ```
 
-В одном выражении мы скомбинировали логический оператор проверки равенства `===` и арифметический оператор `%`.
+Приоритет арифметических операций выше логических. Значит, сначала вычисляется арифметическое выражение `$number % 2`, а затем результат сравнивается с нулем и возвращается результат проверки равенства.
 
-Приоритет арифметических операций выше логических. Значит, сначала вычисляется арифметическое выражение `$number % 2`, затем результат участвует в логическом сравнении.
+Теперь напишем функцию, которая принимает строку и проверяет, начинается ли эта строка с латинской буквы `a`.
 
-Это можно расшифровать так:
+Алгоритм:
 
->«Вычислить остаток от деления числа `$number` на 2 и сравнить, равен ли остаток нулю; затем вернуть результат проверки равенства»*
-
----
-
-*Напомним об извлечении символов из строки с помощью квадратных скобок:*
+1. Получим и запишем в переменную первый символ из строки-аргумента
+2. Сравним, равен ли символ латинской букве `a`
+3. Вернем результат
 
 ```php
 <?php
 
-$firstName = 'Alexander';
+function isFirstLetterAnA(string $text): bool
+{
+    $firstLetter = $text[0];
+    return $firstLetter === 'a';
+}
 
-$firstName[0]; // A
+var_dump(isFirstLetterAnA('orange')); // => bool(false)
+var_dump(isFirstLetterAnA('apple'));  // => bool(true)
 ```
+
+Чтобы было понятно, что тут происходит, попробуйте проговорить происходящее аналогично тому, как мы расшифровывали процесс в примере с `isEven()`.
+
+Теперь вы знаете, что операции сравнения применяются в программировании наравне с арифметическими. Но помните, что равенство обозначается `===`. Так вы не спутаете эту операцию с присваиванием значения переменной.
diff --git a/modules/45-logic/20-logic-combine-expressions/ru/assets/even-or-odd.jpg b/modules/45-logic/20-logic-combine-expressions/ru/assets/even-or-odd.jpg
new file mode 100644
index 00000000..6c3197c8
Binary files /dev/null and b/modules/45-logic/20-logic-combine-expressions/ru/assets/even-or-odd.jpg differ
diff --git a/modules/45-logic/20-logic-combine-expressions/ru/data.yml b/modules/45-logic/20-logic-combine-expressions/ru/data.yml
index 1d1a5262..c01f64c5 100644
--- a/modules/45-logic/20-logic-combine-expressions/ru/data.yml
+++ b/modules/45-logic/20-logic-combine-expressions/ru/data.yml
@@ -1,2 +1,10 @@
 ---
 name: Комбинирование операций и функций
+tips:
+  - |
+    [Выражение](https://ru.wikipedia.org/wiki/Выражение_(информатика))
+definitions:
+  - name: Выражение
+    description: >
+      последовательность действий над данными, приводящая к каком-то результату,
+      который можно использовать.
diff --git a/modules/45-logic/25-logical-operators/Solution.php b/modules/45-logic/25-logical-operators/Solution.php
new file mode 100644
index 00000000..a03320fa
--- /dev/null
+++ b/modules/45-logic/25-logical-operators/Solution.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace HexletBasics\Logic\LogicalOperators;
+
+// BEGIN
+function isLeapYear(int $year): bool
+{
+    return $year % 400 === 0 || ($year % 4 === 0 && $year % 100 !== 0);
+}
+// END
diff --git a/modules/45-logic/25-logical-operators/SolutionTest.php b/modules/45-logic/25-logical-operators/SolutionTest.php
index c08fea72..f9730f99 100644
--- a/modules/45-logic/25-logical-operators/SolutionTest.php
+++ b/modules/45-logic/25-logical-operators/SolutionTest.php
@@ -2,14 +2,12 @@
 
 namespace HexletBasics\Logic\LogicalOperators;
 
-use PHPUnit\Framework\TestCase;
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        require 'index.php';
-
         $this->assertTrue(isLeapYear(2016));
         $this->assertTrue(isLeapYear(2000));
         $this->assertFalse(isLeapYear(2017));
diff --git a/modules/45-logic/25-logical-operators/assets/lannisters.jpg b/modules/45-logic/25-logical-operators/assets/lannisters.jpg
deleted file mode 100644
index feeac49e..00000000
Binary files a/modules/45-logic/25-logical-operators/assets/lannisters.jpg and /dev/null differ
diff --git a/modules/45-logic/25-logical-operators/index.php b/modules/45-logic/25-logical-operators/index.php
deleted file mode 100644
index 626755c8..00000000
--- a/modules/45-logic/25-logical-operators/index.php
+++ /dev/null
@@ -1,12 +0,0 @@
-<?php
-
-namespace HexletBasics\Logic\LogicalOperators;
-
-// BEGIN
-function isLeapYear($year)
-{
-    $result = $year % 400 === 0 || ($year % 4 === 0 && $year % 100 !== 0);
-
-    return $result;
-}
-// END
diff --git a/modules/45-logic/25-logical-operators/ru/README.md b/modules/45-logic/25-logical-operators/ru/README.md
index 50ef5966..07fec321 100644
--- a/modules/45-logic/25-logical-operators/ru/README.md
+++ b/modules/45-logic/25-logical-operators/ru/README.md
@@ -1,52 +1,108 @@
-Логические выражения могут объединяться друг с другом, создавая все более хитрые проверки.
+Мы уже умеем писать функции, которые проверяют одиночные условия. А в этом уроке научимся строить составные условия.
 
-Хороший пример — проверка пароля. Как вы знаете, некоторые сайты при регистрации хотят пароль от 8 до 20 символов в длину.
+Предположим, что сайт при регистрации требует, чтобы пароль был длиннее восьми символов и содержал хотя бы одну заглавную букву. Попробуем написать два отдельных логических выражения и соединим их специальным оператором «И»:
 
-В математике мы бы написали `8 >= x <= 20`, где `x` — это длина конкретного пароля. Но в PHP такой трюк не пройдет.
+> Пароль длиннее 8 символов **И** пароль содержит хотя бы одну заглавную букву
 
-Нам придется сделать два отдельных логических выражения и соединить их специальным оператором «И»:
+Вот функция, которая принимает пароль и говорит, соответствует ли он условиям (`true`) или не соответствует (`false`):
 
 ```php
 <?php
 
-function hasSpecialChars($str)
+function hasCapitalLetter(string $text): bool
 {
-    // Проверяет содержание специальных символов в строке
+    // Проверяет наличие хотя бы одной заглавной буквы в строке
 }
 
-// Функция принимает пароль и проверяет, соответствует ли он условиям
-function isCorrectPassword($password)
+function isCorrectPassword(string $password): bool
 {
     $length = strlen($password);
-    // Скобки задают приоритет, чтобы показать, что к чему относится
-    return ($length >= 8 && $length <= 20) && hasSpecialChars($password);
+    return $length > 8 && hasCapitalLetter($password);
+}
+
+var_dump(isCorrectPassword('Qwerty'));     // => bool(false)
+var_dump(isCorrectPassword('Qwerty1234')); // => bool(true)
+var_dump(isCorrectPassword('qwerty1234')); // => bool(false)
+```
+
+Оператор `&&` означает «И». В математической логике это называют конъюнкцией. Все выражение считается истинным, если истинен каждый **операнд**, то есть каждое из составных выражений. Иными словами, `&&` означает «и то, и другое». Приоритет этого оператора ниже, чем приоритет операторов сравнения. Поэтому выражение `hasCapitalLetter($password) && $length > 8` тоже правильно отрабатывает без скобок.
+
+Кроме `&&` часто используется оператор `||`, обозначающий «ИЛИ» (дизъюнкция). Он означает «или то, или другое, или оба». Выражение `$a || $b` считается истинным, если хотя бы один из операндов истинен или когда оба операнда истинны. В другом случае выражение ложное.
+
+```php
+<?php
+
+function hasDiscount(int $age, bool $isStudent): bool
+{
+    return $age < 18 || $isStudent;
+}
+
+var_dump(hasDiscount(15, false)); // => bool(true)  (младше 18)
+var_dump(hasDiscount(25, true));  // => bool(true)  (студент)
+var_dump(hasDiscount(15, true));  // => bool(true)  (оба условия)
+var_dump(hasDiscount(25, false)); // => bool(false)
+```
+
+Операторы можно комбинировать в любом количестве и в любой последовательности. Если в коде одновременно встречаются `&&` и `||`, то приоритет лучше задавать скобками. Ниже пример расширенной функции, которая определяет корректность пароля:
+
+```php
+<?php
+
+function hasCapitalLetter(string $text): bool
+{
+    // Проверяет наличие хотя бы одной заглавной буквы в строке
 }
 
-isCorrectPassword('qwerty'); // false
-isCorrectPassword('qwerty1234'); // true
-isCorrectPassword('zxcvbnmasdfghjkqwertyui'); // false
+function hasSpecialChars(string $text): bool
+{
+    // Проверяет содержание специальных символов в строке
+}
+
+function isStrongPassword(string $password): bool
+{
+    $length = strlen($password);
+    // Скобки задают приоритет. Понятно, что к чему относится.
+    return ($length > 8 && hasCapitalLetter($password)) && hasSpecialChars($password);
+}
 ```
 
-Оператор `&&` означает «И» — в математической логике это называют **конъюнкцией**. Все выражение считается истинным только в том случае, когда истинен каждый операнд — каждое из составных выражений. Иными словами, `&&` означает «и то, и другое». Приоритет этого оператора ниже, чем приоритет операторов сравнения, поэтому выражение отрабатывает правильно без скобок.
+Теперь представим, что мы хотим купить квартиру, которая удовлетворяет таким условиям: площадь от 100 квадратных метров и больше на любой улице **ИЛИ** площадь от 80 квадратных метров и больше, но на центральной улице `Main Street`.
 
-Кроме `&&`, часто используется оператор `||` — «ИЛИ» (**дизъюнкция**). Он означает «или то, или другое, или оба». Операторы можно комбинировать в любом количестве и любой последовательности, но когда одновременно встречаются `&&` и `||`, то приоритет лучше задавать скобками.
+Напишем функцию, которая проверит квартиру. Она принимает два аргумента: площадь (число) и название улицы (строку):
+
+```php
+<?php
+
+function isGoodApartment(int $area, string $street): bool
+{
+    return $area >= 100 || ($area >= 80 && $street === 'Main Street');
+}
+
+var_dump(isGoodApartment(91, 'Queens Street'));  // => bool(false)
+var_dump(isGoodApartment(78, 'Queens Street'));  // => bool(false)
+var_dump(isGoodApartment(70, 'Main Street'));    // => bool(false)
+
+var_dump(isGoodApartment(120, 'Queens Street')); // => bool(true)
+var_dump(isGoodApartment(120, 'Main Street'));   // => bool(true)
+var_dump(isGoodApartment(80, 'Main Street'));    // => bool(true)
+```
 
-Область математики, в которой изучаются логические операторы, называется булевой алгеброй. Ниже увидите **таблицы истинности** — по ним можно определить, каким будет результат, если применить оператора:
+Область математики, в которой изучаются логические операторы, называется булевой алгеброй. **Таблицы истинности** показывают, каким будет результат при применении каждого оператора.
 
-### И `&&`
+#### И `&&`
 
 | A     | B     | A `&&` B |
 | ----- | ----- | -------- |
-| TRUE  | TRUE  | **TRUE** |
-| TRUE  | FALSE | FALSE    |
-| FALSE | TRUE  | FALSE    |
-| FALSE | FALSE | FALSE    |
+| true  | true  | **true** |
+| true  | false | false    |
+| false | true  | false    |
+| false | false | false    |
 
-### ИЛИ `||`
+#### ИЛИ `||`
 
 | A     | B     | A `‖` B  |
 | ----- | ----- | -------- |
-| TRUE  | TRUE  | **TRUE** |
-| TRUE  | FALSE | **TRUE** |
-| FALSE | TRUE  | **TRUE** |
-| FALSE | FALSE | FALSE    |
+| true  | true  | **true** |
+| true  | false | **true** |
+| false | true  | **true** |
+| false | false | false    |
diff --git a/modules/45-logic/25-logical-operators/ru/data.yml b/modules/45-logic/25-logical-operators/ru/data.yml
index efa8ff0b..c4ee669a 100644
--- a/modules/45-logic/25-logical-operators/ru/data.yml
+++ b/modules/45-logic/25-logical-operators/ru/data.yml
@@ -4,9 +4,9 @@ tips:
   - |
     [Булева алгебра](https://ru.wikipedia.org/wiki/Булева_алгебра)
   - |
-    [Конъюнкция](https://ru.wikipedia.org/wiki/Конъюнкция)
+    [Логическое «И»](https://ru.wikipedia.org/wiki/Конъюнкция)
   - |
-    [Дизъюнкция](https://ru.wikipedia.org/wiki/Дизъюнкция)
+    [Логическое «ИЛИ»](https://ru.wikipedia.org/wiki/Дизъюнкция)
 definitions:
   - name: Логические операторы
     description: >-
diff --git a/modules/45-logic/28-logical-negation/index.php b/modules/45-logic/28-logical-negation/Solution.php
similarity index 64%
rename from modules/45-logic/28-logical-negation/index.php
rename to modules/45-logic/28-logical-negation/Solution.php
index 91ca0da0..83c55578 100644
--- a/modules/45-logic/28-logical-negation/index.php
+++ b/modules/45-logic/28-logical-negation/Solution.php
@@ -2,16 +2,14 @@
 
 namespace HexletBasics\Logic\LogicalNegation;
 
-use function HexletBasics\Functions\mb_strrev;
-
 // BEGIN
-function isPalindrome($word)
+function isPalindrome(string $word): bool
 {
     $lowerWord = strtolower($word);
     return $lowerWord === strrev($lowerWord);
 }
 
-function isNotPalindrome($word)
+function isNotPalindrome(string $word): bool
 {
     return !isPalindrome($word);
 }
diff --git a/modules/45-logic/28-logical-negation/SolutionTest.php b/modules/45-logic/28-logical-negation/SolutionTest.php
index 14ea9b29..4c5971f8 100644
--- a/modules/45-logic/28-logical-negation/SolutionTest.php
+++ b/modules/45-logic/28-logical-negation/SolutionTest.php
@@ -2,14 +2,12 @@
 
 namespace HexletBasics\Logic\LogicalNegation;
 
-use PHPUnit\Framework\TestCase;
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        require 'index.php';
-
         $this->assertFalse(isNotPalindrome('wow'));
         $this->assertFalse(isNotPalindrome('asdffdsa'));
         $this->assertFalse(isNotPalindrome('Wow'));
diff --git a/modules/45-logic/28-logical-negation/ru/EXERCISE.md b/modules/45-logic/28-logical-negation/ru/EXERCISE.md
index 3cdfab51..b3b7da4e 100644
--- a/modules/45-logic/28-logical-negation/ru/EXERCISE.md
+++ b/modules/45-logic/28-logical-negation/ru/EXERCISE.md
@@ -1,7 +1,7 @@
 
-В этом уроке вам нужно будет реализовать две функции `isPalindrome()` и `isNotPalindrome()`
+В игре со словами участники проверяют, является ли слово палиндромом. Реализуйте две функции `isPalindrome()` и `isNotPalindrome()`, принимающие строку на вход
 
-1. Функция `isPalindrome()` определяет, является ли слово палиндромом или нет. Палиндром это слово, которое читается одинаково в обоих направлениях.
+1. Функция `isPalindrome()` определяет, является ли слово палиндромом или нет. Палиндром — это слово, которое читается одинаково в обоих направлениях.
 
     ```php
     <?php
diff --git a/modules/45-logic/28-logical-negation/ru/README.md b/modules/45-logic/28-logical-negation/ru/README.md
index 4ad4511a..f1d888e6 100644
--- a/modules/45-logic/28-logical-negation/ru/README.md
+++ b/modules/45-logic/28-logical-negation/ru/README.md
@@ -1,19 +1,108 @@
-Наряду с конъюнкцией (И) и дизъюнкцией (ИЛИ), часто используется операция «отрицание». Отрицание меняет логическое значение на противоположное.
+Наряду с логическими операторами **И** и **ИЛИ**, часто используется операция «**отрицание**». Она меняет логическое значение на противоположное. В PHP отрицанию соответствует унарный оператор `!`:
 
-В программировании ему соответствует унарный оператор `!`. Если есть функция, проверяющая четность числа, то с помощью отрицания можно выполнить проверку нечетности:
+```php
+<?php
+
+!true;  // false
+!false; // true
+```
+
+Например, если есть функция, которая проверяет четность числа, то с помощью отрицания можно выполнить проверку нечетности:
 
 ```php
 <?php
 
-function isEven($number)
+function isEven(int $number): bool
 {
     return $number % 2 === 0;
 }
 
-isEven(10);  // true
-!isEven(10); // false
-// В логике двойное отрицание подобно отсутствию отрицания вообще
-!!isEven(10); // true
+var_dump(isEven(10));  // => bool(true)
+var_dump(!isEven(10)); // => bool(false)
+```
+
+В примере выше мы добавили `!` слева от вызова функции и получили обратное действие.
+
+Отрицание позволяет выражать задуманные правила в коде без написания новых функций. Если написать `!!isEven(10)`, то код сработает даже в таком случае:
+
+```php
+<?php
+
+var_dump(!!isEven(10)); // => bool(true)
+```
+
+В логике двойное отрицание равносильно отсутствию отрицания:
+
+```php
+<?php
+
+!!true;  // true
+!!false; // false
+
+var_dump(!!isEven(10)); // => bool(true)
+var_dump(!!isEven(11)); // => bool(false)
+```
+
+`!` можно комбинировать с `&&` и `||`. Среди логических операторов у него наивысший приоритет, поэтому он применяется первым:
+
+```php
+<?php
+
+!true || true;  // (!true) || true   => false || true  => true
+!true && false; // (!true) && false  => false && false => false
+```
+
+Скобки меняют порядок вычисления:
+
+```php
+<?php
+
+!(true || true);  // !true  => false
+!(true && false); // !false => true
+```
+
+Практический пример — функция проверяет, может ли водитель сесть за руль: нужны права и трезвость:
+
+```php
+<?php
+
+function canDrive(bool $hasLicense, bool $isDrunk): bool
+{
+    return $hasLicense && !$isDrunk;
+}
+
+var_dump(canDrive(true, false));  // => bool(true)  (есть права, трезвый)
+var_dump(canDrive(true, true));   // => bool(false) (есть права, но пьяный)
+var_dump(canDrive(false, false)); // => bool(false) (нет прав)
+```
+
+Теперь вы знаете, что означают операторы **И**, **ИЛИ** и `!`. С их помощью вы сможете задавать составные условия из двух и более логических выражений.
+
+## Законы де Моргана
+
+При работе со сложными логическими выражениями бывает нужно их инвертировать или переписать в эквивалентную форму, которую легче читать. Для этого существуют **законы де Моргана** — два правила, которые описывают, как отрицание распределяется по составному выражению:
+
+```text
+!(A && B)  эквивалентно  !A || !B
+!(A || B)  эквивалентно  !A && !B
+```
+
+Первый закон: отрицание конъюнкции равно дизъюнкции отрицаний. Проверим:
+
+```php
+<?php
+
+!(true && false); // !false => true
+!true || !false;  // false || true => true
+```
+
+Второй закон: отрицание дизъюнкции равно конъюнкции отрицаний:
+
+```php
+<?php
+
+!(true || false); // !true => false
+!true && !false;  // false && true => false
 ```
 
-Мы просто добавили `!` слева от вызова функции и получили обратное действие. Отрицание — мощный инструмент, который позволяет лаконично выражать задуманные правила в коде без необходимости писать новые функции.
+На практике законы де Моргана помогают упрощать условия. Например, вместо `!($isAdmin || $isModerator)` можно написать `!$isAdmin && !$isModerator` — читается как «не администратор и не модератор».
diff --git a/modules/45-logic/28-logical-negation/ru/data.yml b/modules/45-logic/28-logical-negation/ru/data.yml
index dd24f7f1..b8232201 100644
--- a/modules/45-logic/28-logical-negation/ru/data.yml
+++ b/modules/45-logic/28-logical-negation/ru/data.yml
@@ -3,3 +3,8 @@ name: Отрицание
 tips:
   - |
     [Законы Де Моргана](https://ru.wikipedia.org/wiki/Законы_де_Моргана)
+definitions:
+  - name: Отрицание
+    description: >
+      логическая операция, которая меняет логическое значение на
+      противоположное.
diff --git a/modules/45-logic/29-logical-operators-2/SolutionTest.php b/modules/45-logic/29-logical-operators-2/SolutionTest.php
deleted file mode 100644
index 892e568b..00000000
--- a/modules/45-logic/29-logical-operators-2/SolutionTest.php
+++ /dev/null
@@ -1,20 +0,0 @@
-<?php
-
-namespace HexletBasics\Logic\LogicalOperators2;
-
-use PHPUnit\Framework\TestCase;
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        require 'index.php';
-
-        $this->assertTrue(isNeutralSoldier('yellow', 'black'));
-        $this->assertFalse(isNeutralSoldier('red', 'yellow'));
-        $this->assertFalse(isNeutralSoldier('red', 'red'));
-        $this->assertFalse(isNeutralSoldier('red', 'black'));
-        $this->assertFalse(isNeutralSoldier('yellow', 'red'));
-        $this->assertTrue(isNeutralSoldier('black', 'black'));
-    }
-}
diff --git a/modules/45-logic/29-logical-operators-2/description.es.yml b/modules/45-logic/29-logical-operators-2/description.es.yml
deleted file mode 100644
index 08f7c1c8..00000000
--- a/modules/45-logic/29-logical-operators-2/description.es.yml
+++ /dev/null
@@ -1,49 +0,0 @@
----
-
-name: Operadores lógicos 2
-theory: |
-
-  Los operadores lógicos son un tema importante, por lo que es necesario reforzarlo con un ejemplo y un ejercicio adicional.
-
-  Intentemos implementar una función que verifique si un año es bisiesto. Un año es bisiesto si es divisible por 400 o si es divisible por 4 y no es divisible por 100. Como puedes ver, toda la lógica necesaria ya está definida, solo falta trasladarla al código:
-
-  ```php
-  <?php
-
-  function esBisiesto($año)
-  {
-      return $año % 400 === 0 || ($año % 4 === 0 && $año % 100 !== 0);
-  }
-
-  esBisiesto(2018); // false
-  esBisiesto(2017); // false
-  esBisiesto(2016); // true
-  ```
-
-  Veamos cada parte:
-
-  - La primera condición `$año % 400 === 0`: el resto de la división por 400 es igual a 0, lo que significa que el número es divisible por 400.
-  - `||` **O**
-  - La segunda condición `($año % 4 === 0 && $año % 100 !== 0)`
-      - `$año % 4 === 0`: el resto de la división por 4 es igual a 0, lo que significa que el número es divisible por 4.
-      - `&&` **Y**
-      - `$año % 100 !== 0`: el resto de la división por 100 no es igual a 0, lo que significa que el número no es divisible por 100.
-
-instructions: |
-
-  Escribe una función `isNeutralSoldier()` que reciba dos argumentos:
-
-  1. El color de la armadura (cadena de texto). Opciones posibles: `red`, `yellow`, `black`.
-  2. El color del escudo (cadena de texto). Opciones posibles: `red`, `yellow`, `black`.
-
-  La función devuelve `true` si *el color de la armadura no es rojo* y *el color del escudo es negro*. En caso contrario, devuelve `false`.
-
-  Ejemplos de uso:
-
-  ```php
-  <?php
-
-  isNeutralSoldier('yellow', 'black'); // true
-  isNeutralSoldier('red', 'black');    // false
-  isNeutralSoldier('red', 'red');      // false
-  ```
diff --git a/modules/45-logic/29-logical-operators-2/en/EXERCISE.md b/modules/45-logic/29-logical-operators-2/en/EXERCISE.md
deleted file mode 100644
index e85e36e8..00000000
--- a/modules/45-logic/29-logical-operators-2/en/EXERCISE.md
+++ /dev/null
@@ -1,17 +0,0 @@
-
-Write a function `isNeutralSoldier()`, that takes two arguments as input:
-
-1. Armor color (string). Possible variants: `red`, `yellow`, `black`.
-2. Shield color (string). Possible variants: `red`, `yellow`, `black`.
-
-The function returns `true` if *the color of the armor is not red and the color of the shield is black*. In other cases, it returns `false`.
-
-Call examples:
-
-```php
-<?php
-
-isNeutralSoldier('yellow', 'black'); // true
-isNeutralSoldier('red', 'black');    // false
-isNeutralSoldier('red', 'red');      // false
-```
diff --git a/modules/45-logic/29-logical-operators-2/en/README.md b/modules/45-logic/29-logical-operators-2/en/README.md
deleted file mode 100644
index 1ab9f53a..00000000
--- a/modules/45-logic/29-logical-operators-2/en/README.md
+++ /dev/null
@@ -1,26 +0,0 @@
-
-Logical operators are an important topic, so it's worth reinforcing them with some more examples and practice.
-
-Let's try to implement a function that checks a year to see if it's a leap year. A year is a leap year if it's a multiple of 400, or if it's both a multiple of 4 and not a multiple of 100. As you can see, the definition already contains all the required logic, all we need to do is to put it into code:
-
-```php
-<?php
-
-function isLeapYear($year)
-{
-    return $year % 400 === 0 || ($year % 4 === 0 && $year % 100 !== 0);
-}
-
-isLeapYear(2018); // false
-isLeapYear(2017); // false
-isLeapYear(2016); // true
-```
-
-Let's break it down piece by piece:
-
-- the first condition, `$year % 400 === 0`: means the remainder of division by 400 is 0, so the number is a multiple of 400
-- `||` **OR**
-- second condition `($year % 4 === 0 && $year % 100 !== 0)`
-    - `year % 4 === 0`: means the remainder of division by 4 is 0, so the number is a multiple of 4
-    - `&&` **AND**
-    - `$year % 100 !== 0`: means the remainder of division by 100 is not 0, so the number is not a multiple of 100
diff --git a/modules/45-logic/29-logical-operators-2/en/data.yml b/modules/45-logic/29-logical-operators-2/en/data.yml
deleted file mode 100644
index e925fe16..00000000
--- a/modules/45-logic/29-logical-operators-2/en/data.yml
+++ /dev/null
@@ -1,2 +0,0 @@
----
-name: Logical Operators 2
diff --git a/modules/45-logic/29-logical-operators-2/es/EXERCISE.md b/modules/45-logic/29-logical-operators-2/es/EXERCISE.md
deleted file mode 100644
index 9a0a3920..00000000
--- a/modules/45-logic/29-logical-operators-2/es/EXERCISE.md
+++ /dev/null
@@ -1,17 +0,0 @@
-
-Escribe una función `isNeutralSoldier()` que reciba dos argumentos:
-
-1. El color de la armadura (cadena de texto). Opciones posibles: `red`, `yellow`, `black`.
-2. El color del escudo (cadena de texto). Opciones posibles: `red`, `yellow`, `black`.
-
-La función devuelve `true` si *el color de la armadura no es rojo* y *el color del escudo es negro*. En caso contrario, devuelve `false`.
-
-Ejemplos de uso:
-
-```php
-<?php
-
-isNeutralSoldier('yellow', 'black'); // true
-isNeutralSoldier('red', 'black');    // false
-isNeutralSoldier('red', 'red');      // false
-```
diff --git a/modules/45-logic/29-logical-operators-2/es/README.md b/modules/45-logic/29-logical-operators-2/es/README.md
deleted file mode 100644
index e3018563..00000000
--- a/modules/45-logic/29-logical-operators-2/es/README.md
+++ /dev/null
@@ -1,26 +0,0 @@
-
-Los operadores lógicos son un tema importante, por lo que es necesario reforzarlo con un ejemplo y un ejercicio adicional.
-
-Intentemos implementar una función que verifique si un año es bisiesto. Un año es bisiesto si es divisible por 400 o si es divisible por 4 y no es divisible por 100. Como puedes ver, toda la lógica necesaria ya está definida, solo falta trasladarla al código:
-
-```php
-<?php
-
-function esBisiesto($año)
-{
-    return $año % 400 === 0 || ($año % 4 === 0 && $año % 100 !== 0);
-}
-
-esBisiesto(2018); // false
-esBisiesto(2017); // false
-esBisiesto(2016); // true
-```
-
-Veamos cada parte:
-
-- La primera condición `$año % 400 === 0`: el resto de la división por 400 es igual a 0, lo que significa que el número es divisible por 400.
-- `||` **O**
-- La segunda condición `($año % 4 === 0 && $año % 100 !== 0)`
-    - `$año % 4 === 0`: el resto de la división por 4 es igual a 0, lo que significa que el número es divisible por 4.
-    - `&&` **Y**
-    - `$año % 100 !== 0`: el resto de la división por 100 no es igual a 0, lo que significa que el número no es divisible por 100.
diff --git a/modules/45-logic/29-logical-operators-2/es/data.yml b/modules/45-logic/29-logical-operators-2/es/data.yml
deleted file mode 100644
index ad71a9f4..00000000
--- a/modules/45-logic/29-logical-operators-2/es/data.yml
+++ /dev/null
@@ -1,2 +0,0 @@
----
-name: Operadores lógicos 2
diff --git a/modules/45-logic/29-logical-operators-2/index.php b/modules/45-logic/29-logical-operators-2/index.php
deleted file mode 100644
index 1c9ff633..00000000
--- a/modules/45-logic/29-logical-operators-2/index.php
+++ /dev/null
@@ -1,10 +0,0 @@
-<?php
-
-namespace HexletBasics\Logic\LogicalOperators2;
-
-// BEGIN
-function isNeutralSoldier($armorColor, $shieldColor)
-{
-    return ($armorColor !== 'red' && $shieldColor === 'black');
-}
-// END
diff --git a/modules/45-logic/29-logical-operators-2/ru/EXERCISE.md b/modules/45-logic/29-logical-operators-2/ru/EXERCISE.md
deleted file mode 100644
index 279f7dd8..00000000
--- a/modules/45-logic/29-logical-operators-2/ru/EXERCISE.md
+++ /dev/null
@@ -1,17 +0,0 @@
-
-Напишите функцию `isNeutralSoldier()`, которая принимает на вход два аргумента:
-
-1. Цвет доспехов (строка). Возможные варианты: `red`, `yellow`, `black`.
-2. Цвет щита (строка). Возможные варианты: `red`, `yellow`, `black`.
-
-Функция возвращает `true` если *цвет доспехов не красный* и *цвет щита чёрный*. В остальных случаях возвращает `false`.
-
-Примеры вызова:
-
-```php
-<?php
-
-isNeutralSoldier('yellow', 'black'); // true
-isNeutralSoldier('red', 'black');    // false
-isNeutralSoldier('red', 'red');      // false
-```
diff --git a/modules/45-logic/29-logical-operators-2/ru/README.md b/modules/45-logic/29-logical-operators-2/ru/README.md
deleted file mode 100644
index 334f8317..00000000
--- a/modules/45-logic/29-logical-operators-2/ru/README.md
+++ /dev/null
@@ -1,26 +0,0 @@
-
-Логические операторы — важная тема, поэтому стоит закрепить её дополнительным примером и упражнением.
-
-Попробуем реализовать функцию, проверяющую год на високосность. Год будет високосным, если он кратен 400 или он одновременно кратен 4 и не кратен 100. Как видите, в определении уже заложена вся необходимая логика, осталось только переложить её на код:
-
-```php
-<?php
-
-function isLeapYear($year)
-{
-    return $year % 400 === 0 || ($year % 4 === 0 && $year % 100 !== 0);
-}
-
-isLeapYear(2018); // false
-isLeapYear(2017); // false
-isLeapYear(2016); // true
-```
-
-Разберём по частям:
-
-- первое условие `$year % 400 === 0`: остаток от деления на 400 равен 0, значит, число кратно 400
-- `||` **ИЛИ**
-- второе условие `($year % 4 === 0 && $year % 100 !== 0)`
-    - `year % 4 === 0`: остаток от деления на 4 равен 0, значит, число кратно 4
-    - `&&` **И**
-    - `$year % 100 !== 0`: остаток от деления на 100 не равен 0, значит, число не кратно 100
diff --git a/modules/45-logic/29-logical-operators-2/ru/data.yml b/modules/45-logic/29-logical-operators-2/ru/data.yml
deleted file mode 100644
index 88ffe1c8..00000000
--- a/modules/45-logic/29-logical-operators-2/ru/data.yml
+++ /dev/null
@@ -1,2 +0,0 @@
----
-name: Логические операторы 2
diff --git a/modules/45-logic/70-logic-weak-typing/description.es.yml b/modules/45-logic/70-logic-weak-typing/description.es.yml
deleted file mode 100644
index db83d7ad..00000000
--- a/modules/45-logic/70-logic-weak-typing/description.es.yml
+++ /dev/null
@@ -1,75 +0,0 @@
----
-
-name: Tipado débil - 2
-theory: |
-  Recordemos que PHP es un lenguaje con **tipado débil**:
-
-  * Conoce la existencia de diferentes tipos (números, cadenas, etc.)
-  * Sin embargo, no es muy estricto en su uso, tratando de convertir la información cuando parece razonable
-
-  Se producen muchas conversiones automáticas al trabajar con operaciones lógicas. En PHP hay dos reglas simples para las conversiones:
-
-  * `0`, `null` y la cadena vacía `''` se convierten en `false`, por lo que se llaman *falsy*
-  * Todo lo demás se convierte en `true`
-
-  Esto también funciona en sentido contrario. Tanto `true` como `false` se convierten en otros tipos de datos según la situación:
-
-  ```php
-  <?php
-
-  print_r(true);   // => 1
-  print_r(false);  // => (se muestra una cadena vacía en la pantalla)
-  print_r(0 || 1); // => 1
-  ```
-
-  El operador **OR** solo funciona con el tipo *bool*, pero se le dan los números `1` y `0`:
-
-  1. `0` se convierte en `false` y `1` se convierte en `true`
-  2. El resultado de `false || true` es `true`
-  3. Ahora `print_r()` recibe `true`, pero solo funciona con cadenas
-  4. `true` se convierte en `1`
-  5. Y se muestra `1` en la pantalla
-
-  Aquí es importante destacar la diferencia entre los operadores `===` y `==`. La diferencia radica en la conversión de tipos.
-
-  La cadena vacía y `false` son valores diferentes, por lo que el operador `===` dice "¡Falso! ¡No son iguales!".
-
-  Pero el operador `==` convierte los tipos. Desde su punto de vista, la cadena vacía y `false` son iguales. Esta conversión es implícita, por lo que se recomienda evitar los operadores `==` y `!=` siempre que sea posible:
-
-  ```php
-  <?php
-
-  var_dump('' === false); // => false
-  var_dump('' == false);  // => true
-  ```
-
-  Recordemos la operación de negación. Con una doble negación `!!`, el valor final es igual al valor inicial:
-
-  ```php
-  <?php
-
-  $respuesta = true;
-  var_dump(!$respuesta);  // => false
-  var_dump(!!$respuesta); // => true
-  ```
-
-  Aquí también se producen conversiones de tipo adicionales. Por lo tanto, el resultado de una doble negación siempre será de tipo _bool_. Se utiliza este truco para cambiar el tipo de datos.
-
-  En diferentes lenguajes de programación, hay diferentes reglas de conversión. Algunos lenguajes no realizan conversiones de tipos por sí mismos.
-
-instructions: |
-
-  Escribe una función `isFalsy()` que verifique si el valor pasado se interpreta como falso en PHP. Para realizar esta verificación, deberás comparar `false` con el valor pasado utilizando `==`.
-
-  ```php
-  <?php
-
-  isFalsy(false);  // true
-  isFalsy(0);      // true
-  isFalsy('ayuda'); // false
-  isFalsy(10);     // false
-  ```
-
-tips:
-  - |
-    [Booleanos](https://php.net/manual/es/language.types.boolean.php)
diff --git a/modules/45-logic/70-logic-weak-typing/en/EXERCISE.md b/modules/45-logic/70-logic-weak-typing/en/EXERCISE.md
deleted file mode 100644
index e8a72d27..00000000
--- a/modules/45-logic/70-logic-weak-typing/en/EXERCISE.md
+++ /dev/null
@@ -1,11 +0,0 @@
-
-Write an `isFalsy()` function that checks if the passed value is interpreted as false from PHP's point of view. To do this check, you need to compare `false` with the passed value using `==`.
-
-```php
-<?php
-
-isFalsy(false);  // true
-isFalsy(0);      // true
-isFalsy('help'); // false
-isFalsy(10);     // false
-```
diff --git a/modules/45-logic/70-logic-weak-typing/en/README.md b/modules/45-logic/70-logic-weak-typing/en/README.md
deleted file mode 100644
index 68d381a5..00000000
--- a/modules/45-logic/70-logic-weak-typing/en/README.md
+++ /dev/null
@@ -1,98 +0,0 @@
-
-In the Arithmetic module, we touched on the topic of weak typing.
-
-PHP is a **weakly typed** language. It recognizes different data types (numbers, strings, etc.), but doesn't use them too strictly, it tries to convert data when it seems reasonable.
-
-A particularly large number of automatic transformations take place when working with logical operations.
-
-In PHP there are two simple rules by which conversions take place:
-
-* `0`, `'0'`, `''` (empty string), `null` are set to `false`. These values are called *falsy*.
-* Everything else becomes `true`.
-
-This works the other way as well: `true` and `false` are converted to other data types, depending on the situation:
-
-```php
-<?php
-
-print_r(true);
-```
-
-```text
-1
-```
-
-```php
-<?php
-
-print_r(false);
-```
-
-```text
-
-```
-
-*(an empty string has been printed)*
-
-Another example:
-
-```php
-<?php
-
-print_r(0 || 1);
-```
-
-```text
-1
-```
-
-What happened here:
-
-The **OR** operator only works with the *bool* type, but it's also given the numbers `1` and `0`.
-
-1. `0` is converted to `false` and `1` is converted to `true`.
-2. The result `false || true` is `true`.
-3. Now `print_r()` gets `true`,  but it only works with strings (not *bool*).
-4. `true` is converted to `1`.
-5. And the screen displays `1`.
-
----
-
-In one of our lessons, we looked at the comparison operators `===` and `!==` and mentioned that PHP also has the operators `==` and `!=`, but we shouldn't use them. The difference lies in type conversion:
-
-```php
-<?php
-
-var_dump('' === false); // => false
-var_dump('' == false);  // => true
-```
-
-An empty string and `false` are different values, so the `===` operator says "false! they're not equal!
-
-But the `==` operator converts types, making an empty string and `false` equivalent from its point of view. This conversion is implicit, so avoid the `==` and `!=` operators whenever possible.
-
----
-
-Remember the negation operator:
-
-```php
-<?php
-
-$answer = true;
-var_dump(!$answer); // => false
-```
-
-When you use double negation `!!` the result value is equal to the initial value:
-
-```php
-<?php
-
-$answer = true;
-var_dump(!!$answer); // => true
-```
-
-However, this is where type conversions also take place. Therefore, the result of a double negation will always be a _bool_. This trick is used to change the data type.
-
----
-
-Different programming languages have different transformation rules. Some languages don't convert types themselves at all. Many features of PHP aren't really the best, but this is the historical legacy of the language. If it were created from scratch today, many of the rules and nuances would probably be quite different.
diff --git a/modules/45-logic/70-logic-weak-typing/en/data.yml b/modules/45-logic/70-logic-weak-typing/en/data.yml
deleted file mode 100644
index 4cce6ac6..00000000
--- a/modules/45-logic/70-logic-weak-typing/en/data.yml
+++ /dev/null
@@ -1,5 +0,0 @@
----
-name: Weak Typing - 2
-tips:
-  - |
-    [Booleans](https://www.php.net/manual/en/language.types.boolean.php)
diff --git a/modules/45-logic/70-logic-weak-typing/es/EXERCISE.md b/modules/45-logic/70-logic-weak-typing/es/EXERCISE.md
deleted file mode 100644
index 6b622f37..00000000
--- a/modules/45-logic/70-logic-weak-typing/es/EXERCISE.md
+++ /dev/null
@@ -1,11 +0,0 @@
-
-Escribe una función `isFalsy()` que verifique si el valor pasado se interpreta como falso en PHP. Para realizar esta verificación, deberás comparar `false` con el valor pasado utilizando `==`.
-
-```php
-<?php
-
-isFalsy(false);  // true
-isFalsy(0);      // true
-isFalsy('ayuda'); // false
-isFalsy(10);     // false
-```
diff --git a/modules/45-logic/70-logic-weak-typing/es/README.md b/modules/45-logic/70-logic-weak-typing/es/README.md
deleted file mode 100644
index 439225fd..00000000
--- a/modules/45-logic/70-logic-weak-typing/es/README.md
+++ /dev/null
@@ -1,54 +0,0 @@
-Recordemos que PHP es un lenguaje con **tipado débil**:
-
-* Conoce la existencia de diferentes tipos (números, cadenas, etc.)
-* Sin embargo, no es muy estricto en su uso, tratando de convertir la información cuando parece razonable
-
-Se producen muchas conversiones automáticas al trabajar con operaciones lógicas. En PHP hay dos reglas simples para las conversiones:
-
-* `0`, `null` y la cadena vacía `''` se convierten en `false`, por lo que se llaman *falsy*
-* Todo lo demás se convierte en `true`
-
-Esto también funciona en sentido contrario. Tanto `true` como `false` se convierten en otros tipos de datos según la situación:
-
-```php
-<?php
-
-print_r(true);   // => 1
-print_r(false);  // => (se muestra una cadena vacía en la pantalla)
-print_r(0 || 1); // => 1
-```
-
-El operador **OR** solo funciona con el tipo *bool*, pero se le dan los números `1` y `0`:
-
-1. `0` se convierte en `false` y `1` se convierte en `true`
-2. El resultado de `false || true` es `true`
-3. Ahora `print_r()` recibe `true`, pero solo funciona con cadenas
-4. `true` se convierte en `1`
-5. Y se muestra `1` en la pantalla
-
-Aquí es importante destacar la diferencia entre los operadores `===` y `==`. La diferencia radica en la conversión de tipos.
-
-La cadena vacía y `false` son valores diferentes, por lo que el operador `===` dice "¡Falso! ¡No son iguales!".
-
-Pero el operador `==` convierte los tipos. Desde su punto de vista, la cadena vacía y `false` son iguales. Esta conversión es implícita, por lo que se recomienda evitar los operadores `==` y `!=` siempre que sea posible:
-
-```php
-<?php
-
-var_dump('' === false); // => false
-var_dump('' == false);  // => true
-```
-
-Recordemos la operación de negación. Con una doble negación `!!`, el valor final es igual al valor inicial:
-
-```php
-<?php
-
-$respuesta = true;
-var_dump(!$respuesta);  // => false
-var_dump(!!$respuesta); // => true
-```
-
-Aquí también se producen conversiones de tipo adicionales. Por lo tanto, el resultado de una doble negación siempre será de tipo _bool_. Se utiliza este truco para cambiar el tipo de datos.
-
-En diferentes lenguajes de programación, hay diferentes reglas de conversión. Algunos lenguajes no realizan conversiones de tipos por sí mismos.
diff --git a/modules/45-logic/70-logic-weak-typing/es/data.yml b/modules/45-logic/70-logic-weak-typing/es/data.yml
deleted file mode 100644
index e6788258..00000000
--- a/modules/45-logic/70-logic-weak-typing/es/data.yml
+++ /dev/null
@@ -1,5 +0,0 @@
----
-name: Tipado débil - 2
-tips:
-  - |
-    [Booleanos](https://php.net/manual/es/language.types.boolean.php)
diff --git a/modules/45-logic/70-logic-weak-typing/index.php b/modules/45-logic/70-logic-weak-typing/index.php
deleted file mode 100644
index 0e6f104f..00000000
--- a/modules/45-logic/70-logic-weak-typing/index.php
+++ /dev/null
@@ -1,10 +0,0 @@
-<?php
-
-namespace HexletBasics\Logic\WeakTyping;
-
-// BEGIN
-function isFalsy($value)
-{
-    return $value == false;
-}
-// END
diff --git a/modules/45-logic/70-logic-weak-typing/ru/EXERCISE.md b/modules/45-logic/70-logic-weak-typing/ru/EXERCISE.md
deleted file mode 100644
index 96509082..00000000
--- a/modules/45-logic/70-logic-weak-typing/ru/EXERCISE.md
+++ /dev/null
@@ -1,11 +0,0 @@
-
-Напишите функцию `isFalsy()`, которая проверяет, трактуется ли переданное значение как ложное с точки зрения PHP. Для выполнения этой проверки вам понадобится сравнить `false` с переданным значением, используя `==`.
-
-```php
-<?php
-
-isFalsy(false);  // true
-isFalsy(0);      // true
-isFalsy('help'); // false
-isFalsy(10);     // false
-```
diff --git a/modules/45-logic/70-logic-weak-typing/ru/README.md b/modules/45-logic/70-logic-weak-typing/ru/README.md
deleted file mode 100644
index 1c3e1b88..00000000
--- a/modules/45-logic/70-logic-weak-typing/ru/README.md
+++ /dev/null
@@ -1,54 +0,0 @@
-Напомним, что PHP — это язык со **слабой типизацией**:
-
-* Он знает о существовании разных типов (числа, строки и так далее)
-* При этом он относится к их использованию не очень строго, пытаясь преобразовывать информацию, когда это кажется разумным
-
-Особенно много автоматических преобразований происходит при работе с логическими операциями. В PHP есть два простых правила, по которым происходят преобразования:
-
-* `0`, `null` и пустая строка `''` приводятся к `false`, поэтому эти значения называют *falsy*
-* Все остальное превращается в `true`
-
-Это работает и в другую сторону. И `true`, и `false` преобразовываются в другие типы данных в зависимости от ситуации:
-
-```php
-<?php
-
-print_r(true);   // => 1
-print_r(false);  // => (на экран выводится пустая строка)
-print_r(0 || 1); // => 1
-```
-
-Оператор **ИЛИ** работает только с типом *bool*, но ему даны числа `1` и `0`:
-
-1. `0` преобразуется в `false`, а `1` преобразуется в `true`
-2. Результат `false || true` — это `true`
-3. Теперь `print_r()` получает `true`, но он работает только со строками
-4. `true` преобразуется в `1`
-5. И на экран выводится `1`
-
-Здесь важно отметить также отличие операторов `===` и `==`. Оно как раз заключается в преобразовании типов.
-
-Пустая строка и `false` — это разные значения, поэтому оператор `===` говорит «Ложь! Они не равны!».
-
-Но оператор `==` преобразует типы. С его точки зрения, пустая строка и `false` равны. Это преобразование неявное, поэтому по возможности избегайте операторов `==` и `!=`:
-
-```php
-<?php
-
-var_dump('' === false); // => false
-var_dump('' == false);  // => true
-```
-
-Вспомним операцию отрицания. При двойном отрицании `!!` итоговое значение равно начальному:
-
-```php
-<?php
-
-$answer = true;
-var_dump(!$answer);  // => false
-var_dump(!!$answer); // => true
-```
-
-Здесь также дополнительно происходят преобразования типа. Поэтому результатом двойного отрицания всегда будет _bool_. Этим приемом пользуются, чтобы поменять тип данных.
-
-В разных языках программирования разные правила преобразований. Некоторые языки вообще не преобразовывают типы сами.
diff --git a/modules/45-logic/70-logic-weak-typing/ru/data.yml b/modules/45-logic/70-logic-weak-typing/ru/data.yml
deleted file mode 100644
index ace54acc..00000000
--- a/modules/45-logic/70-logic-weak-typing/ru/data.yml
+++ /dev/null
@@ -1,5 +0,0 @@
----
-name: Слабая типизация - 2
-tips:
-  - |
-    [Booleans](https://php.net/manual/ru/language.types.boolean.php)
diff --git a/modules/50-loops/29-edge-cases/Makefile b/modules/45-logic/90-logical-expressions/Makefile
similarity index 100%
rename from modules/50-loops/29-edge-cases/Makefile
rename to modules/45-logic/90-logical-expressions/Makefile
diff --git a/modules/45-logic/90-logical-expressions/Solution.php b/modules/45-logic/90-logical-expressions/Solution.php
new file mode 100644
index 00000000..6a82af89
--- /dev/null
+++ b/modules/45-logic/90-logical-expressions/Solution.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace HexletBasics\Logic\LogicalExpressions;
+
+// BEGIN
+function isFalsy(int|float|string|bool|null $value): bool
+{
+    return $value == false;
+}
+// END
diff --git a/modules/45-logic/70-logic-weak-typing/SolutionTest.php b/modules/45-logic/90-logical-expressions/SolutionTest.php
similarity index 66%
rename from modules/45-logic/70-logic-weak-typing/SolutionTest.php
rename to modules/45-logic/90-logical-expressions/SolutionTest.php
index 7d20184d..b8f80adb 100644
--- a/modules/45-logic/70-logic-weak-typing/SolutionTest.php
+++ b/modules/45-logic/90-logical-expressions/SolutionTest.php
@@ -1,20 +1,20 @@
 <?php
 
-namespace HexletBasics\Logic\WeakTyping;
+namespace HexletBasics\Logic\LogicalExpressions;
 
-use PHPUnit\Framework\TestCase;
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        require 'index.php';
-
         $this->assertTrue(isFalsy(''));
         $this->assertFalse(isFalsy(' '));
         $this->assertTrue(isFalsy(null));
         $this->assertTrue(isFalsy(false));
+        $this->assertTrue(isFalsy('0'));
         $this->assertFalse(isFalsy(true));
         $this->assertFalse(isFalsy(3));
+        $this->assertFalse(isFalsy('help'));
     }
 }
diff --git a/modules/45-logic/90-logical-expressions/description.es.yml b/modules/45-logic/90-logical-expressions/description.es.yml
new file mode 100644
index 00000000..ddff25ca
--- /dev/null
+++ b/modules/45-logic/90-logical-expressions/description.es.yml
@@ -0,0 +1,57 @@
+---
+
+name: Resultado de expresiones lógicas
+theory: |
+  En las expresiones lógicas se pueden usar no solo valores de tipo `bool`. Cuando un valor entra en un contexto lógico, PHP lo convierte en `true` o `false`.
+
+  Hay un conjunto fijo de valores **falsy**: `false`, `0` (y `0.0`), la cadena vacía `''`, la cadena `'0'` y `null`. Todo lo demás es **truthy**. Se puede comprobar con la doble negación `!!`, que convierte cualquier valor a `bool`:
+
+  ```php
+  <?php
+
+  var_dump(!!'hello'); // => bool(true)
+  var_dump(!!'');      // => bool(false)
+  var_dump(!!'0');     // => bool(false) — una particularidad de PHP
+  ```
+
+  A diferencia de muchos lenguajes donde `&&` y `||` devuelven uno de sus operandos, en PHP los operadores lógicos siempre devuelven un `bool`:
+
+  ```php
+  <?php
+
+  var_dump('hello' && 'world'); // => bool(true)
+  var_dump(0 || 1);             // => bool(true)
+  ```
+
+  La conversión de tipos también ocurre con la comparación no estricta. El operador `==` convierte los operandos antes de comparar, por lo que una cadena vacía es igual a `false` desde su punto de vista. Esta conversión es implícita, así que evita `==` y `!=` siempre que sea posible:
+
+  ```php
+  <?php
+
+  var_dump('' === false); // => bool(false)
+  var_dump('' == false);  // => bool(true)
+  ```
+
+  Un error común de principiante es escribir `$value === ('first' || 'second')`. Primero se evalúan los paréntesis: ambas cadenas son truthy, el resultado es `true`, y toda la expresión se convierte en `$value === true` — siempre falsa para cadenas. La comprobación correcta es:
+
+  ```php
+  <?php
+
+  $value === 'first' || $value === 'second';
+  ```
+
+instructions: |
+  Escribe una función `isFalsy()` que compruebe si el valor dado se trata como falso (falsy) desde el punto de vista de PHP. Para realizar esta comprobación, compara el valor con `false` usando la comparación no estricta `==`.
+
+  ```php
+  <?php
+
+  isFalsy(false);  // true
+  isFalsy(0);      // true
+  isFalsy('help'); // false
+  isFalsy(10);     // false
+  ```
+
+tips:
+  - |
+    [Booleanos en PHP](https://www.php.net/manual/es/language.types.boolean.php)
diff --git a/modules/45-logic/90-logical-expressions/en/EXERCISE.md b/modules/45-logic/90-logical-expressions/en/EXERCISE.md
new file mode 100644
index 00000000..c3d092c8
--- /dev/null
+++ b/modules/45-logic/90-logical-expressions/en/EXERCISE.md
@@ -0,0 +1,10 @@
+Write a function `isFalsy()` that checks whether the given value is treated as falsy by PHP. To perform this check, compare the value with `false` using the loose comparison `==`.
+
+```php
+<?php
+
+isFalsy(false);  // true
+isFalsy(0);      // true
+isFalsy('help'); // false
+isFalsy(10);     // false
+```
diff --git a/modules/45-logic/90-logical-expressions/en/README.md b/modules/45-logic/90-logical-expressions/en/README.md
new file mode 100644
index 00000000..1b7bf315
--- /dev/null
+++ b/modules/45-logic/90-logical-expressions/en/README.md
@@ -0,0 +1,37 @@
+Logical expressions can use more than just `bool` values. When a value gets into a logical context, PHP converts it to `true` or `false`.
+
+There is a fixed set of **falsy** values: `false`, `0` (and `0.0`), the empty string `''`, the string `'0'`, and `null`. Everything else is **truthy**. You can check this with the double negation `!!`, which converts any value to `bool`:
+
+```php
+<?php
+
+var_dump(!!'hello'); // => bool(true)
+var_dump(!!'');      // => bool(false)
+var_dump(!!'0');     // => bool(false) — a PHP peculiarity
+```
+
+Unlike many languages where `&&` and `||` return one of their operands, in PHP logical operators always return a `bool`:
+
+```php
+<?php
+
+var_dump('hello' && 'world'); // => bool(true)
+var_dump(0 || 1);             // => bool(true)
+```
+
+Type conversion also happens with loose comparison. The `==` operator converts operands before comparing, so an empty string equals `false` from its point of view. This conversion is implicit, so avoid `==` and `!=` whenever possible:
+
+```php
+<?php
+
+var_dump('' === false); // => bool(false)
+var_dump('' == false);  // => bool(true)
+```
+
+A common beginner mistake is writing `$value === ('first' || 'second')`. The parentheses evaluate first: both strings are truthy, so the result is `true`, and the whole expression becomes `$value === true` — always false for strings. The correct check is:
+
+```php
+<?php
+
+$value === 'first' || $value === 'second';
+```
diff --git a/modules/45-logic/90-logical-expressions/en/data.yml b/modules/45-logic/90-logical-expressions/en/data.yml
new file mode 100644
index 00000000..6957334a
--- /dev/null
+++ b/modules/45-logic/90-logical-expressions/en/data.yml
@@ -0,0 +1,5 @@
+---
+name: Logical expressions output
+tips:
+  - |
+    [Booleans in PHP](https://www.php.net/manual/en/language.types.boolean.php)
diff --git a/modules/45-logic/90-logical-expressions/es/EXERCISE.md b/modules/45-logic/90-logical-expressions/es/EXERCISE.md
new file mode 100644
index 00000000..e4895549
--- /dev/null
+++ b/modules/45-logic/90-logical-expressions/es/EXERCISE.md
@@ -0,0 +1,10 @@
+Escribe una función `isFalsy()` que compruebe si el valor dado se trata como falso (falsy) desde el punto de vista de PHP. Para realizar esta comprobación, compara el valor con `false` usando la comparación no estricta `==`.
+
+```php
+<?php
+
+isFalsy(false);  // true
+isFalsy(0);      // true
+isFalsy('help'); // false
+isFalsy(10);     // false
+```
diff --git a/modules/45-logic/90-logical-expressions/es/README.md b/modules/45-logic/90-logical-expressions/es/README.md
new file mode 100644
index 00000000..e25d5489
--- /dev/null
+++ b/modules/45-logic/90-logical-expressions/es/README.md
@@ -0,0 +1,37 @@
+En las expresiones lógicas se pueden usar no solo valores de tipo `bool`. Cuando un valor entra en un contexto lógico, PHP lo convierte en `true` o `false`.
+
+Hay un conjunto fijo de valores **falsy**: `false`, `0` (y `0.0`), la cadena vacía `''`, la cadena `'0'` y `null`. Todo lo demás es **truthy**. Se puede comprobar con la doble negación `!!`, que convierte cualquier valor a `bool`:
+
+```php
+<?php
+
+var_dump(!!'hello'); // => bool(true)
+var_dump(!!'');      // => bool(false)
+var_dump(!!'0');     // => bool(false) — una particularidad de PHP
+```
+
+A diferencia de muchos lenguajes donde `&&` y `||` devuelven uno de sus operandos, en PHP los operadores lógicos siempre devuelven un `bool`:
+
+```php
+<?php
+
+var_dump('hello' && 'world'); // => bool(true)
+var_dump(0 || 1);             // => bool(true)
+```
+
+La conversión de tipos también ocurre con la comparación no estricta. El operador `==` convierte los operandos antes de comparar, por lo que una cadena vacía es igual a `false` desde su punto de vista. Esta conversión es implícita, así que evita `==` y `!=` siempre que sea posible:
+
+```php
+<?php
+
+var_dump('' === false); // => bool(false)
+var_dump('' == false);  // => bool(true)
+```
+
+Un error común de principiante es escribir `$value === ('first' || 'second')`. Primero se evalúan los paréntesis: ambas cadenas son truthy, el resultado es `true`, y toda la expresión se convierte en `$value === true` — siempre falsa para cadenas. La comprobación correcta es:
+
+```php
+<?php
+
+$value === 'first' || $value === 'second';
+```
diff --git a/modules/45-logic/90-logical-expressions/es/data.yml b/modules/45-logic/90-logical-expressions/es/data.yml
new file mode 100644
index 00000000..b0145692
--- /dev/null
+++ b/modules/45-logic/90-logical-expressions/es/data.yml
@@ -0,0 +1,5 @@
+---
+name: Resultado de expresiones lógicas
+tips:
+  - |
+    [Booleanos en PHP](https://www.php.net/manual/es/language.types.boolean.php)
diff --git a/modules/45-logic/90-logical-expressions/ru/EXERCISE.md b/modules/45-logic/90-logical-expressions/ru/EXERCISE.md
new file mode 100644
index 00000000..e3eb6700
--- /dev/null
+++ b/modules/45-logic/90-logical-expressions/ru/EXERCISE.md
@@ -0,0 +1,10 @@
+Напишите функцию `isFalsy()`, которая проверяет, трактуется ли переданное значение как ложное (falsy) с точки зрения PHP. Для выполнения этой проверки сравните переданное значение с `false`, используя нестрогое сравнение `==`.
+
+```php
+<?php
+
+isFalsy(false);  // true
+isFalsy(0);      // true
+isFalsy('help'); // false
+isFalsy(10);     // false
+```
diff --git a/modules/45-logic/90-logical-expressions/ru/README.md b/modules/45-logic/90-logical-expressions/ru/README.md
new file mode 100644
index 00000000..eaf3750d
--- /dev/null
+++ b/modules/45-logic/90-logical-expressions/ru/README.md
@@ -0,0 +1,89 @@
+В логических выражениях можно использовать не только значения типа `bool`. Числа и строки тоже могут быть операндами логических операций. В этом уроке разберем, как PHP обращается с ними и каким будет результат таких выражений.
+
+## Falsy и truthy значения
+
+Когда значение попадает в логический контекст, PHP приводит его к `true` или `false`. В PHP есть фиксированный набор значений, которые считаются **ложными** (falsy). К ним относятся `false`, число `0` (и `0.0`), пустая строка `''`, строка `'0'`, а также специальное значение `null` — «отсутствие значения».
+
+Все остальные значения считаются **истинными** (truthy). Это, например, любое ненулевое число (`1`, `-3.5`) и непустая строка (`'hi'`, `'hello'`).
+
+Убедиться в этом можно с помощью двойного отрицания `!!`, которое приводит любое значение к типу `bool`: первое отрицание превращает значение в логическое (и инвертирует его), а второе возвращает обратно:
+
+```php
+<?php
+
+var_dump(!!'hello'); // => bool(true)  — непустая строка — truthy
+var_dump(!!'');      // => bool(false) — пустая строка — falsy
+var_dump(!!0);       // => bool(false) — ноль — falsy
+var_dump(!!-3.5);    // => bool(true)  — ненулевое число — truthy
+var_dump(!!'0');     // => bool(false) — строка '0' — falsy, особенность PHP
+```
+
+Этим приемом пользуются, чтобы явно поменять тип данных: результатом двойного отрицания всегда будет значение типа `bool`.
+
+## Как работают логические выражения
+
+В некоторых языках операторы «И» и «ИЛИ» возвращают один из своих операндов, поэтому результатом может быть строка или число. PHP устроен иначе: логические операторы `&&` и `||` всегда возвращают значение типа `bool` — `true` или `false`:
+
+```php
+<?php
+
+var_dump('hello' && 'world'); // => bool(true)  — оба операнда truthy
+var_dump('' && 'world');      // => bool(false) — первый операнд falsy
+var_dump(0 || 1);             // => bool(true)  — второй операнд truthy
+var_dump('' || 0);            // => bool(false) — оба операнда falsy
+```
+
+Порядок вычисления зависит от приоритета операторов:
+
+```text
+Приоритет (от высокого к низкому):
+
+  ()          скобки
+   ↓
+  !           отрицание
+   ↓
+  &&          логическое И
+   ↓
+  ||          логическое ИЛИ
+```
+
+## Нестрогое сравнение
+
+Преобразование типов происходит и при нестрогом сравнении. Вспомните операторы `==` и `!=` из урока про логический тип: они сравнивают значения, предварительно преобразовав типы. Поэтому, с точки зрения `==`, пустая строка и `false` равны:
+
+```php
+<?php
+
+var_dump('' === false); // => bool(false)
+var_dump('' == false);  // => bool(true)
+```
+
+Пустая строка и `false` — это разные значения, поэтому строгий оператор `===` говорит «Ложь! Они не равны!». Но оператор `==` преобразует операнды и считает их равными. Это преобразование неявное, поэтому по возможности избегайте операторов `==` и `!=`.
+
+## Ошибка выбора
+
+Представим задачу, в которой нужно проверить, что значение равно либо одному, либо другому. Например, переменная `$value` должна содержать одно из двух значений: `'first'` или `'second'`. Начинающие разработчики иногда записывают это выражение так:
+
+```php
+<?php
+
+$value === ('first' || 'second');
+```
+
+В голове мы это себе примерно так и представляем, но языки работают по-другому, поэтому такой код приведет к неверному результату. Как его правильно прочитать? Первым делом вычисляется все, что указано в скобках, то есть `'first' || 'second'`. Обе строки непустые, то есть truthy, поэтому результатом будет `true`. Теперь можно заменить исходное выражение на частично вычисленное:
+
+```php
+<?php
+
+$value === true;
+```
+
+Совсем не то, что мы ожидали: строка `'first'` не равна `true` при строгом сравнении, поэтому выражение всегда ложно. А теперь вернемся к началу и напишем проверку правильно:
+
+```php
+<?php
+
+// Скобки ставить не обязательно,
+// потому что приоритет === выше, чем приоритет ||
+$value === 'first' || $value === 'second';
+```
diff --git a/modules/45-logic/90-logical-expressions/ru/data.yml b/modules/45-logic/90-logical-expressions/ru/data.yml
new file mode 100644
index 00000000..8efdbdf0
--- /dev/null
+++ b/modules/45-logic/90-logical-expressions/ru/data.yml
@@ -0,0 +1,5 @@
+---
+name: Результат логических выражений
+tips:
+  - |
+    [Тип bool в PHP](https://www.php.net/manual/ru/language.types.boolean.php)
diff --git a/modules/48-conditionals/30-if/index.php b/modules/48-conditionals/30-if/Solution.php
similarity index 79%
rename from modules/48-conditionals/30-if/index.php
rename to modules/48-conditionals/30-if/Solution.php
index d9f7efb0..6cf473a6 100644
--- a/modules/48-conditionals/30-if/index.php
+++ b/modules/48-conditionals/30-if/Solution.php
@@ -3,7 +3,7 @@
 namespace HexletBasics\Conditionals\IfStatement;
 
 // BEGIN
-function guessNumber($guess)
+function guessNumber(int $guess): string
 {
     if ($guess === 42) {
         return 'You win!';
diff --git a/modules/48-conditionals/30-if/SolutionTest.php b/modules/48-conditionals/30-if/SolutionTest.php
index 1ad5fea0..211e04c2 100644
--- a/modules/48-conditionals/30-if/SolutionTest.php
+++ b/modules/48-conditionals/30-if/SolutionTest.php
@@ -2,14 +2,12 @@
 
 namespace HexletBasics\Conditionals\IfStatement;
 
-use PHPUnit\Framework\TestCase;
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        require 'index.php';
-
         $this->assertEquals('Try again!', guessNumber(100500));
         $this->assertEquals('You win!', guessNumber(42));
     }
diff --git a/modules/48-conditionals/30-if/ru/EXERCISE.md b/modules/48-conditionals/30-if/ru/EXERCISE.md
index b3fc91e3..0617bbd3 100644
--- a/modules/48-conditionals/30-if/ru/EXERCISE.md
+++ b/modules/48-conditionals/30-if/ru/EXERCISE.md
@@ -1,9 +1,9 @@
 
-Реализуйте функцию `guessNumber()`, которая принимает число и проверяет, равно ли число заданному (пусть это будет 42). Если равно, то функция должна вернуть строку `'You win!'`, в противном случае нужно вернуть строку `'Try again!'`.
+В викторине загадано число 42. Участник называет число, и программа сразу говорит — угадал он или нет. Реализуйте функцию `guessNumber()`, которая принимает число и проверяет, равно ли оно 42. Если равно — возвращает `'You win!'`, иначе — `'Try again!'`.
 
 ```php
 <?php
 
-guessNumber(42) // 'You win!'
-guessNumber(61) // 'Try again!'
+guessNumber(42); // 'You win!'
+guessNumber(61); // 'Try again!'
 ```
diff --git a/modules/48-conditionals/30-if/ru/README.md b/modules/48-conditionals/30-if/ru/README.md
index 4083ca07..cac2c79e 100644
--- a/modules/48-conditionals/30-if/ru/README.md
+++ b/modules/48-conditionals/30-if/ru/README.md
@@ -1,14 +1,55 @@
-Задача предиката — получить ответ на вопрос, но обычно этого недостаточно и нужно выполнить определенное действие в зависимости от ответа.
+Логические выражения позволяют проверять разные условия. Но сами по себе они лишь возвращают `true` или `false`. Чтобы программа могла выполнять разные действия в зависимости от результата, в PHP есть специальная конструкция `if`:
 
-Напишем функцию, которая определяет тип переданного предложения. Для начала она будет отличать обычные предложения от вопросительных:
+```php
+<?php
+
+if (5 > 3) {
+    print_r('Yes, it is true');
+}
+```
+
+Здесь строка `'Yes, it is true'` напечатается, потому что условие `5 > 3` истинно.
+
+```text
+┌───────────┐
+│ условие?  │
+└─────┬─────┘
+ true │
+      ↓
+┌───────────┐
+│ тело if   │
+└───────────┘
+```
+
+## Блоки кода
+
+После слова `if` в круглых скобках пишется условие, а затем в фигурных скобках описывается блок кода. Все инструкции внутри фигурных скобок входят в один блок:
 
 ```php
 <?php
 
-function getTypeOfSentence($sentence)
+if (10 === 10) {
+    print_r("First\n");
+    print_r("Second\n");
+}
+
+print_r('Goodbye!');
+```
+
+Здесь напечатаются `First` и `Second`, потому что условие выполнилось. А `Goodbye!` напечатается в любом случае, так как эта инструкция уже за пределами блока. Принцип такой же, как и в определении функций.
+
+## Использование if внутри функции
+
+Рассмотрим функцию, которая определяет тип переданного предложения. Если оно оканчивается на знак вопроса, функция вернет `'question'`, иначе вернет `'normal'`:
+
+```php
+<?php
+
+function getTypeOfSentence(string $sentence): string
 {
     // Простой способ извлечь последний символ
     $lastChar = $sentence[-1];
+
     if ($lastChar === '?') {
         return 'question';
     }
@@ -16,10 +57,43 @@ function getTypeOfSentence($sentence)
     return 'normal';
 }
 
-getTypeOfSentence('Hodor');  // normal
-getTypeOfSentence('Hodor?'); // question
+print_r(getTypeOfSentence('Hodor') . "\n");  // => normal
+print_r(getTypeOfSentence('Hodor?') . "\n"); // => question
 ```
 
-`if` — это инструкция. В скобках ей передается выражение-предикат, а затем описывается блок кода в фигурных скобках. Этот блок кода будет выполнен, только если предикат — истина. Если предикат — ложь, то блок кода в фигурных скобках пропускается, и функция продолжает свое выполнение дальше.
+Здесь используется сразу два `return`. Если условие внутри `if` выполняется, срабатывает `return 'question';` и функция завершается. Если условие не выполняется, управление переходит на следующую строку с `return 'normal';`.
+
+Таким образом, у функции есть несколько возможных точек выхода. Это частая практика. В зависимости от условий функция может завершаться по-разному.
+
+Несмотря на то, что функция `getTypeOfSentence()` использует `if`, она возвращает строки, а значит, предикатом не является. В качестве предиката рассмотрим функцию, которая проверяет, достаточно ли денег для покупки:
+
+```php
+<?php
+
+function hasEnoughMoney(int $balance, int $price): bool
+{
+    if ($balance >= $price) {
+        return true;
+    }
+
+    return false;
+}
+
+var_dump(hasEnoughMoney(100, 50)); // => bool(true)
+var_dump(hasEnoughMoney(30, 50));  // => bool(false)
+```
+
+## if и логические выражения
+
+Функцию `hasEnoughMoney()` мы написали через `if`. Но в таком виде она могла бы обойтись и без него, потому что результат сравнения сам по себе уже является логическим выражением:
+
+```php
+<?php
+
+function hasEnoughMoney(int $balance, int $price): bool
+{
+    return $balance >= $price;
+}
+```
 
-В нашем случае следующая строчка кода — `return 'normal';`. Она заставит функцию вернуть строку и завершиться. Как видите, `return` может находиться где угодно в функции, в том числе — внутри блока кода с условием.
+В простых случаях лучше сразу возвращать такое выражение. `if` нужен там, где внутри блока выполняются дополнительные действия помимо возврата результата. Чем более сложные программы мы будем писать, тем чаще такие ситуации начнут встречаться.
diff --git a/modules/48-conditionals/40-if-else/Solution.php b/modules/48-conditionals/40-if-else/Solution.php
new file mode 100644
index 00000000..d38d8adc
--- /dev/null
+++ b/modules/48-conditionals/40-if-else/Solution.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace HexletBasics\Conditionals\IfElse;
+
+// BEGIN
+function normalizeUrl(string $url): string
+{
+    $prefix = 'https://';
+
+    if (str_starts_with($url, $prefix)) {
+        return $url;
+    }
+
+    if (str_starts_with($url, 'http://')) {
+        $domain = substr($url, 7);
+    } else {
+        $domain = $url;
+    }
+
+    return "{$prefix}{$domain}";
+}
+// END
diff --git a/modules/48-conditionals/40-if-else/SolutionTest.php b/modules/48-conditionals/40-if-else/SolutionTest.php
index 8fe41501..4a064998 100644
--- a/modules/48-conditionals/40-if-else/SolutionTest.php
+++ b/modules/48-conditionals/40-if-else/SolutionTest.php
@@ -2,20 +2,27 @@
 
 namespace HexletBasics\Conditionals\IfElse;
 
-use PHPUnit\Framework\TestCase;
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        require 'index.php';
-
-        $expected1 = 'https://yandex.ru';
-        $actual1 = normalizeUrl('yandex.ru');
-        $this->assertEquals($expected1, $actual1);
-
-        $expected2 = 'https://yandex.ru';
-        $actual2 = normalizeUrl('http://yandex.ru');
-        $this->assertEquals($expected2, $actual2);
+        $this->assertEquals('https://yandex.ru', normalizeUrl('yandex.ru'));
+        $this->assertEquals('https://yandex.ru', normalizeUrl('http://yandex.ru'));
+        $this->assertEquals('https://yandex.ru', normalizeUrl('https://yandex.ru'));
+        $this->assertEquals('https://httpsecurity.com', normalizeUrl('httpsecurity.com'));
+        $this->assertEquals(
+            'https://httpbin.org/redirect-to?url=http://google.com',
+            normalizeUrl('https://httpbin.org/redirect-to?url=http://google.com')
+        );
+        $this->assertEquals(
+            'https://httpbin.org/redirect-to?url=https://google.com',
+            normalizeUrl('httpbin.org/redirect-to?url=https://google.com')
+        );
+        $this->assertEquals(
+            'https://httpbin.org/redirect-to?url=http://google.com',
+            normalizeUrl('httpbin.org/redirect-to?url=http://google.com')
+        );
     }
 }
diff --git a/modules/48-conditionals/40-if-else/index.php b/modules/48-conditionals/40-if-else/index.php
deleted file mode 100644
index 2bb7ff20..00000000
--- a/modules/48-conditionals/40-if-else/index.php
+++ /dev/null
@@ -1,21 +0,0 @@
-<?php
-
-namespace HexletBasics\Conditionals\IfElse;
-
-// BEGIN
-function normalizeUrl($url)
-{
-    if (strpos($url, 'https://') === 0) {
-        return $url;
-    }
-
-    if (strpos($url, 'http://') === 0) {
-        $domain = substr($url, 7);
-    } else {
-        $domain = $url;
-    }
-
-    return "https://{$domain}";
-}
-
-// END
diff --git a/modules/48-conditionals/40-if-else/ru/EXERCISE.md b/modules/48-conditionals/40-if-else/ru/EXERCISE.md
index e59a9f51..f4b95d70 100644
--- a/modules/48-conditionals/40-if-else/ru/EXERCISE.md
+++ b/modules/48-conditionals/40-if-else/ru/EXERCISE.md
@@ -1,20 +1,34 @@
 
-Реализуйте функцию `normalizeUrl()`, которая выполняет так называемую нормализацию данных. Она принимает адрес сайта и возвращает его с `https://` в начале.
+Реализуйте функцию `normalizeUrl()`, которая выполняет нормализацию данных. Она принимает адрес сайта и возвращает его с `https://` в начале.
 
-Функция принимает адреса в виде `АДРЕС` или `http://АДРЕС`, но всегда возвращает адрес в виде `https://АДРЕС`
+Функция принимает адреса в виде `АДРЕС` или `http://АДРЕС`, но всегда возвращает адрес в виде `https://АДРЕС`. На вход функции также может поступить адрес в уже нормализованном виде `https://АДРЕС`, в этом случае ничего менять не надо.
 
-Есть два пути решения:
+Примеры вызова:
+
+```php
+<?php
 
-1. Можно сравнить первые 7 символов строки-аргумента со строкой `http://`.
-2. Можно использовать функцию [strpos](https://php.net/manual/ru/function.strpos.php), чтобы проверить, содержится ли в строке-аргументе подстрока `http://`.
+normalizeUrl('https://ya.ru'); // 'https://ya.ru'
+normalizeUrl('google.com');    // 'https://google.com'
+normalizeUrl('http://ai.fi');  // 'https://ai.fi'
+```
 
-А потом на основе этого добавлять или не добавлять `https://`.
+Есть несколько способов решить задачу. Один из них — проверить с помощью функции `str_starts_with()`, начинается ли строка-аргумент со строки `http://`, а потом на основе этого добавлять или не добавлять к ней `https://`.
 
-Примеры вызова:
+Также вам скорее всего потребуется отбросить ненужную часть в начале строки. Помните, мы рассматривали способ получения кусочка от строки с помощью функции `substr()`? Если нет, напоминаю:
+
+```php
+<?php
+
+// Берем 2 символа от начала
+print_r(substr('python', 0, 2)); // => py
+```
+
+Так вот, с помощью `substr()` можно также отбросить определенное количество символов:
 
 ```php
 <?php
 
-normalizeUrl('google.com');   // 'https://google.com'
-normalizeUrl('http://ai.fi'); // 'https://ai.fi'
+// Отбрасываем первые 2 символа
+print_r(substr('python', 2)); // => thon
 ```
diff --git a/modules/48-conditionals/40-if-else/ru/README.md b/modules/48-conditionals/40-if-else/ru/README.md
index 6ccd6caf..2507f708 100644
--- a/modules/48-conditionals/40-if-else/ru/README.md
+++ b/modules/48-conditionals/40-if-else/ru/README.md
@@ -1,9 +1,9 @@
-Попробуем изменить функцию из предыдущего примера так, чтобы она возвращала не просто тип предложения, а целую строку *Sentence is normal* или *Sentence is question*:
+Посмотрите на функцию ниже. Она определяет тип предложения по последнему символу: если предложение заканчивается вопросительным знаком, функция вернет `Sentence is question`, иначе — `Sentence is normal`:
 
 ```php
 <?php
 
-function getTypeOfSentence($sentence)
+function getTypeOfSentence(string $sentence): string
 {
     $lastChar = $sentence[-1];
 
@@ -16,18 +16,47 @@ function getTypeOfSentence($sentence)
     return "Sentence is {$sentenceType}";
 }
 
-getTypeOfSentence('Hodor');  // Sentence is normal
-getTypeOfSentence('Hodor?'); // Sentence is question
+print_r(getTypeOfSentence('Hodor') . "\n");  // => Sentence is normal
+print_r(getTypeOfSentence('Hodor?') . "\n"); // => Sentence is question
 ```
 
-Мы добавили `else` и новый блок с фигурными скобками. Этот блок выполнится, только если условие в `if` — ложь.
+Мы добавили `else` и новый блок в фигурных скобках. Он выполнится, если условие в `if` окажется ложным. Еще в блок `else` можно вкладывать другие условия `if`. Else переводится «иначе», «в ином случае».
 
-Существует два способа оформления конструкции *if-else*. С помощью отрицания `!==` можно изменить порядок блоков:
+```text
+      ┌───────────┐
+      │ условие?  │
+      └─────┬─────┘
+ true │           │ false
+      ↓           ↓
+┌──────────┐ ┌──────────┐
+│ тело if  │ │ тело else│
+└──────────┘ └──────────┘
+```
+
+Пример вложенных блоков:
 
 ```php
 <?php
 
-function getTypeOfSentence($sentence)
+$number = 10;
+
+if ($number > 10) {
+    print_r('Number is greater than 10');
+} else {
+    if ($number === 10) {
+        print_r('Number is exactly 10');
+    } else {
+        print_r('Number is less than 10');
+    }
+}
+```
+
+Оформить конструкцию `if-else` можно двумя способами. С помощью отрицания `!==` можно изменить порядок блоков:
+
+```php
+<?php
+
+function getTypeOfSentence(string $sentence): string
 {
     $lastChar = $sentence[-1];
 
@@ -41,4 +70,53 @@ function getTypeOfSentence($sentence)
 }
 ```
 
-Какой способ предпочтительнее? Обычно людям проще мыслить прямолинейно, а не через отрицание. Старайтесь выбирать проверку без отрицаний и подстраивайте содержимое блоков под нее.
+Чтобы конструкцию было легче оформлять, старайтесь выбирать проверку без отрицаний и подстраивайте содержимое блоков под нее.
+
+На примере использования `else` видно, как важно следить за тем, к какому `if` относится каждый блок:
+
+```php
+<?php
+
+// Неправильно
+function checkNumber(int $number): void
+{
+    if ($number > 0) {
+        print_r("Число положительное\n");
+    }
+
+    if ($number > 10) {
+        print_r("Число больше 10\n");
+    } else {
+        print_r("Число не положительное\n");
+    }
+}
+
+checkNumber(3);
+// => Число положительное
+// => Число не положительное
+```
+
+В примере выше мы забыли вложить второй `if` внутрь первого, поэтому `else` теперь относится ко второму `if`. Программа сообщает, что число одновременно положительное и не положительное.
+
+```php
+<?php
+
+// Правильно
+function checkNumber(int $number): void
+{
+    if ($number > 0) {
+        print_r("Число положительное\n");
+
+        if ($number > 10) {
+            print_r("Число больше 10\n");
+        }
+    } else {
+        print_r("Число не положительное\n");
+    }
+}
+
+checkNumber(3);
+// => Число положительное
+```
+
+Теперь второй `if` вложен в первый, а `else` на одном уровне с первым и противопоставляется ему.
diff --git a/modules/48-conditionals/50-else-if/Solution.php b/modules/48-conditionals/50-else-if/Solution.php
new file mode 100644
index 00000000..06e82989
--- /dev/null
+++ b/modules/48-conditionals/50-else-if/Solution.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace HexletBasics\Conditionals\ElseIfStatement;
+
+// BEGIN
+function getTrafficLightAction(string $color): string
+{
+    if ($color === 'green') {
+        return 'go';
+    } elseif ($color === 'yellow') {
+        return 'slow down';
+    } elseif ($color === 'red') {
+        return 'stop';
+    }
+
+    return 'unknown';
+}
+// END
diff --git a/modules/48-conditionals/50-else-if/SolutionTest.php b/modules/48-conditionals/50-else-if/SolutionTest.php
index cd7b4523..45c344db 100644
--- a/modules/48-conditionals/50-else-if/SolutionTest.php
+++ b/modules/48-conditionals/50-else-if/SolutionTest.php
@@ -2,18 +2,16 @@
 
 namespace HexletBasics\Conditionals\ElseIfStatement;
 
-use PHPUnit\Framework\TestCase;
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        require 'index.php';
-
-        $this->assertEquals('friend', whoIsThisHouseToStarks('Tully'));
-        $this->assertEquals('friend', whoIsThisHouseToStarks('Karstark'));
-        $this->assertEquals('enemy', whoIsThisHouseToStarks('Lannister'));
-        $this->assertEquals('neutral', whoIsThisHouseToStarks('Martell'));
-        $this->assertEquals('neutral', whoIsThisHouseToStarks('undefined'));
+        $this->assertEquals('go', getTrafficLightAction('green'));
+        $this->assertEquals('slow down', getTrafficLightAction('yellow'));
+        $this->assertEquals('stop', getTrafficLightAction('red'));
+        $this->assertEquals('unknown', getTrafficLightAction('blue'));
+        $this->assertEquals('unknown', getTrafficLightAction('purple'));
     }
 }
diff --git a/modules/48-conditionals/50-else-if/index.php b/modules/48-conditionals/50-else-if/index.php
deleted file mode 100644
index 1d4cab63..00000000
--- a/modules/48-conditionals/50-else-if/index.php
+++ /dev/null
@@ -1,16 +0,0 @@
-<?php
-
-namespace HexletBasics\Conditionals\ElseIfStatement;
-
-// BEGIN
-function whoIsThisHouseToStarks($houseName)
-{
-    if ($houseName === 'Karstark' || $houseName === 'Tully') {
-        return 'friend';
-    } elseif ($houseName === 'Lannister' || $houseName === 'Frey') {
-        return 'enemy';
-    }
-
-    return 'neutral';
-}
-// END
diff --git a/modules/48-conditionals/50-else-if/ru/EXERCISE.md b/modules/48-conditionals/50-else-if/ru/EXERCISE.md
index 5594dead..f7f3a11e 100644
--- a/modules/48-conditionals/50-else-if/ru/EXERCISE.md
+++ b/modules/48-conditionals/50-else-if/ru/EXERCISE.md
@@ -1,21 +1,19 @@
 
-На электронной карте Вестероса, которую реализовал Сэм, союзники Старков отображены зеленым кружком, враги — красным, а нейтральные семьи — серым.
+Реализуйте функцию `getTrafficLightAction()`, которая принимает цвет светофора и возвращает, что нужно делать водителю.
 
-Напишите для Сэма функцию `whoIsThisHouseToStarks()`, которая принимает на вход фамилию семьи и возвращает одно из трех значений: `'friend'`, `'enemy'`, `'neutral'`.
+Правила:
 
-Правила определения:
-
-  * Друзья (`'friend'`): 'Karstark', 'Tully'
-  * Враги (`'enemy'`): 'Lannister', 'Frey'
-  * Любые другие семьи считаются нейтральными
+* `'green'` → `'go'`
+* `'yellow'` → `'slow down'`
+* `'red'` → `'stop'`
+* Любой другой цвет → `'unknown'`
 
 Примеры вызова:
 
 ```php
 <?php
 
-whoIsThisHouseToStarks('Karstark'); // 'friend'
-whoIsThisHouseToStarks('Frey');     // 'enemy'
-whoIsThisHouseToStarks('Joar');     // 'neutral'
-whoIsThisHouseToStarks('Ivanov');   // 'neutral'
+getTrafficLightAction('green');  // 'go'
+getTrafficLightAction('red');    // 'stop'
+getTrafficLightAction('purple'); // 'unknown'
 ```
diff --git a/modules/48-conditionals/50-else-if/ru/README.md b/modules/48-conditionals/50-else-if/ru/README.md
index cafc8e4e..0dbd5a47 100644
--- a/modules/48-conditionals/50-else-if/ru/README.md
+++ b/modules/48-conditionals/50-else-if/ru/README.md
@@ -1,62 +1,75 @@
-Функция `getTypeOfSentence()` различает только вопросительные и обычные предложения. Давайте попробуем добавить поддержку восклицательных предложений:
+Функция `getTypeOfSentence()` различает только вопросительные и обычные предложения. Добавим в нее поддержку восклицательных предложений:
 
 ```php
 <?php
 
-function getTypeOfSentence($sentence)
+function getTypeOfSentence(string $sentence): string
 {
     $lastChar = $sentence[-1];
 
+    if ($lastChar === '?') {
+        $sentenceType = 'question';
+    }
+
     if ($lastChar === '!') {
         $sentenceType = 'exclamation';
     } else {
         $sentenceType = 'normal';
     }
 
-    if ($lastChar === '?') {
-        $sentenceType = 'question';
-    }
-
     return "Sentence is {$sentenceType}";
 }
 
-getTypeOfSentence('Who?'); // 'Sentence is question'
-getTypeOfSentence('No');   // 'Sentence is normal'
-getTypeOfSentence('No!');  // 'Sentence is exclamation'
+print_r(getTypeOfSentence('Who?') . "\n"); // => Sentence is normal
+print_r(getTypeOfSentence('No') . "\n");   // => Sentence is normal
+print_r(getTypeOfSentence('No!') . "\n");  // => Sentence is exclamation
 ```
 
-Мы добавили еще одну проверку (_exclamation_ переводится «восклицание»). Технически функция работает, но с точки зрения семантики есть проблемы:
+Мы добавили проверку восклицательных предложений (_exclamation_ переводится «восклицание»). Технически эта функция работает, но вопросительные предложения трактует неверно. Еще в ней есть проблемы с точки зрения семантики. Наличие восклицательного знака проверяется в любом случае, даже если уже обнаружился вопросительный знак. Ветка `else` описана для второго условия, но не для первого. Поэтому вопросительное предложение становится `normal`.
 
-* Проверка на наличие вопросительного знака происходит в любом случае, даже если уже был обнаружен восклицательный знак
-* Ветка `else` описана именно для первого условия, но не для второго
-
-Правильнее будет воспользоваться еще одной возможностью условной конструкции:
+Чтобы исправить ситуацию, воспользуемся еще одной возможностью условной конструкции:
 
 ```php
 <?php
 
-function getTypeOfSentence($sentence)
+function getTypeOfSentence(string $sentence): string
 {
-  $lastChar = $sentence[-1];
+    $lastChar = $sentence[-1];
 
-  if ($lastChar === '?') {
-      $sentenceType = 'question';
-  } elseif ($lastChar === '!') {
-      $sentenceType = 'exclamation';
-  } else {
-      $sentenceType = 'normal';
-  }
+    if ($lastChar === '?') {
+        $sentenceType = 'question';
+    } elseif ($lastChar === '!') {
+        $sentenceType = 'exclamation';
+    } else {
+        $sentenceType = 'normal';
+    }
 
-  return "Sentence is {$sentenceType}";
+    return "Sentence is {$sentenceType}";
 }
-```
 
-Теперь все условия выстроены в единую конструкцию.
+print_r(getTypeOfSentence('Who?') . "\n"); // => Sentence is question
+print_r(getTypeOfSentence('No') . "\n");   // => Sentence is normal
+print_r(getTypeOfSentence('No!') . "\n");  // => Sentence is exclamation
+```
 
-Конструкция `elseif` — это «если не выполнено предыдущее условие, но выполнено текущее». Получается такая схема:
+Теперь все условия выстроились в единую конструкцию. Ключевое слово `elseif` означает «если не выполнено предыдущее условие, но выполнено текущее».
+
+```text
+  ┌─────────────────┐
+  │ условие 1?      │
+  └────┬────────┬───┘
+ true │        │ false
+       ↓        ↓
+┌──────────┐  ┌─────────────────┐
+│ тело if  │  │ условие 2?      │
+└──────────┘  └────┬────────┬───┘
+              true │        │ false
+                    ↓        ↓
+          ┌────────────┐ ┌──────────┐
+          │тело elseif │ │ тело else│
+          └────────────┘ └──────────┘
+```
 
-* Если последний символ `?`, то `'question'`
-* Иначе, если последний символ `!`, то `'exclamation'`
-* Иначе `'normal'`
+Логика функции устроена так. Если последний символ `?`, возвращается `'question'`. Если последний символ `!`, возвращается `'exclamation'`. Во всех остальных случаях возвращается `'normal'`.
 
-Выполнится только один из блоков кода, относящихся ко всей конструкции `if`.
+Выполнится только один из блоков кода, который относится ко всей конструкции `if`.
diff --git a/modules/48-conditionals/60-ternary-operator/Solution.php b/modules/48-conditionals/60-ternary-operator/Solution.php
new file mode 100644
index 00000000..16a2ca1e
--- /dev/null
+++ b/modules/48-conditionals/60-ternary-operator/Solution.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace HexletBasics\Conditionals\TernaryOperator;
+
+// BEGIN
+function flipFlop(string $string): string
+{
+    return $string === 'flip' ? 'flop' : 'flip';
+}
+// END
diff --git a/modules/48-conditionals/60-ternary-operator/SolutionTest.php b/modules/48-conditionals/60-ternary-operator/SolutionTest.php
index bef19d58..9701095e 100644
--- a/modules/48-conditionals/60-ternary-operator/SolutionTest.php
+++ b/modules/48-conditionals/60-ternary-operator/SolutionTest.php
@@ -1,15 +1,13 @@
 <?php
 
-namespace HexletBasics\Logic\TernaryOperator;
+namespace HexletBasics\Conditionals\TernaryOperator;
 
-use PHPUnit\Framework\TestCase;
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        require 'index.php';
-
         $this->assertEquals('flop', flipFlop('flip'));
         $this->assertEquals('flip', flipFlop('flop'));
         $this->assertEquals('flip', flipFlop(''));
diff --git a/modules/48-conditionals/60-ternary-operator/index.php b/modules/48-conditionals/60-ternary-operator/index.php
deleted file mode 100644
index cc9e2b8a..00000000
--- a/modules/48-conditionals/60-ternary-operator/index.php
+++ /dev/null
@@ -1,10 +0,0 @@
-<?php
-
-namespace HexletBasics\Logic\TernaryOperator;
-
-// BEGIN
-function flipFlop($string)
-{
-    return $string === 'flip' ? 'flop' : 'flip';
-}
-// END
diff --git a/modules/48-conditionals/60-ternary-operator/ru/EXERCISE.md b/modules/48-conditionals/60-ternary-operator/ru/EXERCISE.md
index 6a1d8457..85ae94ec 100644
--- a/modules/48-conditionals/60-ternary-operator/ru/EXERCISE.md
+++ b/modules/48-conditionals/60-ternary-operator/ru/EXERCISE.md
@@ -1,5 +1,5 @@
 
-Реализуйте функцию `flipFlop()`, которая принимает на вход строку и, если эта строка равна `'flip'`, возвращает строку `'flop'`. В противном случае функция должна вернуть `'flip'`.
+Кнопка в приложении работает как переключатель: каждое нажатие меняет состояние на противоположное. Реализуйте функцию `flipFlop()`, которая принимает на вход строку и, если эта строка равна `'flip'`, возвращает строку `'flop'`. В противном случае функция должна вернуть `'flip'`.
 
 Примеры вызова:
 
diff --git a/modules/48-conditionals/60-ternary-operator/ru/README.md b/modules/48-conditionals/60-ternary-operator/ru/README.md
index 882a3fc0..29139f41 100644
--- a/modules/48-conditionals/60-ternary-operator/ru/README.md
+++ b/modules/48-conditionals/60-ternary-operator/ru/README.md
@@ -3,7 +3,7 @@
 ```php
 <?php
 
-function abs($number)
+function abs(int $number): int
 {
     if ($number >= 0) {
         return $number;
@@ -12,20 +12,16 @@ function abs($number)
     return -$number;
 }
 
-abs(10);  // 10
-abs(-10); // 10
+print_r(abs(10) . "\n");  // => 10
+print_r(abs(-10) . "\n"); // => 10
 ```
 
-Можно ли записать ее лаконичнее? Что-то вроде `return ОТВЕТ В ЗАВИСИМОСТИ ОТ УСЛОВИЯ`? Для этого справа от `return` должно быть выражение. Но есть проблема: `if` — это инструкция, а не выражение.
-
-В PHP существует конструкция, которая по своему действию аналогична конструкции *if-else*, но при этом является выражением. Она называется **тернарный оператор**, и именно его мы изучим в этом уроке.
-
-**Тернарный оператор** — единственный в своем роде оператор, требующий три операнда:
+Но можно записать более лаконично. В PHP есть конструкция, которая работает как *if-else*, но при этом является выражением — ее результат можно сразу вернуть из функции. Она называется **тернарный оператор** и является единственным оператором в PHP, который требует три операнда:
 
 ```php
 <?php
 
-function abs($number)
+function abs(int $number): int
 {
     return $number >= 0 ? $number : -$number;
 }
@@ -41,35 +37,35 @@ function abs($number)
 
 Давайте перепишем начальный вариант `getTypeOfSentence()` аналогично. Посмотрим, как было:
 
-  ```php
-  <?php
+```php
+<?php
 
-  function getTypeOfSentence($sentence)
-  {
-      $lastChar = substr($sentence, -1);
+function getTypeOfSentence(string $sentence): string
+{
+    $lastChar = $sentence[-1];
 
-      if ($lastChar === '?') {
-          return 'question';
-      }
+    if ($lastChar === '?') {
+        return 'question';
+    }
 
-      return 'normal';
-  }
-  ```
+    return 'normal';
+}
+```
 
-  А теперь — как стало:
+А теперь — как стало:
 
-  ```php
-  <?php
+```php
+<?php
 
-  function getTypeOfSentence($sentence)
-  {
-      $lastChar = substr($sentence, -1);
+function getTypeOfSentence(string $sentence): string
+{
+    $lastChar = $sentence[-1];
 
-      return ($lastChar === '?') ? 'question' : 'normal';
-  }
+    return $lastChar === '?' ? 'question' : 'normal';
+}
 
-  getTypeOfSentence('Hodor');  // normal
-  getTypeOfSentence('Hodor?'); // question
-  ```
+print_r(getTypeOfSentence('Hodor') . "\n");  // => normal
+print_r(getTypeOfSentence('Hodor?') . "\n"); // => question
+```
 
 Вы уже могли догадаться, что тернарный оператор можно вкладывать в тернарный оператор. Это возможно, но лучше так не делать. Такой код тяжело читать и отлаживать, поэтому вложенные тернарные операторы считаются очень плохой практикой.
diff --git a/modules/48-conditionals/65-switch/index.php b/modules/48-conditionals/65-switch/Solution.php
similarity index 86%
rename from modules/48-conditionals/65-switch/index.php
rename to modules/48-conditionals/65-switch/Solution.php
index c4333cef..8f3968ab 100644
--- a/modules/48-conditionals/65-switch/index.php
+++ b/modules/48-conditionals/65-switch/Solution.php
@@ -3,7 +3,7 @@
 namespace HexletBasics\Conditionals\SwitchStatement;
 
 // BEGIN
-function getNumberExplanation($number)
+function getNumberExplanation(int $number): string
 {
     switch ($number) {
         case 666:
diff --git a/modules/48-conditionals/65-switch/SolutionTest.php b/modules/48-conditionals/65-switch/SolutionTest.php
index 7902d170..3670dc52 100644
--- a/modules/48-conditionals/65-switch/SolutionTest.php
+++ b/modules/48-conditionals/65-switch/SolutionTest.php
@@ -2,14 +2,12 @@
 
 namespace HexletBasics\Conditionals\SwitchStatement;
 
-use PHPUnit\Framework\TestCase;
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        require 'index.php';
-
         $this->assertEquals('just a number', getNumberExplanation(0));
         $this->assertEquals('devil number', getNumberExplanation(666));
         $this->assertEquals('answer for everything', getNumberExplanation(42));
diff --git a/modules/48-conditionals/65-switch/description.es.yml b/modules/48-conditionals/65-switch/description.es.yml
index f382272c..5738e0a9 100644
--- a/modules/48-conditionals/65-switch/description.es.yml
+++ b/modules/48-conditionals/65-switch/description.es.yml
@@ -70,7 +70,7 @@ theory: |
   ```php
   <?php
 
-  function doSomethingGood($count)
+  function doSomethingGood(int $count): ?string
   {
       // Llenar
       switch ($count) {
@@ -94,7 +94,7 @@ theory: |
   ```php
   <?php
 
-  function doSomethingGood($count)
+  function doSomethingGood(int $count): ?string
   {
       switch ($count) {
           case 1:
diff --git a/modules/48-conditionals/65-switch/en/EXERCISE.md b/modules/48-conditionals/65-switch/en/EXERCISE.md
index 8e6d0d6d..7cdd9c52 100644
--- a/modules/48-conditionals/65-switch/en/EXERCISE.md
+++ b/modules/48-conditionals/65-switch/en/EXERCISE.md
@@ -1,6 +1,10 @@
 
 Write a function, `getNumberExplanation()`, that describes a number passed to it. If there's no explanation available, it returns `null`:
 
+* 666 - devil number
+* 42 - answer for everything
+* 7 - prime number
+
 ```php
 <?php
 
diff --git a/modules/48-conditionals/65-switch/en/README.md b/modules/48-conditionals/65-switch/en/README.md
index 21c1736f..664aa39c 100644
--- a/modules/48-conditionals/65-switch/en/README.md
+++ b/modules/48-conditionals/65-switch/en/README.md
@@ -65,7 +65,7 @@ The first way. Create a variable before *switch*, fill it with something in *cas
 ```php
 <?php
 
-function doSomethingGood($count)
+function doSomethingGood(int $count): ?string
 {
     // Filling it
     switch ($count) {
@@ -89,7 +89,7 @@ The second way is easier and shorter. Instead of creating a variable, *case* all
 ```php
 <?php
 
-function doSomethingGood($count)
+function doSomethingGood(int $count): ?string
 {
     switch ($count) {
         case 1:
diff --git a/modules/48-conditionals/65-switch/es/EXERCISE.md b/modules/48-conditionals/65-switch/es/EXERCISE.md
index 64b8cc01..a044b22f 100644
--- a/modules/48-conditionals/65-switch/es/EXERCISE.md
+++ b/modules/48-conditionals/65-switch/es/EXERCISE.md
@@ -1,8 +1,8 @@
 Implementa la función `getNumberExplanation()`, que recibe un número como entrada y devuelve una explicación para ese número. Si no hay una explicación para el número, se devuelve `just a number`. Solo hay explicaciones para los siguientes números:
 
-  * 666 - devil number
-  * 42 - answer for everything
-  * 7 - prime number
+* 666 - devil number
+* 42 - answer for everything
+* 7 - prime number
 
 Ejemplos de llamadas a la función:
 
diff --git a/modules/48-conditionals/65-switch/es/README.md b/modules/48-conditionals/65-switch/es/README.md
index 699a94df..d84e60a9 100644
--- a/modules/48-conditionals/65-switch/es/README.md
+++ b/modules/48-conditionals/65-switch/es/README.md
@@ -66,7 +66,7 @@ A veces, el resultado obtenido dentro de un `case` es el final de la ejecución
 ```php
 <?php
 
-function doSomethingGood($count)
+function doSomethingGood(int $count): ?string
 {
     // Llenar
     switch ($count) {
@@ -90,7 +90,7 @@ function doSomethingGood($count)
 ```php
 <?php
 
-function doSomethingGood($count)
+function doSomethingGood(int $count): ?string
 {
     switch ($count) {
         case 1:
diff --git a/modules/48-conditionals/65-switch/ru/EXERCISE.md b/modules/48-conditionals/65-switch/ru/EXERCISE.md
index 59006804..64522adf 100644
--- a/modules/48-conditionals/65-switch/ru/EXERCISE.md
+++ b/modules/48-conditionals/65-switch/ru/EXERCISE.md
@@ -1,8 +1,8 @@
 Реализуйте функцию `getNumberExplanation()`, которая принимает на вход число и возвращает объяснение этого числа. Если для числа нет объяснения, то возвращается `just a number`. Объяснения есть только для следующих чисел:
 
-  * 666 - devil number
-  * 42 - answer for everything
-  * 7 - prime number
+* 666 - devil number
+* 42 - answer for everything
+* 7 - prime number
 
 Примеры вызова функции:
 
diff --git a/modules/48-conditionals/65-switch/ru/README.md b/modules/48-conditionals/65-switch/ru/README.md
index 1202a054..aaebb2e1 100644
--- a/modules/48-conditionals/65-switch/ru/README.md
+++ b/modules/48-conditionals/65-switch/ru/README.md
@@ -1,4 +1,4 @@
-Многие языки в дополнение к условной конструкции *if* включают в себя **switch**. В этом уроке мы познакомимся с ним.
+Во многих языках помимо условной конструкции *if* есть **switch**. Эта конструкция встречается в огромном количестве существующего PHP-кода, поэтому ее важно уметь читать.
 
 Это специализированная версия *if*, созданная для некоторых особых ситуаций. Например, ее имеет смысл использовать там, где есть цепочка *if else* с проверками на равенство. Например:
 
@@ -66,7 +66,7 @@ switch ($count) {
 ```php
 <?php
 
-function doSomethingGood($count)
+function doSomethingGood(int $count): ?string
 {
     // Заполняем
     switch ($count) {
@@ -90,7 +90,7 @@ function doSomethingGood($count)
 ```php
 <?php
 
-function doSomethingGood($count)
+function doSomethingGood(int $count): ?string
 {
     switch ($count) {
         case 1:
diff --git a/modules/50-loops/30-syntax-sugar/Makefile b/modules/48-conditionals/70-match/Makefile
similarity index 100%
rename from modules/50-loops/30-syntax-sugar/Makefile
rename to modules/48-conditionals/70-match/Makefile
diff --git a/modules/48-conditionals/70-match/Solution.php b/modules/48-conditionals/70-match/Solution.php
new file mode 100644
index 00000000..cf95fdb6
--- /dev/null
+++ b/modules/48-conditionals/70-match/Solution.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace HexletBasics\Conditionals\MatchExpression;
+
+// BEGIN
+function calculateDeliveryCost(string $country, float $weight): ?int
+{
+    return match ($country) {
+        'canada' => $weight <= 1 ? 600 : 900,
+        'usa' => $weight <= 1 ? 800 : 1200,
+        'germany' => $weight <= 1 ? 700 : 1000,
+        default => null,
+    };
+}
+// END
diff --git a/modules/48-conditionals/70-match/SolutionTest.php b/modules/48-conditionals/70-match/SolutionTest.php
new file mode 100644
index 00000000..6b8525e5
--- /dev/null
+++ b/modules/48-conditionals/70-match/SolutionTest.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace HexletBasics\Conditionals\MatchExpression;
+
+use HexletBasics\Exercise\TestCase;
+
+class SolutionTest extends TestCase
+{
+    public function test()
+    {
+        $this->assertEquals(600, calculateDeliveryCost('canada', 0.5));
+        $this->assertEquals(600, calculateDeliveryCost('canada', 1));
+        $this->assertEquals(900, calculateDeliveryCost('canada', 2));
+        $this->assertEquals(800, calculateDeliveryCost('usa', 1));
+        $this->assertEquals(1200, calculateDeliveryCost('usa', 3));
+        $this->assertEquals(700, calculateDeliveryCost('germany', 0.3));
+        $this->assertEquals(1000, calculateDeliveryCost('germany', 1.5));
+        $this->assertNull(calculateDeliveryCost('france', 1));
+    }
+}
diff --git a/modules/48-conditionals/70-match/description.es.yml b/modules/48-conditionals/70-match/description.es.yml
new file mode 100644
index 00000000..85fb9f02
--- /dev/null
+++ b/modules/48-conditionals/70-match/description.es.yml
@@ -0,0 +1,111 @@
+---
+
+name: Expresión match
+theory: |
+  La expresión `match` apareció en PHP 8 y resuelve la misma tarea que `switch`: elige un resultado según el valor de una variable. Las construcciones son similares, pero `match` es más corta y funciona como una expresión. Comparémoslas con un ejemplo. Así se selecciona un texto según el estado del pedido con `switch`:
+
+  ```php
+  <?php
+
+  switch ($status) {
+      case 'processing':
+          $statusText = 'El pedido está en proceso';
+          break;
+      case 'paid':
+          $statusText = 'El pedido está pagado';
+          break;
+      case 'new':
+          $statusText = 'Pedido nuevo';
+          break;
+      default:
+          $statusText = 'Estado desconocido';
+  }
+  ```
+
+  Lo mismo con `match` ocupa menos espacio, y el resultado va directamente a la variable:
+
+  ```php
+  <?php
+
+  $statusText = match ($status) {
+      'processing' => 'El pedido está en proceso',
+      'paid' => 'El pedido está pagado',
+      'new' => 'Pedido nuevo',
+      default => 'Estado desconocido',
+  };
+  ```
+
+  ```text
+  match (valor) {
+    │
+    ├── 'a' → resultado 1
+    ├── 'b' → resultado 2
+    ├── 'c' → resultado 3
+    └── default → resultado por defecto
+  }
+  ```
+
+  A la izquierda de la flecha `=>` está el valor a comparar, y a la derecha, cualquier expresión que se convertirá en el resultado. La rama `default` se activa cuando ningún valor coincide y cumple el papel de `else`. Si varios valores llevan al mismo resultado, se enumeran separados por comas:
+
+  ```php
+  <?php
+
+  $type = match ($size) {
+      'xs', 's' => 'small',
+      'm' => 'medium',
+      'l', 'xl' => 'large',
+  };
+  ```
+
+  La principal diferencia con `switch` es que `match` es una **expresión**. Toda la construcción se evalúa a un valor, por lo que el resultado se puede asignar a una variable o devolver desde una función de inmediato. `switch` no puede hacer esto; necesita una variable aparte o un `return` dentro de un `case`. Hay otras diferencias:
+
+  * `match` compara los valores de forma estricta, como el operador `===`, sin conversión automática de tipos. `switch` compara de forma no estricta, con `==`.
+  * `match` ejecuta exactamente una rama, por lo que no se necesita `break`. En `switch`, sin `break`, el control cae en cascada al siguiente `case`.
+  * Si nada coincide en `match` y no hay `default`, el programa termina con un error `UnhandledMatchError`. En el mismo caso, `switch` no hace nada.
+
+  Como `match` devuelve un valor, su resultado a menudo se devuelve directamente desde la función con `return`:
+
+  ```php
+  <?php
+
+  function countItems(int $count): ?string
+  {
+      return match ($count) {
+          1 => 'one',
+          2 => 'two',
+          default => null,
+      };
+  }
+
+  print_r(countItems(2)); // => two
+  ```
+
+  Técnicamente siempre se puede prescindir de `match`, igual que de `switch`. Pero cuando hay que elegir un resultado según valores concretos de una variable, `match` expresa esa intención con la mayor claridad, y ese código es más fácil de leer que una cadena de `elseif`.
+
+instructions: |
+  Implementa una función `calculateDeliveryCost()` que reciba el país de entrega y el peso del paquete en kilogramos. La función debe devolver el costo de la entrega.
+
+  Cada país tiene dos tarifas: una para paquetes de hasta 1 kg inclusive y otra para paquetes más pesados:
+
+  * `'canada'`: 600 para paquetes de hasta 1 kg, 900 para el resto
+  * `'usa'`: 800 para paquetes de hasta 1 kg, 1200 para el resto
+  * `'germany'`: 700 para paquetes de hasta 1 kg, 1000 para el resto
+
+  Si el país es desconocido, la función debe devolver `null`.
+
+  Ejemplos de llamada de la función:
+
+  ```php
+  <?php
+
+  calculateDeliveryCost('canada', 0.5); // 600
+  calculateDeliveryCost('canada', 2);   // 900
+  calculateDeliveryCost('usa', 1);      // 800
+  calculateDeliveryCost('france', 1);   // null
+  ```
+
+  Pista: a la derecha de la flecha `=>` puede ir cualquier expresión, incluido el operador ternario.
+
+tips:
+  - |
+    [match](https://www.php.net/manual/es/control-structures.match.php)
diff --git a/modules/48-conditionals/70-match/en/EXERCISE.md b/modules/48-conditionals/70-match/en/EXERCISE.md
new file mode 100644
index 00000000..1e35a5fe
--- /dev/null
+++ b/modules/48-conditionals/70-match/en/EXERCISE.md
@@ -0,0 +1,23 @@
+
+Implement a function `calculateDeliveryCost()` that takes a delivery country and a parcel weight in kilograms. The function should return the delivery cost.
+
+Each country has two rates: one for parcels weighing up to and including 1 kg, and another for heavier parcels:
+
+* `'canada'`: 600 for parcels up to 1 kg, 900 for the rest
+* `'usa'`: 800 for parcels up to 1 kg, 1200 for the rest
+* `'germany'`: 700 for parcels up to 1 kg, 1000 for the rest
+
+If the country is unknown, the function should return `null`.
+
+Function call examples:
+
+```php
+<?php
+
+calculateDeliveryCost('canada', 0.5); // 600
+calculateDeliveryCost('canada', 2);   // 900
+calculateDeliveryCost('usa', 1);      // 800
+calculateDeliveryCost('france', 1);   // null
+```
+
+Hint: any expression can appear to the right of the `=>` arrow, including the ternary operator.
diff --git a/modules/48-conditionals/70-match/en/README.md b/modules/48-conditionals/70-match/en/README.md
new file mode 100644
index 00000000..31bc4329
--- /dev/null
+++ b/modules/48-conditionals/70-match/en/README.md
@@ -0,0 +1,79 @@
+The `match` expression appeared in PHP 8 and solves the same task as `switch`: it picks a result based on a variable's value. The constructs are similar, but `match` is shorter and works as an expression. Let's compare them on one example. Here is how you select a text by an order status with `switch`:
+
+```php
+<?php
+
+switch ($status) {
+    case 'processing':
+        $statusText = 'Order is being processed';
+        break;
+    case 'paid':
+        $statusText = 'Order is paid';
+        break;
+    case 'new':
+        $statusText = 'New order';
+        break;
+    default:
+        $statusText = 'Unknown status';
+}
+```
+
+The same thing with `match` takes less space, and the result goes straight into the variable:
+
+```php
+<?php
+
+$statusText = match ($status) {
+    'processing' => 'Order is being processed',
+    'paid' => 'Order is paid',
+    'new' => 'New order',
+    default => 'Unknown status',
+};
+```
+
+```text
+match (value) {
+  │
+  ├── 'a' → result 1
+  ├── 'b' → result 2
+  ├── 'c' → result 3
+  └── default → default result
+}
+```
+
+To the left of the `=>` arrow is the value to compare, and to the right is any expression that becomes the result. The `default` arm fires when no value matches and plays the role of `else`. If several values lead to the same result, they are listed separated by commas:
+
+```php
+<?php
+
+$type = match ($size) {
+    'xs', 's' => 'small',
+    'm' => 'medium',
+    'l', 'xl' => 'large',
+};
+```
+
+The main difference from `switch` is that `match` is an **expression**. The whole construct evaluates to a value, so the result can be assigned to a variable or returned from a function right away. `switch` cannot do this; it needs a separate variable or a `return` inside a `case`. There are other differences too:
+
+* `match` compares values strictly, like the `===` operator, with no automatic type conversion. `switch` compares loosely, with `==`.
+* `match` executes exactly one arm, so no `break` is needed. In `switch`, without `break`, control falls through to the next `case`.
+* If nothing matches in `match` and there is no `default`, the program terminates with an `UnhandledMatchError`. In the same case, `switch` does nothing.
+
+Since `match` returns a value, its result is often returned straight from the function with `return`:
+
+```php
+<?php
+
+function countItems(int $count): ?string
+{
+    return match ($count) {
+        1 => 'one',
+        2 => 'two',
+        default => null,
+    };
+}
+
+print_r(countItems(2)); // => two
+```
+
+Technically you can always do without `match`, just as without `switch`. But when you need to pick a result by specific values of a variable, `match` expresses that intent most clearly, and such code is easier to read than a chain of `elseif`.
diff --git a/modules/48-conditionals/70-match/en/data.yml b/modules/48-conditionals/70-match/en/data.yml
new file mode 100644
index 00000000..05b81e0f
--- /dev/null
+++ b/modules/48-conditionals/70-match/en/data.yml
@@ -0,0 +1,5 @@
+---
+name: Match expression
+tips:
+  - |
+    [match](https://www.php.net/manual/en/control-structures.match.php)
diff --git a/modules/48-conditionals/70-match/es/EXERCISE.md b/modules/48-conditionals/70-match/es/EXERCISE.md
new file mode 100644
index 00000000..252b73c2
--- /dev/null
+++ b/modules/48-conditionals/70-match/es/EXERCISE.md
@@ -0,0 +1,23 @@
+
+Implementa una función `calculateDeliveryCost()` que reciba el país de entrega y el peso del paquete en kilogramos. La función debe devolver el costo de la entrega.
+
+Cada país tiene dos tarifas: una para paquetes de hasta 1 kg inclusive y otra para paquetes más pesados:
+
+* `'canada'`: 600 para paquetes de hasta 1 kg, 900 para el resto
+* `'usa'`: 800 para paquetes de hasta 1 kg, 1200 para el resto
+* `'germany'`: 700 para paquetes de hasta 1 kg, 1000 para el resto
+
+Si el país es desconocido, la función debe devolver `null`.
+
+Ejemplos de llamada de la función:
+
+```php
+<?php
+
+calculateDeliveryCost('canada', 0.5); // 600
+calculateDeliveryCost('canada', 2);   // 900
+calculateDeliveryCost('usa', 1);      // 800
+calculateDeliveryCost('france', 1);   // null
+```
+
+Pista: a la derecha de la flecha `=>` puede ir cualquier expresión, incluido el operador ternario.
diff --git a/modules/48-conditionals/70-match/es/README.md b/modules/48-conditionals/70-match/es/README.md
new file mode 100644
index 00000000..81abe7b8
--- /dev/null
+++ b/modules/48-conditionals/70-match/es/README.md
@@ -0,0 +1,79 @@
+La expresión `match` apareció en PHP 8 y resuelve la misma tarea que `switch`: elige un resultado según el valor de una variable. Las construcciones son similares, pero `match` es más corta y funciona como una expresión. Comparémoslas con un ejemplo. Así se selecciona un texto según el estado del pedido con `switch`:
+
+```php
+<?php
+
+switch ($status) {
+    case 'processing':
+        $statusText = 'El pedido está en proceso';
+        break;
+    case 'paid':
+        $statusText = 'El pedido está pagado';
+        break;
+    case 'new':
+        $statusText = 'Pedido nuevo';
+        break;
+    default:
+        $statusText = 'Estado desconocido';
+}
+```
+
+Lo mismo con `match` ocupa menos espacio, y el resultado va directamente a la variable:
+
+```php
+<?php
+
+$statusText = match ($status) {
+    'processing' => 'El pedido está en proceso',
+    'paid' => 'El pedido está pagado',
+    'new' => 'Pedido nuevo',
+    default => 'Estado desconocido',
+};
+```
+
+```text
+match (valor) {
+  │
+  ├── 'a' → resultado 1
+  ├── 'b' → resultado 2
+  ├── 'c' → resultado 3
+  └── default → resultado por defecto
+}
+```
+
+A la izquierda de la flecha `=>` está el valor a comparar, y a la derecha, cualquier expresión que se convertirá en el resultado. La rama `default` se activa cuando ningún valor coincide y cumple el papel de `else`. Si varios valores llevan al mismo resultado, se enumeran separados por comas:
+
+```php
+<?php
+
+$type = match ($size) {
+    'xs', 's' => 'small',
+    'm' => 'medium',
+    'l', 'xl' => 'large',
+};
+```
+
+La principal diferencia con `switch` es que `match` es una **expresión**. Toda la construcción se evalúa a un valor, por lo que el resultado se puede asignar a una variable o devolver desde una función de inmediato. `switch` no puede hacer esto; necesita una variable aparte o un `return` dentro de un `case`. Hay otras diferencias:
+
+* `match` compara los valores de forma estricta, como el operador `===`, sin conversión automática de tipos. `switch` compara de forma no estricta, con `==`.
+* `match` ejecuta exactamente una rama, por lo que no se necesita `break`. En `switch`, sin `break`, el control cae en cascada al siguiente `case`.
+* Si nada coincide en `match` y no hay `default`, el programa termina con un error `UnhandledMatchError`. En el mismo caso, `switch` no hace nada.
+
+Como `match` devuelve un valor, su resultado a menudo se devuelve directamente desde la función con `return`:
+
+```php
+<?php
+
+function countItems(int $count): ?string
+{
+    return match ($count) {
+        1 => 'one',
+        2 => 'two',
+        default => null,
+    };
+}
+
+print_r(countItems(2)); // => two
+```
+
+Técnicamente siempre se puede prescindir de `match`, igual que de `switch`. Pero cuando hay que elegir un resultado según valores concretos de una variable, `match` expresa esa intención con la mayor claridad, y ese código es más fácil de leer que una cadena de `elseif`.
diff --git a/modules/48-conditionals/70-match/es/data.yml b/modules/48-conditionals/70-match/es/data.yml
new file mode 100644
index 00000000..a0497120
--- /dev/null
+++ b/modules/48-conditionals/70-match/es/data.yml
@@ -0,0 +1,5 @@
+---
+name: Expresión match
+tips:
+  - |
+    [match](https://www.php.net/manual/es/control-structures.match.php)
diff --git a/modules/48-conditionals/70-match/ru/EXERCISE.md b/modules/48-conditionals/70-match/ru/EXERCISE.md
new file mode 100644
index 00000000..068cf120
--- /dev/null
+++ b/modules/48-conditionals/70-match/ru/EXERCISE.md
@@ -0,0 +1,23 @@
+
+Реализуйте функцию `calculateDeliveryCost()`, которая принимает страну доставки и вес посылки в килограммах. Функция должна вернуть стоимость доставки.
+
+Для каждой страны есть два тарифа: для посылок весом до 1 кг включительно и для более тяжелых посылок:
+
+* `'canada'`: 600 для посылок до 1 кг, 900 для остальных
+* `'usa'`: 800 для посылок до 1 кг, 1200 для остальных
+* `'germany'`: 700 для посылок до 1 кг, 1000 для остальных
+
+Если страна неизвестна, функция должна вернуть `null`.
+
+Примеры вызова функции:
+
+```php
+<?php
+
+calculateDeliveryCost('canada', 0.5); // 600
+calculateDeliveryCost('canada', 2);   // 900
+calculateDeliveryCost('usa', 1);      // 800
+calculateDeliveryCost('france', 1);   // null
+```
+
+Подсказка: справа от стрелки `=>` может стоять любое выражение, в том числе тернарный оператор.
diff --git a/modules/48-conditionals/70-match/ru/README.md b/modules/48-conditionals/70-match/ru/README.md
new file mode 100644
index 00000000..434937ac
--- /dev/null
+++ b/modules/48-conditionals/70-match/ru/README.md
@@ -0,0 +1,79 @@
+Выражение `match` появилось в PHP 8 и решает ту же задачу, что и `switch`: выбирает результат по значению переменной. Конструкции похожи, но `match` записывается короче и работает как выражение. Сравним их на одном примере. Вот выбор текста по статусу заказа через `switch`:
+
+```php
+<?php
+
+switch ($status) {
+    case 'processing':
+        $statusText = 'Заказ в обработке';
+        break;
+    case 'paid':
+        $statusText = 'Заказ оплачен';
+        break;
+    case 'new':
+        $statusText = 'Новый заказ';
+        break;
+    default:
+        $statusText = 'Неизвестный статус';
+}
+```
+
+То же самое на `match` занимает меньше места, а результат сразу попадает в переменную:
+
+```php
+<?php
+
+$statusText = match ($status) {
+    'processing' => 'Заказ в обработке',
+    'paid' => 'Заказ оплачен',
+    'new' => 'Новый заказ',
+    default => 'Неизвестный статус',
+};
+```
+
+```text
+match (значение) {
+  │
+  ├── 'a' → результат 1
+  ├── 'b' → результат 2
+  ├── 'c' → результат 3
+  └── default → результат по умолчанию
+}
+```
+
+Слева от стрелки `=>` стоит значение для сравнения, справа — любое выражение, которое станет результатом. Ветка `default` срабатывает, когда не подошло ни одно значение, и играет роль `else`. Если одному результату соответствует несколько значений, их перечисляют через запятую:
+
+```php
+<?php
+
+$type = match ($size) {
+    'xs', 's' => 'small',
+    'm' => 'medium',
+    'l', 'xl' => 'large',
+};
+```
+
+Главное отличие от `switch` в том, что `match` — это **выражение**. Вся конструкция вычисляется в значение, поэтому результат сразу присваивают переменной или возвращают из функции. У `switch` так не получится, для результата нужна отдельная переменная или `return` внутри `case`. Есть и другие различия:
+
+* `match` сравнивает значения строго, как оператор `===`, без автоматического преобразования типов. `switch` сравнивает нестрого, через `==`.
+* В `match` выполняется ровно одна ветка, поэтому `break` не нужен. В `switch` без `break` управление "проваливается" в следующий `case`.
+* Если в `match` ничего не совпало и нет `default`, программа завершится с ошибкой `UnhandledMatchError`. `switch` в этом случае ничего не делает.
+
+Раз `match` возвращает значение, его результат часто отдают прямо из функции через `return`:
+
+```php
+<?php
+
+function countItems(int $count): ?string
+{
+    return match ($count) {
+        1 => 'one',
+        2 => 'two',
+        default => null,
+    };
+}
+
+print_r(countItems(2)); // => two
+```
+
+Технически без `match` всегда можно обойтись, как и без `switch`. Но когда нужно выбрать результат по конкретным значениям переменной, `match` выражает это намерение яснее всего, и читать такой код легче, чем цепочку `elseif`.
diff --git a/modules/48-conditionals/70-match/ru/data.yml b/modules/48-conditionals/70-match/ru/data.yml
new file mode 100644
index 00000000..b3972cc5
--- /dev/null
+++ b/modules/48-conditionals/70-match/ru/data.yml
@@ -0,0 +1,6 @@
+---
+name: Выражение match
+tips:
+  - |
+    [match](https://www.php.net/manual/ru/control-structures.match.php)
+definitions: []
diff --git a/modules/48-conditionals/75-elvis/index.php b/modules/48-conditionals/75-elvis/Solution.php
similarity index 70%
rename from modules/48-conditionals/75-elvis/index.php
rename to modules/48-conditionals/75-elvis/Solution.php
index 5b2562ed..f8cd1b8c 100644
--- a/modules/48-conditionals/75-elvis/index.php
+++ b/modules/48-conditionals/75-elvis/Solution.php
@@ -3,7 +3,7 @@
 namespace HexletBasics\Conditionals\Elvis;
 
 // BEGIN
-function generateAmount($amount, $price)
+function generateAmount(int $amount, int $price): int
 {
     $result = $amount ?: $price * 3;
 
diff --git a/modules/48-conditionals/75-elvis/SolutionTest.php b/modules/48-conditionals/75-elvis/SolutionTest.php
index e49dc302..f019ac96 100644
--- a/modules/48-conditionals/75-elvis/SolutionTest.php
+++ b/modules/48-conditionals/75-elvis/SolutionTest.php
@@ -2,14 +2,12 @@
 
 namespace HexletBasics\Conditionals\Elvis;
 
-use PHPUnit\Framework\TestCase;
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        require 'index.php';
-
         $this->assertEquals(6, generateAmount(0, 2));
         $this->assertEquals(15, generateAmount(0, 5));
         $this->assertEquals(1, generateAmount(1, 2));
diff --git a/modules/48-conditionals/75-elvis/description.es.yml b/modules/48-conditionals/75-elvis/description.es.yml
index 36e1db41..6e000e10 100644
--- a/modules/48-conditionals/75-elvis/description.es.yml
+++ b/modules/48-conditionals/75-elvis/description.es.yml
@@ -7,7 +7,7 @@ theory: |
   ```php
   <?php
 
-  function generateGreeting($name, $nickname)
+  function generateGreeting(string $name, string $nickname): string
   {
       if ($name) {
           return "¡Hola, {$name}!";
@@ -27,7 +27,7 @@ theory: |
   ```php
   <?php
 
-  function generateGreeting($name, $nickname)
+  function generateGreeting(string $name, string $nickname): string
   {
       return $name ? "¡Hola, {$name}!" : "¡Hola, {$nickname}!";
   }
@@ -43,7 +43,7 @@ theory: |
   ```php
   <?php
 
-  function generateGreeting($name, $nickname)
+  function generateGreeting(string $name, string $nickname): string
   {
       $user = $name ?: $nickname;
       return "¡Hola, {$user}!";
diff --git a/modules/48-conditionals/75-elvis/en/README.md b/modules/48-conditionals/75-elvis/en/README.md
index b0ccb366..0b15d632 100644
--- a/modules/48-conditionals/75-elvis/en/README.md
+++ b/modules/48-conditionals/75-elvis/en/README.md
@@ -6,7 +6,7 @@ Let's try to assemble a string that greets users according to these requirements
 ```php
 <?php
 
-function generateGreeting($name, $nickname)
+function generateGreeting(string $name, string $nickname): string
 {
     if ($name) {
         return "Hello, {$name}!";
@@ -26,7 +26,7 @@ You can use a ternary operator to write it in an even shorter way:
 ```php
 <?php
 
-function generateGreeting($name, $nickname)
+function generateGreeting(string $name, string $nickname): string
 {
     return $name ? "Hello, {$name}!" : "Hello, {$nickname}!";
 }
@@ -39,7 +39,7 @@ In PHP, there's a special operator for such cases:
 ```php
 <?php
 
-function generateGreeting($name, $nickname)
+function generateGreeting(string $name, string $nickname): string
 {
     $user = $name ?: $nickname;
     return "Hello, {$user}!";
diff --git a/modules/48-conditionals/75-elvis/es/README.md b/modules/48-conditionals/75-elvis/es/README.md
index fc4e90c4..eaa43bdf 100644
--- a/modules/48-conditionals/75-elvis/es/README.md
+++ b/modules/48-conditionals/75-elvis/es/README.md
@@ -3,7 +3,7 @@ Imaginemos el siguiente escenario: en un sitio web, los usuarios pueden tener no
 ```php
 <?php
 
-function generateGreeting($name, $nickname)
+function generateGreeting(string $name, string $nickname): string
 {
     if ($name) {
         return "¡Hola, {$name}!";
@@ -23,7 +23,7 @@ Con el operador ternario, podemos obtener una forma más corta:
 ```php
 <?php
 
-function generateGreeting($name, $nickname)
+function generateGreeting(string $name, string $nickname): string
 {
     return $name ? "¡Hola, {$name}!" : "¡Hola, {$nickname}!";
 }
@@ -39,7 +39,7 @@ En PHP, para estos casos, existe un operador especial:
 ```php
 <?php
 
-function generateGreeting($name, $nickname)
+function generateGreeting(string $name, string $nickname): string
 {
     $user = $name ?: $nickname;
     return "¡Hola, {$user}!";
diff --git a/modules/48-conditionals/75-elvis/ru/README.md b/modules/48-conditionals/75-elvis/ru/README.md
index bfb19cac..b1643588 100644
--- a/modules/48-conditionals/75-elvis/ru/README.md
+++ b/modules/48-conditionals/75-elvis/ru/README.md
@@ -3,7 +3,7 @@
 ```php
 <?php
 
-function generateGreeting($name, $nickname)
+function generateGreeting(string $name, string $nickname): string
 {
     if ($name) {
         return "Hello, {$name}!";
@@ -23,7 +23,7 @@ generateGreeting('', 'CoolBob86');    // 'Hello, CoolBob86!'
 ```php
 <?php
 
-function generateGreeting($name, $nickname)
+function generateGreeting(string $name, string $nickname): string
 {
     return $name ? "Hello, {$name}!" : "Hello, {$nickname}!";
 }
@@ -39,7 +39,7 @@ function generateGreeting($name, $nickname)
 ```php
 <?php
 
-function generateGreeting($name, $nickname)
+function generateGreeting(string $name, string $nickname): string
 {
     $user = $name ?: $nickname;
     return "Hello, {$user}!";
diff --git a/modules/50-loops/10-while/index.php b/modules/50-loops/10-while/Solution.php
similarity index 64%
rename from modules/50-loops/10-while/index.php
rename to modules/50-loops/10-while/Solution.php
index 5f2aa2be..ad81e528 100644
--- a/modules/50-loops/10-while/index.php
+++ b/modules/50-loops/10-while/Solution.php
@@ -2,14 +2,14 @@
 
 namespace HexletBasics\Loops\WhileLoop;
 
-function printNumbers($firstNumber)
+function printCountdown(int $seconds): void
 {
     // BEGIN
-    $i = $firstNumber;
+    $i = $seconds;
     while ($i >= 1) {
         print_r("{$i}\n");
         $i = $i - 1;
     }
-    print_r('finished!');
+    print_r('Go!');
     // END
 }
diff --git a/modules/50-loops/10-while/SolutionTest.php b/modules/50-loops/10-while/SolutionTest.php
index 5d790409..e92c2077 100644
--- a/modules/50-loops/10-while/SolutionTest.php
+++ b/modules/50-loops/10-while/SolutionTest.php
@@ -2,16 +2,14 @@
 
 namespace HexletBasics\Loops\WhileLoop;
 
-use PHPUnit\Framework\TestCase;
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        require 'index.php';
-
-        $expected = "3\n2\n1\nfinished!";
+        $expected = "4\n3\n2\n1\nGo!";
         $this->expectOutputString($expected);
-        printNumbers(3);
+        printCountdown(4);
     }
 }
diff --git a/modules/50-loops/10-while/ru/EXERCISE.md b/modules/50-loops/10-while/ru/EXERCISE.md
index 17badff6..1ffeda83 100644
--- a/modules/50-loops/10-while/ru/EXERCISE.md
+++ b/modules/50-loops/10-while/ru/EXERCISE.md
@@ -1,16 +1,14 @@
-Модифицируйте функцию `printNumbers()` так, чтобы она выводила числа в обратном порядке. Для этого нужно идти от верхней границы к нижней. То есть, счетчик должен быть инициализирован максимальным значением, а в теле цикла его нужно уменьшать до нижней границы.
+Напишите функцию `printCountdown()`, которая имитирует обратный отсчет перед стартом. Функция принимает количество секунд и печатает числа от этого значения до `1`.
 
+После завершения отсчета функция должна вывести на экран строку `Go!`.
 
 ```php
 <?php
 
-printNumbers(4);
-```
-
-```text
-4
-3
-2
-1
-finished!
+printCountdown(4);
+// => 4
+// => 3
+// => 2
+// => 1
+// => Go!
 ```
diff --git a/modules/50-loops/10-while/ru/README.md b/modules/50-loops/10-while/ru/README.md
index bca12c38..dcdf5aed 100644
--- a/modules/50-loops/10-while/ru/README.md
+++ b/modules/50-loops/10-while/ru/README.md
@@ -1,121 +1,106 @@
-Программы, которые мы пишем, становятся все сложнее и объемнее. Они все еще очень далеки от реальных программ, где количество строк кода измеряется десятками и сотнями тысяч. Текущая сложность уже способна заставить напрячься людей без опыта. Начиная с этого урока, мы переходим к одной из самых сложных базовых тем в программировании – **циклам**.
+Помимо условных конструкций, в программировании невозможно обойтись без циклов. Это специальный механизм, позволяющий выполнять любое действие многократно. На его базе строятся практически любые вычисления — от подсчета среднего балла в группе до обработки входящих запросов на сайтах.
 
-Любые прикладные программы служат прагматичным целям. Они помогают управлять сотрудниками и финансами, развлекают, в конце концов. Несмотря на различия, все эти программы выполняют заложенные в них алгоритмы, которые похожи между собой. Что это такое? **Алгоритм** — это последовательность действий или инструкций, которая приводит нас к некоему ожидаемому результату. Это описание подходит под любую программу, но под алгоритмами обычно понимается что-то более специфичное.
+Цикл хранит повторяющееся действие в одном месте и запускает его снова, пока условие остается истинным.
 
-Представьте себе, что у нас есть книга, и мы хотим найти внутри нее какую-то конкретную фразу. Саму фразу мы помним, но не знаем, на какой она странице. Как найти нужную страницу? Самый простой и долгий способ — последовательно просматривать страницы до тех пор, пока мы не найдем нужную фразу. В худшем случае придется просмотреть все страницы, но результат мы все равно получим. Именно этот процесс и называется **алгоритмом**. Он включает в себя перебор страниц и логические проверки, нашли мы фразу или нет.
+## Первый пример
 
-Заранее неизвестно количество страниц, которое придется посмотреть, но сам процесс просмотра повторяется из раза в раз совершенно одинаково. Для выполнения таких повторяющихся действий как раз и нужны **циклы**. Каждый такой повтор называется **итерацией**.
+Пусть программа должна пять раз вывести строку `Hello!`. Чтобы остановить повторение в нужный момент, программе нужна переменная, которая хранит номер текущего шага. Такую переменную обычно называют счетчиком.
 
-Допустим, мы хотим написать функцию, которая выводит на экран все числа от единицы до указанного (через аргументы):
+В примере счетчик называется `$counter`. Перед циклом он равен `0`. После каждого вывода строки мы увеличиваем его на единицу.
 
 ```php
 <?php
 
-printNumbers(3);
-// => 1
-// => 2
-// => 3
+$counter = 0;
+while ($counter < 5) {
+    print_r("Hello!\n");
+    $counter = $counter + 1;
+}
+
+// => Hello!
+// => Hello!
+// => Hello!
+// => Hello!
+// => Hello!
 ```
 
-Эту функцию невозможно реализовать уже изученными средствами, так как количество выводов на экран заранее не известно. А с циклами это не составит никаких проблем:
+Теперь цикл может проверять значение счетчика перед каждым повтором. Пока `$counter < 5`, выполняется код в фигурных скобках после `while`. Такой блок называют телом цикла.
 
-```php
-<?php
+После выполнения тела интерпретатор возвращается к условию и проверяет его заново. Пока условие истинно, цикл продолжается. Когда условие становится ложным (`false`), программа выходит из цикла и выполняет следующий код.
 
-function printNumbers($lastNumber)
-{
-    // Переменная i — это сокращение от index (порядковый номер)
-    // Он используется по общему соглашению во множестве языков
-    // в качестве счетчика цикла
-    $i = 1;
+Без изменения счетчика условие никогда не станет ложным, и цикл превратится в бесконечный. Со стороны это выглядит так, как будто программа зависла.
 
-    while ($i <= $lastNumber) {
-        print_r($i);
-        print_r("\n");
-        $i = $i + 1;
-    }
-    print_r('finished!');
-}
-
-printNumbers(3);
-// => 1
-// => 2
-// => 3
-// => finished!
-```
+## Работа цикла по шагам
 
+Перед первым повтором `$counter` равен `0`.
 
-В коде функции использован цикл `while`. Он состоит из трех элементов:
+**Шаг 1.** Интерпретатор проверяет `$counter < 5`. Значение `0` меньше `5`, поэтому выполняется тело цикла.
+На экран выводится `Hello!`, а `$counter` увеличивается до `1`.
 
-* Ключевое слово `while` — несмотря на схожесть с вызовом функций, это не вызов функции
-* Предикат — условие, которое указывается в скобках после `while` и вычисляется на каждой итерации
-* Тело цикла — блок кода в фигурных скобках
+**Шаг 2.** Интерпретатор снова проверяет условие. Значение `1` все еще меньше `5`, поэтому тело цикла выполняется еще раз.
+На экран снова выводится `Hello!`, а `$counter` увеличивается до `2`.
 
-Конструкция читается так: «делать то, что указано в теле цикла, пока истинно условие `$i <= $lastNumber`».
+Так продолжается, пока `$counter` не станет равен `5`. При следующей проверке условие `$counter < 5` будет ложным, поэтому цикл завершится. Дальше программа выполнит код после цикла.
 
-Разберем работу этого кода для вызова `printNumbers(3)`:
+Та же последовательность на схеме.
 
-```php
-<?php
+```text
+$counter = 0
+┌──→ $counter < 5?
+│     true │
+│          ↓
+│    print_r("Hello!\n")
+│    $counter = $counter + 1
+└──────────┘
+      false → выход из цикла
+```
 
-// Инициализируется переменная i
-$i = 1;
+После завершения цикла `$counter` равен `5`, а строка `Hello!` напечатана пять раз.
 
-// Предикат возвращает true, поэтому выполняется тело цикла
-while (1 <= 3)
-// print_r(1);
-// $i = 1 + 1;
+## Тело цикла и продолжение программы
 
-// Закончилось тело цикла, поэтому происходит возврат в начало
-while (2 <= 3)
-// print_r(2);
-// $i = 2 + 1;
+К телу цикла относятся все строки внутри фигурных скобок после `while`. Когда закрывающая скобка заканчивает блок, заканчивается и цикл.
 
-// Закончилось тело цикла, поэтому происходит возврат в начало
-while (3 <= 3)
-// print_r(3);
-// $i = 3 + 1;
+```php
+<?php
 
-// Предикат возвращает false, поэтому выполнение переходит за цикл
-while (4 <= 3)
+$counter = 0;
+while ($counter < 2) {
+    print_r("Hello!\n");
+    $counter = $counter + 1;
+}
 
-// print_r('finished!');
-// На этом этапе i равен 4, но он нам уже не нужен
-// Функция завершается
+print_r("End of loop\n");
 ```
 
-Самое главное в цикле — завершение его работы (выход из цикла). Процесс, который порождает цикл, должен в конце концов остановиться. Ответственность за остановку полностью лежит на программисте.
+В этом примере `print_r("Hello!\n")` и `$counter = $counter + 1` находятся внутри цикла. Строка `print_r("End of loop\n")` стоит после закрывающей скобки, поэтому выполнится один раз после завершения цикла.
 
-Обычно задача сводится к введению переменной, называемой **счетчиком цикла**. Сначала счетчик инициализируется, то есть ему задается начальное значение. В нашем примере это инструкция `$i = 1`, выполняемая до входа в цикл. Затем в условии цикла проверяется, достиг ли счетчик своего предельного значения. И, наконец, счетчик меняет свое значение `$i = $i + 1`.
+По фигурным скобкам PHP понимает, какие строки нужно повторять, а какие идут дальше по программе.
 
-На этом моменте новички делают больше всего ошибок. Например, случайно забытое увеличение счетчика или неправильная проверка в предикате способны привести к **зацикливанию**. Это ситуация, при которой цикл работает бесконечно, и программа никогда не останавливается.
+## Цикл внутри функции
 
-В таком случае приходится ее завершать принудительно:
+Теперь перенесем цикл в функцию. Она напечатает числа от `1` до переданного значения.
 
 ```php
 <?php
 
-function printNumbers($lastNumber)
+function printNumbers(int $n): void
 {
     $i = 1;
-
-    // Этот цикл никогда не остановится
-    // Он будет печатать всегда одно значение
-    while ($i <= $lastNumber) {
-        print_r($i);
+    while ($i <= $n) {
+        print_r($i . "\n");
+        $i = $i + 1;
     }
-    print_r('finished!');
+    print_r("Finished!\n");
 }
-```
-
-В некоторых случаях бесконечные циклы полезны. Здесь мы такие случаи не рассматриваем, но полезно знать, как выглядит такой код:
 
-```php
-<?php
-
-while (true) {
-    // Что-то делаем
-}
+printNumbers(3);
+// => 1
+// => 2
+// => 3
+// => Finished!
 ```
 
-Подведем итог. Когда все же нужны циклы, а когда можно обойтись без них? Физически невозможно обойтись без циклов, когда алгоритм решения задачи требует повторения каких-то действий и количество этих операций заранее неизвестно — как в нашем примере с книгой.
+Цикл `while` печатает числа, пока `$i` не станет больше `$n`. После этого программа выходит из цикла и выполняет `print_r("Finished!\n")`.
+
+Условие и изменение счетчика зависят от задачи. Счетчик можно увеличивать на `1`, на `2` или сразу на `10`. Его можно уменьшать, если цикл идет от большего значения к меньшему. Можно менять счетчик не на каждом повторе, а через один или после выполнения дополнительной проверки. Главное, чтобы условие когда-нибудь стало ложным. Иначе цикл будет работать бесконечно.
diff --git a/modules/50-loops/55-return-from-loop/Makefile b/modules/50-loops/15-conditions-inside-loops/Makefile
similarity index 100%
rename from modules/50-loops/55-return-from-loop/Makefile
rename to modules/50-loops/15-conditions-inside-loops/Makefile
diff --git a/modules/50-loops/26-conditions-inside-loops/index.php b/modules/50-loops/15-conditions-inside-loops/Solution.php
similarity index 50%
rename from modules/50-loops/26-conditions-inside-loops/index.php
rename to modules/50-loops/15-conditions-inside-loops/Solution.php
index 5caffcba..20333f44 100644
--- a/modules/50-loops/26-conditions-inside-loops/index.php
+++ b/modules/50-loops/15-conditions-inside-loops/Solution.php
@@ -3,15 +3,15 @@
 namespace HexletBasics\Loops\ConditionsInsideLoops;
 
 // BEGIN
-function countChars($str, $char)
+function countHashtags(string $text): int
 {
-    $i = 0;
+    $index = 0;
     $count = 0;
-    while ($i < strlen($str)) {
-        if (strtoupper($str[$i]) === strtoupper($char)) {
+    while ($index < strlen($text)) {
+        if ($text[$index] === '#') {
             $count = $count + 1;
         }
-        $i = $i + 1;
+        $index = $index + 1;
     }
 
     return $count;
diff --git a/modules/50-loops/15-conditions-inside-loops/SolutionTest.php b/modules/50-loops/15-conditions-inside-loops/SolutionTest.php
new file mode 100644
index 00000000..29969960
--- /dev/null
+++ b/modules/50-loops/15-conditions-inside-loops/SolutionTest.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace HexletBasics\Loops\ConditionsInsideLoops;
+
+use HexletBasics\Exercise\TestCase;
+
+class SolutionTest extends TestCase
+{
+    public function test()
+    {
+        $this->assertEquals(2, countHashtags('New post #php #code'));
+        $this->assertEquals(0, countHashtags('No tags here'));
+        $this->assertEquals(2, countHashtags('#start and #finish'));
+        $this->assertEquals(0, countHashtags(''));
+    }
+}
diff --git a/modules/50-loops/26-conditions-inside-loops/description.es.yml b/modules/50-loops/15-conditions-inside-loops/description.es.yml
similarity index 100%
rename from modules/50-loops/26-conditions-inside-loops/description.es.yml
rename to modules/50-loops/15-conditions-inside-loops/description.es.yml
diff --git a/modules/50-loops/26-conditions-inside-loops/en/EXERCISE.md b/modules/50-loops/15-conditions-inside-loops/en/EXERCISE.md
similarity index 100%
rename from modules/50-loops/26-conditions-inside-loops/en/EXERCISE.md
rename to modules/50-loops/15-conditions-inside-loops/en/EXERCISE.md
diff --git a/modules/50-loops/26-conditions-inside-loops/en/README.md b/modules/50-loops/15-conditions-inside-loops/en/README.md
similarity index 100%
rename from modules/50-loops/26-conditions-inside-loops/en/README.md
rename to modules/50-loops/15-conditions-inside-loops/en/README.md
diff --git a/modules/50-loops/26-conditions-inside-loops/en/data.yml b/modules/50-loops/15-conditions-inside-loops/en/data.yml
similarity index 100%
rename from modules/50-loops/26-conditions-inside-loops/en/data.yml
rename to modules/50-loops/15-conditions-inside-loops/en/data.yml
diff --git a/modules/50-loops/26-conditions-inside-loops/es/EXERCISE.md b/modules/50-loops/15-conditions-inside-loops/es/EXERCISE.md
similarity index 100%
rename from modules/50-loops/26-conditions-inside-loops/es/EXERCISE.md
rename to modules/50-loops/15-conditions-inside-loops/es/EXERCISE.md
diff --git a/modules/50-loops/26-conditions-inside-loops/es/README.md b/modules/50-loops/15-conditions-inside-loops/es/README.md
similarity index 100%
rename from modules/50-loops/26-conditions-inside-loops/es/README.md
rename to modules/50-loops/15-conditions-inside-loops/es/README.md
diff --git a/modules/50-loops/26-conditions-inside-loops/es/data.yml b/modules/50-loops/15-conditions-inside-loops/es/data.yml
similarity index 100%
rename from modules/50-loops/26-conditions-inside-loops/es/data.yml
rename to modules/50-loops/15-conditions-inside-loops/es/data.yml
diff --git a/modules/50-loops/15-conditions-inside-loops/ru/EXERCISE.md b/modules/50-loops/15-conditions-inside-loops/ru/EXERCISE.md
new file mode 100644
index 00000000..4f84dab9
--- /dev/null
+++ b/modules/50-loops/15-conditions-inside-loops/ru/EXERCISE.md
@@ -0,0 +1,9 @@
+Реализуйте функцию `countHashtags()`, которая принимает текст публикации и считает, сколько раз в нем встречается символ `#`.
+
+```php
+<?php
+
+countHashtags('New post #php #code'); // 2
+countHashtags('No tags here');        // 0
+countHashtags('#start and #finish');  // 2
+```
diff --git a/modules/50-loops/15-conditions-inside-loops/ru/README.md b/modules/50-loops/15-conditions-inside-loops/ru/README.md
new file mode 100644
index 00000000..989c2004
--- /dev/null
+++ b/modules/50-loops/15-conditions-inside-loops/ru/README.md
@@ -0,0 +1,59 @@
+Тело цикла, как и тело функции — это место выполнения инструкций. Значит, мы можем использовать внутри него всё изученное ранее, например — условные конструкции. Так программа повторяет одно действие несколько раз, но на каждом повторе принимает решение.
+
+![Условия внутри цикла](./assets/conditions-inside-loops.png)
+
+Пусть нужно пройти числа от `1` до `10` и напечатать только четные. Цикл перебирает все числа подряд, а условие внутри цикла решает, какие из них попадут на экран.
+
+Для перебора нужен счетчик. Он хранит текущее число и увеличивается после каждого повтора. Печатать число нужно только тогда, когда оно проходит проверку:
+
+```php
+<?php
+
+$number = 1;
+while ($number <= 10) {
+    if ($number % 2 === 0) {
+        print_r("{$number}\n");
+    }
+    $number = $number + 1;
+}
+
+// => 2
+// => 4
+// => 6
+// => 8
+// => 10
+```
+
+Цикл `while` перебирает числа от `1` до `10`. Условие внутри цикла проверяет текущее число. Если `$number % 2 === 0`, число делится на `2` без остатка, и программа выводит его на экран.
+
+Счетчик увеличивается после проверки в любом случае. Это важно. Если увеличивать `$number` только внутри `if`, цикл остановится на первом нечетном числе и будет работать бесконечно.
+
+## Работа по шагам
+
+Перед первым повтором `$number` равен `1`.
+
+**Шаг 1.** Условие цикла `$number <= 10` истинно, поэтому программа входит в тело цикла. Число `1` нечетное, блок `if` не выполняется. Затем `$number` увеличивается до `2`.
+
+**Шаг 2.** Условие цикла снова истинно. Число `2` четное, поэтому программа печатает `2`. Затем `$number` увеличивается до `3`.
+
+Дальше цикл продолжает проверять каждое число. Нечетные числа он пропускает, а четные выводит на экран. Когда `$number` станет равен `11`, условие `$number <= 10` станет ложным, и цикл завершится.
+
+## Условия меняют действие, а не движение
+
+В таких циклах удобно разделять две части. Счетчик переводит программу к следующему значению, а `if` решает, что делать с текущим значением.
+
+```php
+<?php
+
+$number = 1;
+while ($number <= 10) {
+    if ($number > 5) {
+        print_r("{$number}\n");
+    }
+    $number = $number + 1;
+}
+```
+
+Здесь цикл проходит тот же диапазон от `1` до `10`, но условие внутри другое. Поэтому программа печатает только числа больше `5`.
+
+Условие внутри цикла может проверять что угодно. Например, четность числа, совпадение символа, длину строки или значение переменной. Главное, чтобы счетчик продолжал меняться, и цикл мог завершиться.
diff --git a/modules/50-loops/15-conditions-inside-loops/ru/assets/conditions-inside-loops.png b/modules/50-loops/15-conditions-inside-loops/ru/assets/conditions-inside-loops.png
new file mode 100644
index 00000000..e016c272
Binary files /dev/null and b/modules/50-loops/15-conditions-inside-loops/ru/assets/conditions-inside-loops.png differ
diff --git a/modules/50-loops/26-conditions-inside-loops/ru/data.yml b/modules/50-loops/15-conditions-inside-loops/ru/data.yml
similarity index 100%
rename from modules/50-loops/26-conditions-inside-loops/ru/data.yml
rename to modules/50-loops/15-conditions-inside-loops/ru/data.yml
diff --git a/modules/50-loops/20-aggregation-numbers/Solution.php b/modules/50-loops/20-aggregation-numbers/Solution.php
new file mode 100644
index 00000000..673a3d20
--- /dev/null
+++ b/modules/50-loops/20-aggregation-numbers/Solution.php
@@ -0,0 +1,24 @@
+<?php
+
+namespace HexletBasics\Loops\AggregationNumbers;
+
+// BEGIN
+function calculateElectricityBill(int $kwh): int
+{
+    $total = 0;
+    $current = 1;
+
+    while ($current <= $kwh) {
+        if ($current <= 100) {
+            $total = $total + 5;
+        } elseif ($current <= 200) {
+            $total = $total + 7;
+        } else {
+            $total = $total + 10;
+        }
+        $current = $current + 1;
+    }
+
+    return $total;
+}
+// END
diff --git a/modules/50-loops/20-aggregation-numbers/SolutionTest.php b/modules/50-loops/20-aggregation-numbers/SolutionTest.php
index 86a4c031..60e8f1ff 100644
--- a/modules/50-loops/20-aggregation-numbers/SolutionTest.php
+++ b/modules/50-loops/20-aggregation-numbers/SolutionTest.php
@@ -1,17 +1,17 @@
 <?php
 
-namespace HexletBasics\Loops\AgregationNumber;
+namespace HexletBasics\Loops\AggregationNumbers;
 
-use PHPUnit\Framework\TestCase;
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        require 'index.php';
-
-        $this->assertEquals(2, multiplyNumbersFromRange(2, 2));
-        $this->assertEquals(6, multiplyNumbersFromRange(1, 3));
-        $this->assertEquals(120, multiplyNumbersFromRange(1, 5));
+        $this->assertEquals(0, calculateElectricityBill(0));
+        $this->assertEquals(400, calculateElectricityBill(80));
+        $this->assertEquals(500, calculateElectricityBill(100));
+        $this->assertEquals(850, calculateElectricityBill(150));
+        $this->assertEquals(1700, calculateElectricityBill(250));
     }
 }
diff --git a/modules/50-loops/20-aggregation-numbers/index.php b/modules/50-loops/20-aggregation-numbers/index.php
deleted file mode 100644
index e6ce3b10..00000000
--- a/modules/50-loops/20-aggregation-numbers/index.php
+++ /dev/null
@@ -1,18 +0,0 @@
-<?php
-
-namespace HexletBasics\Loops\AgregationNumber;
-
-// BEGIN
-function multiplyNumbersFromRange($start, $finish)
-{
-    $i = $start;
-    $result = 1;
-
-    while ($i <= $finish) {
-        $result = $result * $i;
-        $i = $i + 1;
-    }
-
-    return $result;
-}
-// END
diff --git a/modules/50-loops/20-aggregation-numbers/ru/EXERCISE.md b/modules/50-loops/20-aggregation-numbers/ru/EXERCISE.md
index 1a30443e..73173f40 100644
--- a/modules/50-loops/20-aggregation-numbers/ru/EXERCISE.md
+++ b/modules/50-loops/20-aggregation-numbers/ru/EXERCISE.md
@@ -1,9 +1,13 @@
-Реализуйте функцию `multiplyNumbersFromRange()`, которая перемножает числа в указанном диапазоне включая границы диапазона. Пример вызова:
+Реализуйте функцию `calculateElectricityBill()`, которая принимает количество израсходованных киловатт-часов и возвращает сумму счета за электричество.
 
-  ```php
-  <?php
+В этом задании действует ступенчатый тариф. Первые `100` кВт⋅ч стоят по `5` рублей, следующие `100` кВт⋅ч стоят по `7` рублей, а все кВт⋅ч сверх `200` стоят по `10` рублей.
 
-  multiplyNumbersFromRange(1, 5); // 1 * 2 * 3 * 4 * 5 = 120
-  multiplyNumbersFromRange(2, 3); // 2 * 3 = 6
-  multiplyNumbersFromRange(6, 6); // 6
-  ```
+Пройдите расход с помощью цикла и постепенно накопите итоговую сумму.
+
+```php
+<?php
+
+calculateElectricityBill(80);  // 400
+calculateElectricityBill(150); // 850
+calculateElectricityBill(250); // 1700
+```
diff --git a/modules/50-loops/20-aggregation-numbers/ru/README.md b/modules/50-loops/20-aggregation-numbers/ru/README.md
index ab1f1dc5..8fc9f2e1 100644
--- a/modules/50-loops/20-aggregation-numbers/ru/README.md
+++ b/modules/50-loops/20-aggregation-numbers/ru/README.md
@@ -1,8 +1,8 @@
-Есть отдельный класс задач, который не может обойтись без циклов — он называется **агрегированием данных**. К таким задачам относятся поиск максимального и минимального значения, вычисление суммы и среднего арифметического и так далее. Их главная особенность в том, что результат зависит от всего набора данных. Для расчета суммы нужно сложить **все** числа, для вычисления максимального нужно сравнить **все** числа.
+Отдельный класс задач, который не обходится без циклов, называется **агрегированием данных**. К таким задачам относятся поиск максимального или минимального значения, суммы, среднего арифметического. В их случае результат зависит от всего набора данных. В этом уроке разберем, как агрегация применяется к числам и строкам.
 
-С такими задачами хорошо знакомы те, кто занимаются числами — например, бухгалтеры или маркетологи. Обычно их выполняют в таблицах в Microsoft Excel или Google Sheets. Именно эту тему мы изучим в этом уроке.
+![Итерации цикла](./assets/iterations.png)
 
-Разберем самый простой пример – поиск суммы набора чисел. Реализуем функцию, которая складывает числа в указанном диапазоне, включая границы. Диапазоном в данном случае называется ряд чисел от какого-то начала до определенного конца. Например, диапазон [1, 10] включает в себя все целые числа от 1 до 10.
+Допустим, нам нужно найти сумму набора чисел. Реализуем функцию, которая складывает числа в указанном диапазоне, включая границы. **Диапазон** представляет собой ряд чисел от конкретного начала до определенного конца. Например, диапазон [1, 10] включает целые числа от одного до десяти.
 
 ```php
 <?php
@@ -16,39 +16,28 @@ sumNumbersFromRange(1, 1); // 1
 sumNumbersFromRange(100, 100); // 100
 ```
 
-Для реализации этого кода нам понадобится цикл по двум причинам:
-
-* Сложение чисел — это итеративный процесс, то есть он повторяется для каждого числа
-* Количество итераций зависит от размера диапазона
-
-Перед тем, как смотреть код, попробуйте ответить на вопросы ниже:
-
-* Каким значением инициализировать счетчик?
-* Как он будет изменяться?
-* Когда цикл должен остановиться?
-
-Попробуйте сначала подумать над этими вопросами, а затем посмотрите код ниже:
+Чтобы реализовать такой код, понадобится цикл, так как сложение чисел является итеративным процессом, то есть повторяется для каждого числа. Количество итераций зависит от размера диапазона. Вот код этой функции:
 
 ```php
 <?php
 
-  function sumNumbersFromRange ($start, $finish)
-  {
-      // Технически можно менять $start
-      // Но входные аргументы нужно оставлять в исходном значении
-      // Это сделает код проще для анализа
-      $i = $start;
-      $sum = 0; // Инициализация суммы
-
-      while ($i <= $finish) { // Двигаемся до конца диапазона
-          $sum = $sum + $i; // Считаем сумму для каждого числа
-          $i = $i + 1; // Переходим к следующему числу в диапазоне
-      }
-
-      // Возвращаем получившийся результат
-      return $sum;
-  };
-  ```
+function sumNumbersFromRange(int $start, int $finish): int
+{
+    // Технически можно менять $start
+    // Но входные аргументы нужно оставлять в исходном значении
+    // Это сделает код проще для анализа
+    $i = $start;
+    $sum = 0; // Инициализация суммы
+
+    while ($i <= $finish) { // Двигаемся до конца диапазона
+        $sum = $sum + $i; // Считаем сумму для каждого числа
+        $i = $i + 1; // Переходим к следующему числу в диапазоне
+    }
+
+    // Возвращаем получившийся результат
+    return $sum;
+}
+```
 
 Общая структура цикла здесь стандартна. В нем есть три компонента:
 
@@ -74,6 +63,18 @@ $sum = $sum + 5; // 14
 // 14 – результат сложения чисел в диапазоне [2, 5]
 ```
 
+Наглядно процесс накопления суммы выглядит так:
+
+```text
+sumNumbersFromRange(2, 5):
+
+i=2: sum = 0 + 2 = 2
+i=3: sum = 2 + 3 = 5
+i=4: sum = 5 + 4 = 9
+i=5: sum = 9 + 5 = 14
+                    └── результат
+```
+
 У переменной `$sum` есть начальное значение, равное 0. Зачем вообще задавать значение? Любая повторяющаяся операция начинается с какого-то значения. Нельзя просто так объявить переменную и начать с ней работать внутри цикла. Это может приводить к ошибкам:
 
 ```php
@@ -87,10 +88,12 @@ $sum;
 $sum = $sum + 2; // ?
 ```
 
-В результате такого вызова внутри `$sum` окажется верный результат, но интерпретатор выведет ошибку: `PHP Notice:  Undefined variable: sum`. Она возникает из-за попытки использовать неопределенную переменную. Значит какое-то значение все же нужно. Почему в коде выше выбран 0? Очень легко проверить, что все остальные варианты приведут к неверному результату. Если начальное значение будет равно 1, то результат получится на 1 больше, чем нужно.
+В результате такого вызова внутри `$sum` окажется верный результат, но интерпретатор выведет предупреждение: `PHP Warning:  Undefined variable $sum`. Оно возникает из-за попытки использовать неопределенную переменную. Значит какое-то значение все же нужно. Почему в коде выше выбран 0? Очень легко проверить, что все остальные варианты приведут к неверному результату. Если начальное значение будет равно 1, то результат получится на 1 больше, чем нужно.
 
 В математике у каждой операции существует **нейтральный элемент этой операции**. Операция с этим элементом не изменяет то значение, над которым проводится операция:
 
 * Ноль при сложении: любое число + ноль = само число
 * Ноль при вычитании: любое число - ноль = само число
-* Пустая строка при конкатенации: `''` + `'string'` будет `'string'`
+* Пустая строка при конкатенации: `'' . 'string'` будет `'string'`
+
+Поэтому если бы мы умножали, то вместо `0` использовали бы `1`.
diff --git a/modules/50-loops/20-aggregation-numbers/ru/assets/iterations.png b/modules/50-loops/20-aggregation-numbers/ru/assets/iterations.png
new file mode 100644
index 00000000..c768d5a6
Binary files /dev/null and b/modules/50-loops/20-aggregation-numbers/ru/assets/iterations.png differ
diff --git a/modules/50-loops/23-aggregation-strings/Solution.php b/modules/50-loops/23-aggregation-strings/Solution.php
new file mode 100644
index 00000000..cc7fc605
--- /dev/null
+++ b/modules/50-loops/23-aggregation-strings/Solution.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace HexletBasics\Loops\AggregationStrings;
+
+// BEGIN
+function sanitizePhoneNumber(string $phone): string
+{
+    $i = 0;
+    $result = '';
+
+    while ($i < strlen($phone)) {
+        $char = $phone[$i];
+        if (!str_contains(' ()-', $char)) {
+            $result = $result . $char;
+        }
+        $i = $i + 1;
+    }
+
+    return $result;
+}
+// END
diff --git a/modules/50-loops/23-aggregation-strings/SolutionTest.php b/modules/50-loops/23-aggregation-strings/SolutionTest.php
index 1ad6dc0f..0c2104bb 100644
--- a/modules/50-loops/23-aggregation-strings/SolutionTest.php
+++ b/modules/50-loops/23-aggregation-strings/SolutionTest.php
@@ -1,17 +1,15 @@
 <?php
 
-namespace HexletBasics\Loops\AgregationString;
+namespace HexletBasics\Loops\AggregationStrings;
 
-use PHPUnit\Framework\TestCase;
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        require 'index.php';
-
-        $this->assertEquals('2', joinNumbersFromRange(2, 2));
-        $this->assertEquals('12345', joinNumbersFromRange(1, 5));
-        $this->assertEquals('101112', joinNumbersFromRange(10, 12));
+        $this->assertEquals('+79991234567', sanitizePhoneNumber('+7 (999) 123-45-67'));
+        $this->assertEquals('88005553535', sanitizePhoneNumber('8 800 555 35 35'));
+        $this->assertEquals('1234567890', sanitizePhoneNumber('(123) 456-7890'));
     }
 }
diff --git a/modules/50-loops/23-aggregation-strings/index.php b/modules/50-loops/23-aggregation-strings/index.php
deleted file mode 100644
index c1ce835b..00000000
--- a/modules/50-loops/23-aggregation-strings/index.php
+++ /dev/null
@@ -1,18 +0,0 @@
-<?php
-
-namespace HexletBasics\Loops\AgregationString;
-
-// BEGIN
-function joinNumbersFromRange($start, $end)
-{
-    $i = $start;
-    $result = '';
-
-    while ($i <= $end) {
-        $result = "{$result}{$i}";
-        $i = $i + 1;
-    }
-
-    return $result;
-}
-// END
diff --git a/modules/50-loops/23-aggregation-strings/ru/EXERCISE.md b/modules/50-loops/23-aggregation-strings/ru/EXERCISE.md
index 4075ebd5..540111fb 100644
--- a/modules/50-loops/23-aggregation-strings/ru/EXERCISE.md
+++ b/modules/50-loops/23-aggregation-strings/ru/EXERCISE.md
@@ -1,10 +1,17 @@
+Реализуйте функцию `sanitizePhoneNumber()`, которая принимает номер телефона из формы и возвращает строку без пробелов, скобок и дефисов.
 
-Реализуйте функцию `joinNumbersFromRange()`, которая объединяет все числа из диапазона в строку:
+Пользователи вводят номера по-разному, но перед сохранением их часто приводят к одному виду. Пройдите исходную строку посимвольно и соберите новый номер только из полезных символов.
 
 ```php
 <?php
 
-joinNumbersFromRange(1, 1); // '1'
-joinNumbersFromRange(2, 3); // '23'
-joinNumbersFromRange(5, 10); // '5678910'
+sanitizePhoneNumber('+7 (999) 123-45-67'); // '+79991234567'
+sanitizePhoneNumber('8 800 555 35 35');    // '88005553535'
+sanitizePhoneNumber('(123) 456-7890');     // '1234567890'
 ```
+
+### Подсказки
+
+* Итоговый результат — строка.
+* Используйте пустую строку как начальное значение.
+* Проверить, входит ли символ в набор `' ()-'`, поможет функция `str_contains()`.
diff --git a/modules/50-loops/23-aggregation-strings/ru/README.md b/modules/50-loops/23-aggregation-strings/ru/README.md
index 1ea6a3cb..0ae2d808 100644
--- a/modules/50-loops/23-aggregation-strings/ru/README.md
+++ b/modules/50-loops/23-aggregation-strings/ru/README.md
@@ -13,7 +13,7 @@ repeat('hexlet', 3); // 'hexlethexlethexlet'
 ```php
 <?php
 
-function repeat($text, $times)
+function repeat(string $text, int $times): string
 {
     // Нейтральный элемент для строк – пустая строка
     $result = '';
@@ -40,3 +40,29 @@ $result = "{$result}hexlet"; // hexlet
 $result = "{$result}hexlet"; // hexlethexlet
 $result = "{$result}hexlet"; // hexlethexlethexlet
 ```
+
+Наглядно процесс наращивания строки выглядит так:
+
+```text
+repeat('hexlet', 3):
+
+i=1: result = ''             . 'hexlet' = 'hexlet'
+i=2: result = 'hexlet'       . 'hexlet' = 'hexlethexlet'
+i=3: result = 'hexlethexlet' . 'hexlet' = 'hexlethexlethexlet'
+                                            └── результат
+```
+
+## Нейтральный элемент
+
+Чтобы наращивание работало, нужно стартовое значение. Для строк таким значением является **пустая строка** `''`.
+
+Она называется нейтральным элементом, потому что при конкатенации ничего не меняет:
+
+```php
+<?php
+
+print_r('' . 'abc');  // => abc
+print_r('abc' . '');  // => abc
+```
+
+Поэтому именно пустая строка всегда используется как начальное значение при агрегации строк.
diff --git a/modules/50-loops/25-iteration-over-string/Solution.php b/modules/50-loops/25-iteration-over-string/Solution.php
new file mode 100644
index 00000000..512aa008
--- /dev/null
+++ b/modules/50-loops/25-iteration-over-string/Solution.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace HexletBasics\Loops\IterationOverString;
+
+// BEGIN
+function maskCardNumber(string $cardNumber): string
+{
+    $result = '';
+    $i = 0;
+    $visiblePartStart = strlen($cardNumber) - 4;
+
+    while ($i < strlen($cardNumber)) {
+        if ($i < $visiblePartStart) {
+            $result = $result . '*';
+        } else {
+            $result = $result . $cardNumber[$i];
+        }
+        $i = $i + 1;
+    }
+
+    return $result;
+}
+// END
diff --git a/modules/50-loops/25-iteration-over-string/SolutionTest.php b/modules/50-loops/25-iteration-over-string/SolutionTest.php
index f419d456..7263df22 100644
--- a/modules/50-loops/25-iteration-over-string/SolutionTest.php
+++ b/modules/50-loops/25-iteration-over-string/SolutionTest.php
@@ -2,17 +2,14 @@
 
 namespace HexletBasics\Loops\IterationOverString;
 
-use PHPUnit\Framework\TestCase;
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        require 'index.php';
-
-        $str = 'Hexlet';
-        $expected = "t\ne\nl\nx\ne\nH\n";
-        $this->expectOutputString($expected);
-        printReversedWordBySymbol($str);
+        $this->assertEquals('************5678', maskCardNumber('1234567812345678'));
+        $this->assertEquals('****5678', maskCardNumber('12345678'));
+        $this->assertEquals('************3333', maskCardNumber('0000111122223333'));
     }
 }
diff --git a/modules/50-loops/25-iteration-over-string/index.php b/modules/50-loops/25-iteration-over-string/index.php
deleted file mode 100644
index 13bd7ef1..00000000
--- a/modules/50-loops/25-iteration-over-string/index.php
+++ /dev/null
@@ -1,14 +0,0 @@
-<?php
-
-namespace HexletBasics\Loops\IterationOverString;
-
-// BEGIN
-function printReversedWordBySymbol($word)
-{
-    $i = strlen($word) - 1;
-    while ($i >= 0) {
-        print_r("$word[$i]\n");
-        $i = $i - 1;
-    }
-}
-// END
diff --git a/modules/50-loops/25-iteration-over-string/ru/EXERCISE.md b/modules/50-loops/25-iteration-over-string/ru/EXERCISE.md
index 3bdf7ffd..52c06d5e 100644
--- a/modules/50-loops/25-iteration-over-string/ru/EXERCISE.md
+++ b/modules/50-loops/25-iteration-over-string/ru/EXERCISE.md
@@ -1,16 +1,10 @@
+Напишите функцию `maskCardNumber()`, которая скрывает номер банковской карты. Функция должна заменить все символы строки на `*`, кроме последних четырех.
 
-Реализуйте функцию `printReversedWordBySymbol()`, которая печатает переданное слово посимвольно, как в примере из теории, но делает это в обратном порядке.
+Пример работы:
 
 ```php
 <?php
 
-$word = 'Hexlet';
-
-printReversedWordBySymbol($word);
-// => 't'
-// => 'e'
-// => 'l'
-// => 'x'
-// => 'e'
-// => 'H'
+maskCardNumber('1234567812345678'); // '************5678'
+maskCardNumber('12345678');         // '****5678'
 ```
diff --git a/modules/50-loops/25-iteration-over-string/ru/README.md b/modules/50-loops/25-iteration-over-string/ru/README.md
index 40e5237c..cd207491 100644
--- a/modules/50-loops/25-iteration-over-string/ru/README.md
+++ b/modules/50-loops/25-iteration-over-string/ru/README.md
@@ -3,7 +3,7 @@
 ```php
 <?php
 
-function printNameBySymbol($name)
+function printNameBySymbol(string $name): void
 {
     $i = 0;
     // Такая проверка будет выполняться до конца строки,
@@ -24,6 +24,15 @@ printNameBySymbol($name);
 // => 'a'
 ```
 
+Цикл проходит по каждому символу строки по очереди:
+
+```text
+'Arya'
+ │ │ │ │
+ A r y a
+ ↓ ↓ ↓ ↓
+каждый символ обрабатывается по очереди
+```
 
 Самое главное в этом коде — поставить правильное условие в `while`. Это можно сделать сразу двумя способами:
 
@@ -31,3 +40,29 @@ printNameBySymbol($name);
 * `$i <= strlen($name) - 1`
 
 Оба способа приводят к одному результату.
+
+## Переворот строки
+
+Вместо печати можно собирать новую строку. Например, напишем функцию, которая переворачивает строку:
+
+```php
+<?php
+
+function reverseString(string $text): string
+{
+    $result = '';
+    $i = strlen($text) - 1;
+
+    while ($i >= 0) {
+        $result = $result . $text[$i];
+        $i = $i - 1;
+    }
+
+    return $result;
+}
+
+print_r(reverseString('Arya') . "\n");   // => ayrA
+print_r(reverseString('hexlet') . "\n"); // => telxeh
+```
+
+Переменная `$result` инициализируется пустой строкой как нейтральным элементом для конкатенации. Цикл начинается с последнего индекса (`strlen($text) - 1`), двигается к нулю и завершается, когда индекс становится меньше нуля. На каждом шаге к результату добавляется текущий символ. В итоге строка строится в обратном порядке.
diff --git a/modules/50-loops/26-conditions-inside-loops/SolutionTest.php b/modules/50-loops/26-conditions-inside-loops/SolutionTest.php
deleted file mode 100644
index 8acb9898..00000000
--- a/modules/50-loops/26-conditions-inside-loops/SolutionTest.php
+++ /dev/null
@@ -1,18 +0,0 @@
-<?php
-
-namespace HexletBasics\Loops\ConditionsInsideLoops;
-
-use PHPUnit\Framework\TestCase;
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        require 'index.php';
-
-        $this->assertEquals(1, countChars('axe', 'a'));
-        $this->assertEquals(0, countChars('', 'a'));
-        $this->assertEquals(2, countChars('OpPa', 'p'));
-        $this->assertEquals(2, countChars('OpPa', 'P'));
-    }
-}
diff --git a/modules/50-loops/26-conditions-inside-loops/ru/EXERCISE.md b/modules/50-loops/26-conditions-inside-loops/ru/EXERCISE.md
deleted file mode 100644
index c156af1d..00000000
--- a/modules/50-loops/26-conditions-inside-loops/ru/EXERCISE.md
+++ /dev/null
@@ -1,9 +0,0 @@
-
-Функция из теории учитывает регистр букв. То есть `A` и `a` с её точки зрения разные символы. Реализуйте вариант этой же функции, так чтобы регистр букв был не важен:
-
-```php
-<?php
-
-countChars('HexlEt', 'e'); // 2
-countChars('HexlEt', 'E'); // 2
-```
diff --git a/modules/50-loops/26-conditions-inside-loops/ru/README.md b/modules/50-loops/26-conditions-inside-loops/ru/README.md
deleted file mode 100644
index 47c7af57..00000000
--- a/modules/50-loops/26-conditions-inside-loops/ru/README.md
+++ /dev/null
@@ -1,43 +0,0 @@
-
-Тело цикла, как и тело функции — это место выполнения инструкций. Значит, мы можем использовать внутри него всё изученное ранее, например — условные конструкции.
-
-Представьте себе функцию, которая считает сколько раз входит буква в предложение. Пример её работы:
-
-```php
-<?php
-
-countChars('Fear cuts deeper than swords.', 'e'); // 4
-// Если вы ничего не нашли, то результат — 0 совпадений
-countChars('Sansa', 'y'); // 0
-```
-
-Перед тем как посмотреть её содержимое, попробуйте ответить на вопросы:
-
-* Является ли эта операция агрегацией?
-* Какой будет проверка на вхождение символа?
-
-```php
-<?php
-
-function countChars($str, $char)
-{
-    $i = 0;
-    $count = 0;
-    while ($i < strlen($str)) {
-        if ($str[$i] === $char) {
-            // Считаем только подходящие символы
-            $count = $count + 1;
-        }
-        // Счетчик увеличивается в любом случае
-        $i = $i + 1;
-    }
-
-    return $count;
-}
-```
-
-Эта задача является агрегирующей. Несмотря на то, что она считает не все символы, для подсчёта самой суммы всё равно приходится анализировать каждый символ.
-
-Ключевое отличие этого цикла от рассмотренных в наличии условия внутри тела. Переменная `$count` увеличивается только в том случае, когда текущий рассматриваемый символ совпадает с ожидаемым.
-
-В остальном — это типичная агрегатная функция, которая возвращает количество нужных символов вызываемому коду.
diff --git a/modules/50-loops/28-build-strings/SolutionTest.php b/modules/50-loops/28-build-strings/SolutionTest.php
deleted file mode 100644
index 49a565da..00000000
--- a/modules/50-loops/28-build-strings/SolutionTest.php
+++ /dev/null
@@ -1,17 +0,0 @@
-<?php
-
-namespace HexletBasics\Loops\ReverseString;
-
-use PHPUnit\Framework\TestCase;
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        require 'index.php';
-
-        $this->assertEquals('got', mysubstr('got', 3));
-        $this->assertEquals('go', mysubstr('got', 2));
-        $this->assertEquals('g', mysubstr('got', 1));
-    }
-}
diff --git a/modules/50-loops/28-build-strings/description.es.yml b/modules/50-loops/28-build-strings/description.es.yml
deleted file mode 100644
index 6db91722..00000000
--- a/modules/50-loops/28-build-strings/description.es.yml
+++ /dev/null
@@ -1,65 +0,0 @@
----
-
-name: Formación de cadenas en bucles
-theory: |
-  Otro uso de los bucles es la formación de cadenas. Este tipo de tarea es común en la programación web. Se reduce a una simple agregación utilizando interpolación o concatenación.
-
-  Hay una tarea muy popular en las entrevistas: **invertir una cadena**. Se puede resolver de muchas formas diferentes, pero el enfoque más básico es recorrerla carácter por carácter.
-
-  Veamos un ejemplo de cómo funciona esta función:
-
-  ```php
-  <?php
-
-  reverse('Hexlet'); // telxeH
-  ```
-
-  La idea general de la inversión es tomar los caracteres uno por uno desde el principio de la cadena y unirlos en orden inverso. Suena bastante simple. Veamos:
-
-  ```php
-  <?php
-
-  function reverse($str)
-  {
-      $i = 0;
-      // El elemento neutral para las cadenas es una cadena vacía
-      $result = '';
-
-      while ($i < strlen($str)) {
-          $currentChar = $str[$i];
-          // Unir en orden inverso
-          $result = "{$currentChar}{$result}";
-          // Lo mismo utilizando concatenación
-          // $result = $currentChar . $result;
-          $i = $i + 1;
-      }
-
-      return $result;
-  }
-
-  $name = 'Bran';
-  reverse($name); // 'narB'
-  // Comprobación del elemento neutral
-  reverse(''); // ''
-  ```
-
-
-  El único aspecto complicado de este código es comprender cómo se construye la cadena. Dado que cada carácter siguiente se adjunta a la cadena resultante desde la izquierda, al final la cadena queda invertida.
-
-instructions: |
-  Implementa la función `mysubstr()`, que extrae una subcadena de una cadena dada con una longitud especificada. Recibe dos argumentos (la cadena y la longitud) y devuelve la subcadena comenzando desde el primer carácter:
-
-  Ejemplo de uso:
-
-  ```php
-  <?php
-
-  $str = 'If I look back I am lost';
-  mysubstr($str, 1); // 'I'
-  mysubstr($str, 7); // 'If I lo'
-  ```
-
-
-  Utiliza el mismo enfoque que en la función de inversión de cadenas del tutorial: construye la cadena resultante en un bucle, recorriendo la cadena original hasta un punto determinado.
-
-tips: []
diff --git a/modules/50-loops/28-build-strings/en/EXERCISE.md b/modules/50-loops/28-build-strings/en/EXERCISE.md
deleted file mode 100644
index 4c5f9f2b..00000000
--- a/modules/50-loops/28-build-strings/en/EXERCISE.md
+++ /dev/null
@@ -1,15 +0,0 @@
-
-Implement the `mysubstr()` function, which extracts a substring of a specified length from a string. It takes two arguments (string and length) and returns a substring starting from the first character:
-
-Call example:
-
-```php
-<?php
-
-$str = 'If I look back I am lost';
-mysubstr($str, 1); // 'I'
-mysubstr($str, 7); // 'If I lo'
-```
-
-
-Use the same approach as you did for the function to flip the string from the lesson: assemble the resulting string in a loop by looping through the initial string up to a certain point.
diff --git a/modules/50-loops/28-build-strings/en/README.md b/modules/50-loops/28-build-strings/en/README.md
deleted file mode 100644
index 64083db7..00000000
--- a/modules/50-loops/28-build-strings/en/README.md
+++ /dev/null
@@ -1,42 +0,0 @@
-
-Loops also allow you to generate strings. This is a common task for web development. It's merely basic aggregation using interpolation or concatenation.
-
-One especially popular task among interviewers is to do a string reversal. There are lots of ways to solve it, but the most basic is by iterating each character. Have a look at how this function works:
-
-```php
-<?php
-
-reverse('Hexlet'); // telxeH
-```
-
-The general idea of a string reversal is that you take characters one by one from the beginning of the string and then connect them together in reverse order. Sounds like a piece of cake. Now let's examine it:
-
-```php
-<?php
-
-function reverse($str)
-{
-    $i = 0;
-    // A neutral element in terms of strings is an empty string
-    $result = '';
-
-    while ($i < strlen($str)) {
-        $currentChar = $str[$i];
-        // Join it together it in reverse order
-        $result = "{$currentChar}{$result}";
-        // The same through concatenation
-        // $result = $currentChar . $result;
-        $i = $i + 1;
-    }
-
-    return $result;
-}
-
-$name = 'Bran';
-reverse($name); // 'narB'
-// Neutral element check
-reverse(''); // ''
-```
-
-
-Perhaps the only tricky part here is getting a feel of how the string itself is built. Since each next character is attached to the resulting string on the left, the string ends up reversed.
diff --git a/modules/50-loops/28-build-strings/en/data.yml b/modules/50-loops/28-build-strings/en/data.yml
deleted file mode 100644
index 20213b1e..00000000
--- a/modules/50-loops/28-build-strings/en/data.yml
+++ /dev/null
@@ -1,2 +0,0 @@
----
-name: Forming strings with loops
diff --git a/modules/50-loops/28-build-strings/es/EXERCISE.md b/modules/50-loops/28-build-strings/es/EXERCISE.md
deleted file mode 100644
index 396d90c8..00000000
--- a/modules/50-loops/28-build-strings/es/EXERCISE.md
+++ /dev/null
@@ -1,14 +0,0 @@
-Implementa la función `mysubstr()`, que extrae una subcadena de una cadena dada con una longitud especificada. Recibe dos argumentos (la cadena y la longitud) y devuelve la subcadena comenzando desde el primer carácter:
-
-Ejemplo de uso:
-
-```php
-<?php
-
-$str = 'If I look back I am lost';
-mysubstr($str, 1); // 'I'
-mysubstr($str, 7); // 'If I lo'
-```
-
-
-Utiliza el mismo enfoque que en la función de inversión de cadenas del tutorial: construye la cadena resultante en un bucle, recorriendo la cadena original hasta un punto determinado.
diff --git a/modules/50-loops/28-build-strings/es/README.md b/modules/50-loops/28-build-strings/es/README.md
deleted file mode 100644
index ba4408ad..00000000
--- a/modules/50-loops/28-build-strings/es/README.md
+++ /dev/null
@@ -1,43 +0,0 @@
-Otro uso de los bucles es la formación de cadenas. Este tipo de tarea es común en la programación web. Se reduce a una simple agregación utilizando interpolación o concatenación.
-
-Hay una tarea muy popular en las entrevistas: **invertir una cadena**. Se puede resolver de muchas formas diferentes, pero el enfoque más básico es recorrerla carácter por carácter.
-
-Veamos un ejemplo de cómo funciona esta función:
-
-```php
-<?php
-
-reverse('Hexlet'); // telxeH
-```
-
-La idea general de la inversión es tomar los caracteres uno por uno desde el principio de la cadena y unirlos en orden inverso. Suena bastante simple. Veamos:
-
-```php
-<?php
-
-function reverse($str)
-{
-    $i = 0;
-    // El elemento neutral para las cadenas es una cadena vacía
-    $result = '';
-
-    while ($i < strlen($str)) {
-        $currentChar = $str[$i];
-        // Unir en orden inverso
-        $result = "{$currentChar}{$result}";
-        // Lo mismo utilizando concatenación
-        // $result = $currentChar . $result;
-        $i = $i + 1;
-    }
-
-    return $result;
-}
-
-$name = 'Bran';
-reverse($name); // 'narB'
-// Comprobación del elemento neutral
-reverse(''); // ''
-```
-
-
-El único aspecto complicado de este código es comprender cómo se construye la cadena. Dado que cada carácter siguiente se adjunta a la cadena resultante desde la izquierda, al final la cadena queda invertida.
diff --git a/modules/50-loops/28-build-strings/es/data.yml b/modules/50-loops/28-build-strings/es/data.yml
deleted file mode 100644
index cd8e469f..00000000
--- a/modules/50-loops/28-build-strings/es/data.yml
+++ /dev/null
@@ -1,3 +0,0 @@
----
-name: Formación de cadenas en bucles
-tips: []
diff --git a/modules/50-loops/28-build-strings/index.php b/modules/50-loops/28-build-strings/index.php
deleted file mode 100644
index 12dba68e..00000000
--- a/modules/50-loops/28-build-strings/index.php
+++ /dev/null
@@ -1,18 +0,0 @@
-<?php
-
-namespace HexletBasics\Loops\ReverseString;
-
-// BEGIN
-function mysubstr($str, $length)
-{
-    $index = 0;
-    $result = '';
-    while ($index < $length) {
-        $currentChar = $str[$index];
-        $result = "{$result}{$currentChar}";
-        $index = $index + 1;
-    }
-
-    return $result;
-}
-// END
diff --git a/modules/50-loops/28-build-strings/ru/EXERCISE.md b/modules/50-loops/28-build-strings/ru/EXERCISE.md
deleted file mode 100644
index d546ae06..00000000
--- a/modules/50-loops/28-build-strings/ru/EXERCISE.md
+++ /dev/null
@@ -1,13 +0,0 @@
-Реализуйте функцию `mysubstr()`, которая извлекает из строки подстроку указанной длины. Она принимает на вход два аргумента (строку и длину) и возвращает подстроку начиная с первого символа:
-
-Пример вызова:
-
-```php
-<?php
-
-$str = 'If I look back I am lost';
-mysubstr($str, 1); // 'I'
-mysubstr($str, 7); // 'If I lo'
-```
-
-Используйте тот же подход, что в функции для переворота строки из урока: собирайте строку-результат в цикле, перебирая начальную строку до определенного момента.
diff --git a/modules/50-loops/28-build-strings/ru/README.md b/modules/50-loops/28-build-strings/ru/README.md
deleted file mode 100644
index 08e36b82..00000000
--- a/modules/50-loops/28-build-strings/ru/README.md
+++ /dev/null
@@ -1,42 +0,0 @@
-Еще одно использование циклов – формирование строк. Подобная задача нередко встречается в веб-программировании. Она сводится к обычной агрегации с применением интерполяции или конкатенации.
-
-Есть одна задача, крайне популярная на собеседованиях — это **переворот строки**. Ее можно решить множеством разных способов, но именно посимвольный перебор считается базовым.
-
-Рассмотрим пример работы этой функции:
-
-```php
-<?php
-
-reverse('Hexlet'); // telxeH
-```
-
-Общая идея переворота состоит в следующем — нужно брать символы по очереди с начала строки и соединять их в обратном порядке. Звучит довольно просто. Давайте проверим:
-
-```php
-<?php
-
-function reverse($str)
-{
-    $i = 0;
-    // Нейтральный элемент для строк — это пустая строка
-    $result = '';
-
-    while ($i < strlen($str)) {
-        $currentChar = $str[$i];
-        // Соединяем в обратном порядке
-        $result = "{$currentChar}{$result}";
-        // Тоже самое через конкатенацию
-        // $result = $currentChar . $result;
-        $i = $i + 1;
-    }
-
-    return $result;
-}
-
-$name = 'Bran';
-reverse($name); // 'narB'
-// Проверка нейтрального элемента
-reverse(''); // ''
-```
-
-Единственный сложный момент в этом коде – прочувствовать, как собирается сама строка. Так как каждый следующий символ прикрепляется к результирующей строке слева, то, в конечном итоге, строка оказывается перевернута.
diff --git a/modules/50-loops/28-build-strings/ru/data.yml b/modules/50-loops/28-build-strings/ru/data.yml
deleted file mode 100644
index db622ea0..00000000
--- a/modules/50-loops/28-build-strings/ru/data.yml
+++ /dev/null
@@ -1,3 +0,0 @@
----
-name: Формирование строк в циклах
-tips: []
diff --git a/modules/50-loops/29-edge-cases/SolutionTest.php b/modules/50-loops/29-edge-cases/SolutionTest.php
deleted file mode 100644
index 066349af..00000000
--- a/modules/50-loops/29-edge-cases/SolutionTest.php
+++ /dev/null
@@ -1,23 +0,0 @@
-<?php
-
-namespace HexletBasics\Loops\EdgeCases;
-
-use PHPUnit\Framework\TestCase;
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        require 'index.php';
-
-        $str = 'Sansa Stark';
-
-        $this->assertFalse(isArgumentsForSubstrCorrect($str, -1, 3), );
-        $this->assertFalse(isArgumentsForSubstrCorrect($str, 4, 100), );
-        $this->assertFalse(isArgumentsForSubstrCorrect($str, 10, 10), );
-        $this->assertFalse(isArgumentsForSubstrCorrect($str, 11, 1), );
-        $this->assertFalse(isArgumentsForSubstrCorrect($str, 11, 0), );
-        $this->assertTrue(isArgumentsForSubstrCorrect($str, 3, 3));
-        $this->assertTrue(isArgumentsForSubstrCorrect($str, 10, 1));
-    }
-}
diff --git a/modules/50-loops/29-edge-cases/description.es.yml b/modules/50-loops/29-edge-cases/description.es.yml
deleted file mode 100644
index 5348c233..00000000
--- a/modules/50-loops/29-edge-cases/description.es.yml
+++ /dev/null
@@ -1,110 +0,0 @@
----
-
-name: Casos límite
-theory: |
-  En esta lección implementaremos la función `mysubstr()`, que extrae una subcadena de una cadena de longitud especificada.
-
-  Recibe dos argumentos:
-
-  * La cadena
-  * La longitud
-
-  Esta función devuelve la subcadena comenzando desde el primer carácter:
-
-  ```php
-  <?php
-
-  function mysubstr($str, $length)
-  {
-      $index = 0;
-      $result = '';
-      while ($index < $length) {
-          $currentChar = $str[$index];
-          $result = "{$result}{$currentChar}";
-          $index = $index + 1;
-      }
-
-      return $result;
-  }
-
-  $str = 'Si miro hacia atrás, estoy perdido';
-
-  mysubstr($str, 1); // 'i'
-  mysubstr($str, 7); // 'Si miro'
-  ```
-
-
-  Parece que todo está bien. Pero nuestra función contiene muchos errores porque no tiene en cuenta los llamados **casos límite**. La función funciona correctamente solo con argumentos normales. Pero no sabemos cómo se comportará si le pasamos estas longitudes:
-
-  * `0`
-  * Un número negativo
-  * Un número que excede la longitud real de la cadena
-
-  La función `mysubstr()` no está diseñada para manejar estos casos. Podríamos pensar que no es un problema: la función funciona en condiciones normales y simplemente no debemos pasarle "argumentos incorrectos".
-
-  En un mundo ideal, sí, pero en el mundo real, tu código se ejecutará en diferentes situaciones, con diferentes combinaciones de condiciones y datos. No se puede estar seguro de que los argumentos siempre serán correctos, por lo que debemos tener en cuenta todos los casos, dentro de los límites de la lógica.
-
-  Los casos límite son la causa más común de errores lógicos en los programas. Los programadores a menudo olvidan tener en cuenta algo. Estos errores a menudo no se manifiestan de inmediato y pueden no causar problemas visibles durante mucho tiempo. El programa sigue funcionando, pero en algún momento se descubre que hay errores en los resultados.
-
-  A menudo, la causa radica en la débil tipificación de PHP. La capacidad para manejar este tipo de errores viene con la experiencia, a través de problemas constantes del tipo "¡Ups, olvidé verificar si la cadena está vacía!".
-
-  Imaginemos una función extendida `mysubstr()`. Recibe tres argumentos:
-
-  * La cadena
-  * El índice
-  * La longitud de la subcadena a extraer
-
-  Veamos ejemplos de llamadas:
-
-  ```php
-  <?php
-
-  $str = 'Si miro hacia atrás, estoy perdido';
-  mysubstr($str, 0, 1); // 'i'
-  mysubstr($str, 3, 6); // 'i miro'
-  ```
-
-  Discutamos qué podría salir mal. ¿Qué casos límite debemos tener en cuenta?
-
-  * Longitud negativa de la subcadena a extraer
-  * Índice negativo especificado
-  * El índice especificado está fuera de los límites de toda la cadena
-  * La longitud de la subcadena, sumada al índice especificado, está fuera de los límites de toda la cadena
-
-  En la implementación de la función, cada caso límite será un fragmento de código separado, probablemente implementado con `if`.
-
-  Para escribir la función `mysubstr()` y protegernos de estos casos, debemos escribir una función separada que verifique la corrección de los argumentos. Abordaremos esto en la tarea de esta lección.
-
-instructions: |
-  Implementa la función predicado `isArgumentsForSubstrCorrect`, que recibe tres argumentos:
-
-  1. La cadena
-  2. El índice desde el cual comenzar la extracción
-  3. La longitud de la subcadena a extraer
-
-  La función devuelve `false` si se cumple al menos una de las siguientes condiciones:
-
-  * Longitud negativa de la subcadena a extraer
-  * Índice negativo especificado
-  * El índice especificado está fuera de los límites de toda la cadena
-  * La longitud de la subcadena, sumada al índice especificado, está fuera de los límites de toda la cadena
-
-  De lo contrario, la función devuelve `true`.
-
-  No olvides que los índices comienzan en `0`, por lo que el índice del último elemento es "longitud de la cadena menos 1".
-
-  Ejemplo de llamada:
-
-  ```php
-  <?php
-
-  $str = 'Sansa Stark';
-  isArgumentsForSubstrCorrect($str, -1, 3);  // false
-  isArgumentsForSubstrCorrect($str, 4, 100); // false
-  isArgumentsForSubstrCorrect($str, 10, 10); // false
-  isArgumentsForSubstrCorrect($str, 11, 1);  // false
-  isArgumentsForSubstrCorrect($str, 3, 3);   // true
-  isArgumentsForSubstrCorrect($str, 0, 5);   // true
-  ```
-
-tips: []
diff --git a/modules/50-loops/29-edge-cases/en/EXERCISE.md b/modules/50-loops/29-edge-cases/en/EXERCISE.md
deleted file mode 100644
index 7df3e66d..00000000
--- a/modules/50-loops/29-edge-cases/en/EXERCISE.md
+++ /dev/null
@@ -1,31 +0,0 @@
-
-Implement an `isArgumentsForSubstrCorrect` predicate function that takes three arguments:
-
-1. the string
-2. the index from which to begin the extraction
-3. the length of the substring to be extracted
-
-The function returns `false` if at least one of the conditions is true:
-
-* The substring extracted has a negative length
-* The index set is negative
-* The index set exceeds the boundary of the whole string
-* The length of the substring plus the given index exceeds the boundary of the whole string
-
-Otherwise the function returns `true`.
-
-Don't forget that indexes start with `0`, so the index of the last element is "string length minus 1".
-
-Call example:
-
-```php
-<?php
-
-$str = 'Sansa Stark';
-isArgumentsForSubstrCorrect($str, -1, 3);  // false
-isArgumentsForSubstrCorrect($str, 4, 100); // false
-isArgumentsForSubstrCorrect($str, 10, 10); // false
-isArgumentsForSubstrCorrect($str, 11, 1);  // false
-isArgumentsForSubstrCorrect($str, 3, 3);   // true
-isArgumentsForSubstrCorrect($str, 0, 5);   // true
-```
diff --git a/modules/50-loops/29-edge-cases/en/README.md b/modules/50-loops/29-edge-cases/en/README.md
deleted file mode 100644
index 8634809e..00000000
--- a/modules/50-loops/29-edge-cases/en/README.md
+++ /dev/null
@@ -1,35 +0,0 @@
-
-The `mysubstr()`, function you implemented in the last lesson contains many errors. "But it passed the tests!" Yes, but there were no **edge cases** in these checks. The function worked fine with normal arguments, but how would it behave if you gave it these length options?
-
-* `0`
-* A negative number
-* A number larger than the actual string size
-
-The `mysubstr()` function isn't designed for this. You might think that this isn't a problem: the function works under normal conditions, and you simply need to not pass "bad" arguments to it. In a perfect world, yes, but in the real world your code might run in different situations, with different combinations of conditions and data. You can't be sure that arguments will always be correct, so you have to consider all cases, within the bounds of common sense.
-
-Boundary errors are the most common cause of logical errors in programs. There's always something that programmers forget to take into account. These errors often don't manifest themselves immediately, and may not lead to visible problems for a long time. The program may continue to work, but at some point someone might notice an error in the results. Often, the reason is PHP's weak typing.
-
-The ability to deal with such errors comes with experience, through constant "oops, forgot to check for an empty string!"-type screw-ups.
-
----
-
-Let's imagine an extended version of the `mysubstr()` function. It takes three arguments; a string, an index, and the length of the substring to be extracted. The function returns a substring of the specified length starting from the specified index. Call examples:
-
-```php
-<?php
-
-$str = 'If I look back I am lost';
-mysubstr($str, 0, 1); // 'I'
-mysubstr($str, 3, 6); // 'I look'
-```
-
-Let's figure out what could go wrong. What edge cases are worth considering:
-
-* The substring extracted has a negative length
-* The index set is negative
-* The index set exceeds the boundary of the whole string
-* The length of the substring plus the given index exceeds the boundary of the whole string
-
-When the function is implemented, each edge case will be a separate piece of code, most likely implemented with an `if`.
-
-If you want to write a `mysubstr()` function that's protected against these cases, it's worth writing a separate function that will check the arguments for correctness. We'll get to that in the assignment.
diff --git a/modules/50-loops/29-edge-cases/en/data.yml b/modules/50-loops/29-edge-cases/en/data.yml
deleted file mode 100644
index a2e3e7ad..00000000
--- a/modules/50-loops/29-edge-cases/en/data.yml
+++ /dev/null
@@ -1,2 +0,0 @@
----
-name: Edge cases
diff --git a/modules/50-loops/29-edge-cases/es/EXERCISE.md b/modules/50-loops/29-edge-cases/es/EXERCISE.md
deleted file mode 100644
index cc8078e4..00000000
--- a/modules/50-loops/29-edge-cases/es/EXERCISE.md
+++ /dev/null
@@ -1,30 +0,0 @@
-Implementa la función predicado `isArgumentsForSubstrCorrect`, que recibe tres argumentos:
-
-1. La cadena
-2. El índice desde el cual comenzar la extracción
-3. La longitud de la subcadena a extraer
-
-La función devuelve `false` si se cumple al menos una de las siguientes condiciones:
-
-* Longitud negativa de la subcadena a extraer
-* Índice negativo especificado
-* El índice especificado está fuera de los límites de toda la cadena
-* La longitud de la subcadena, sumada al índice especificado, está fuera de los límites de toda la cadena
-
-De lo contrario, la función devuelve `true`.
-
-No olvides que los índices comienzan en `0`, por lo que el índice del último elemento es "longitud de la cadena menos 1".
-
-Ejemplo de llamada:
-
-```php
-<?php
-
-$str = 'Sansa Stark';
-isArgumentsForSubstrCorrect($str, -1, 3);  // false
-isArgumentsForSubstrCorrect($str, 4, 100); // false
-isArgumentsForSubstrCorrect($str, 10, 10); // false
-isArgumentsForSubstrCorrect($str, 11, 1);  // false
-isArgumentsForSubstrCorrect($str, 3, 3);   // true
-isArgumentsForSubstrCorrect($str, 0, 5);   // true
-```
diff --git a/modules/50-loops/29-edge-cases/es/README.md b/modules/50-loops/29-edge-cases/es/README.md
deleted file mode 100644
index 20cbacf4..00000000
--- a/modules/50-loops/29-edge-cases/es/README.md
+++ /dev/null
@@ -1,72 +0,0 @@
-En esta lección implementaremos la función `mysubstr()`, que extrae una subcadena de una cadena de longitud especificada.
-
-Recibe dos argumentos:
-
-* La cadena
-* La longitud
-
-Esta función devuelve la subcadena comenzando desde el primer carácter:
-
-```php
-<?php
-
-function mysubstr($str, $length)
-{
-    $index = 0;
-    $result = '';
-    while ($index < $length) {
-        $currentChar = $str[$index];
-        $result = "{$result}{$currentChar}";
-        $index = $index + 1;
-    }
-
-    return $result;
-}
-
-$str = 'Si miro hacia atrás, estoy perdido';
-
-mysubstr($str, 1); // 'i'
-mysubstr($str, 7); // 'Si miro'
-```
-
-
-Parece que todo está bien. Pero nuestra función contiene muchos errores porque no tiene en cuenta los llamados **casos límite**. La función funciona correctamente solo con argumentos normales. Pero no sabemos cómo se comportará si le pasamos estas longitudes:
-
-* `0`
-* Un número negativo
-* Un número que excede la longitud real de la cadena
-
-La función `mysubstr()` no está diseñada para manejar estos casos. Podríamos pensar que no es un problema: la función funciona en condiciones normales y simplemente no debemos pasarle "argumentos incorrectos".
-
-En un mundo ideal, sí, pero en el mundo real, tu código se ejecutará en diferentes situaciones, con diferentes combinaciones de condiciones y datos. No se puede estar seguro de que los argumentos siempre serán correctos, por lo que debemos tener en cuenta todos los casos, dentro de los límites de la lógica.
-
-Los casos límite son la causa más común de errores lógicos en los programas. Los programadores a menudo olvidan tener en cuenta algo. Estos errores a menudo no se manifiestan de inmediato y pueden no causar problemas visibles durante mucho tiempo. El programa sigue funcionando, pero en algún momento se descubre que hay errores en los resultados.
-
-A menudo, la causa radica en la débil tipificación de PHP. La capacidad para manejar este tipo de errores viene con la experiencia, a través de problemas constantes del tipo "¡Ups, olvidé verificar si la cadena está vacía!".
-
-Imaginemos una función extendida `mysubstr()`. Recibe tres argumentos:
-
-* La cadena
-* El índice
-* La longitud de la subcadena a extraer
-
-Veamos ejemplos de llamadas:
-
-```php
-<?php
-
-$str = 'Si miro hacia atrás, estoy perdido';
-mysubstr($str, 0, 1); // 'i'
-mysubstr($str, 3, 6); // 'i miro'
-```
-
-Discutamos qué podría salir mal. ¿Qué casos límite debemos tener en cuenta?
-
-* Longitud negativa de la subcadena a extraer
-* Índice negativo especificado
-* El índice especificado está fuera de los límites de toda la cadena
-* La longitud de la subcadena, sumada al índice especificado, está fuera de los límites de toda la cadena
-
-En la implementación de la función, cada caso límite será un fragmento de código separado, probablemente implementado con `if`.
-
-Para escribir la función `mysubstr()` y protegernos de estos casos, debemos escribir una función separada que verifique la corrección de los argumentos. Abordaremos esto en la tarea de esta lección.
diff --git a/modules/50-loops/29-edge-cases/es/data.yml b/modules/50-loops/29-edge-cases/es/data.yml
deleted file mode 100644
index aa7eaeed..00000000
--- a/modules/50-loops/29-edge-cases/es/data.yml
+++ /dev/null
@@ -1,3 +0,0 @@
----
-name: Casos límite
-tips: []
diff --git a/modules/50-loops/29-edge-cases/index.php b/modules/50-loops/29-edge-cases/index.php
deleted file mode 100644
index 2e597535..00000000
--- a/modules/50-loops/29-edge-cases/index.php
+++ /dev/null
@@ -1,22 +0,0 @@
-<?php
-
-namespace HexletBasics\Loops\EdgeCases;
-
-// BEGIN
-function isArgumentsForSubstrCorrect($str, $index, $length)
-{
-    $stringLength = strlen($str);
-
-    if ($index < 0) {
-        return false;
-    } elseif ($length < 0) {
-        return false;
-    } elseif ($index >= $stringLength) {
-        return false;
-    } elseif ($index + $length > $stringLength) {
-        return false;
-    }
-
-    return true;
-}
-// END
diff --git a/modules/50-loops/29-edge-cases/ru/EXERCISE.md b/modules/50-loops/29-edge-cases/ru/EXERCISE.md
deleted file mode 100644
index 4c851cdc..00000000
--- a/modules/50-loops/29-edge-cases/ru/EXERCISE.md
+++ /dev/null
@@ -1,30 +0,0 @@
-Реализуйте функцию-предикат `isArgumentsForSubstrCorrect`, которая принимает три аргумента:
-
-1. строку
-2. индекс, с которого начинать извлечение
-3. длину извлекаемой подстроки
-
-Функция возвращает `false`, если хотя бы одно из условий истинно:
-
-* Отрицательная длина извлекаемой подстроки
-* Отрицательный заданный индекс
-* Заданный индекс выходит за границу всей строки
-* Длина подстроки в сумме с заданным индексом выходит за границу всей строки
-
-В ином случае функция возвращает `true`.
-
-Не забывайте, что индексы начинаются с `0`, поэтому индекс последнего элемента — это «длина строки минус 1».
-
-Пример вызова:
-
-```php
-<?php
-
-$str = 'Sansa Stark';
-isArgumentsForSubstrCorrect($str, -1, 3);  // false
-isArgumentsForSubstrCorrect($str, 4, 100); // false
-isArgumentsForSubstrCorrect($str, 10, 10); // false
-isArgumentsForSubstrCorrect($str, 11, 1);  // false
-isArgumentsForSubstrCorrect($str, 3, 3);   // true
-isArgumentsForSubstrCorrect($str, 0, 5);   // true
-```
diff --git a/modules/50-loops/29-edge-cases/ru/README.md b/modules/50-loops/29-edge-cases/ru/README.md
deleted file mode 100644
index 20efaee2..00000000
--- a/modules/50-loops/29-edge-cases/ru/README.md
+++ /dev/null
@@ -1,72 +0,0 @@
-В этом уроке мы реализуем функцию `mysubstr()`, которая извлекает из строки подстроку указанной длины.
-
-Она принимает на вход два аргумента:
-
-* Строку
-* Длину
-
-Эта функция возвращает подстроку, начиная с первого символа:
-
-```php
-<?php
-
-function mysubstr($str, $length)
-{
-    $index = 0;
-    $result = '';
-    while ($index < $length) {
-        $currentChar = $str[$index];
-        $result = "{$result}{$currentChar}";
-        $index = $index + 1;
-    }
-
-    return $result;
-}
-
-$str = 'If I look back I am lost';
-
-mysubstr($str, 1); // 'I'
-mysubstr($str, 7); // 'If I lo'
-```
-
-
-Кажется, что все хорошо. Но наша функция содержит множество ошибок, потому что в ней не учтены так называемые **пограничные случаи**. Функция нормально работает только с нормальными аргументами. Но мы не знаем, как она поведет себя, если передать ей такие варианты длины:
-
-* `0`
-* Отрицательное число
-* Число, превышающее реальный размер строки
-
-Функция `mysubstr()` не рассчитана на такие варианты. Можно подумать, что это не проблема: функция работает в нормальных условиях, и просто не нужно передавать ей «плохие аргументы».
-
-В идеальном мире — да, но в реальном мире ваш код будет запускаться в разных ситуациях, с разными комбинациями условий и данных. Нельзя быть уверенным, что аргументы всегда будут корректными, поэтому нужно учитывать все случаи, в рамках здравого смысла.
-
-Пограничные случаи — самая распространенная причина логических ошибок в программах. Программисты часто забывают что-нибудь учесть. Такие ошибки часто проявляются не сразу, и могут долгое время не приводить к видимым проблемам. Программа продолжает работать, но в какой-то момент обнаруживается, что в результатах есть ошибки.
-
-Часто причина заключается в слабой типизации PHP. Умение справляться с такими ошибками приходит с опытом, через постоянные проблемы в стиле «Ой, забыл проверить на пустую строку!».
-
-Давайте представим себе расширенную функцию `mysubstr()`. Она принимает три аргумента:
-
-* Строку
-* Индекс
-* Длину извлекаемой подстроки
-
-Функция возвращает подстроку указанной длины начиная с указанного индекса. Посмотрим примеры вызова:
-
-```php
-<?php
-
-$str = 'If I look back I am lost';
-mysubstr($str, 0, 1); // 'I'
-mysubstr($str, 3, 6); // 'I look'
-```
-
-Обсудим, что может пойти не так. Какие **пограничные случаи** стоит учитывать:
-
-* Отрицательная длина извлекаемой подстроки
-* Отрицательный заданный индекс
-* Заданный индекс выходит за границу всей строки
-* Длина подстроки в сумме с заданным индексом выходит за границу всей строки
-
-В реализации функции каждый пограничный случай будет отдельным куском кода, скорее всего реализованным с помощью `if`.
-
-Чтобы написать функцию `mysubstr()` и защититься от этих случаев, стоит написать отдельную функцию, которая будет проверять аргументы на корректность. Займемся этим в задании к этому уроку.
diff --git a/modules/50-loops/29-edge-cases/ru/data.yml b/modules/50-loops/29-edge-cases/ru/data.yml
deleted file mode 100644
index 272c1615..00000000
--- a/modules/50-loops/29-edge-cases/ru/data.yml
+++ /dev/null
@@ -1,3 +0,0 @@
----
-name: Пограничные случаи
-tips: []
diff --git a/modules/60-deep-into-strings/10-unicode/Makefile b/modules/50-loops/30-syntactic-sugar/Makefile
similarity index 100%
rename from modules/60-deep-into-strings/10-unicode/Makefile
rename to modules/50-loops/30-syntactic-sugar/Makefile
diff --git a/modules/50-loops/30-syntactic-sugar/Solution.php b/modules/50-loops/30-syntactic-sugar/Solution.php
new file mode 100644
index 00000000..bcce92f9
--- /dev/null
+++ b/modules/50-loops/30-syntactic-sugar/Solution.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace HexletBasics\Loops\SyntacticSugar;
+
+// BEGIN
+function buildProgressBar(int $completed, int $total): string
+{
+    $index = 0;
+    $result = '';
+
+    while ($index < $total) {
+        if ($index < $completed) {
+            $result .= '#';
+        } else {
+            $result .= '-';
+        }
+        $index += 1;
+    }
+
+    return $result;
+}
+// END
diff --git a/modules/50-loops/30-syntactic-sugar/SolutionTest.php b/modules/50-loops/30-syntactic-sugar/SolutionTest.php
new file mode 100644
index 00000000..ca12038c
--- /dev/null
+++ b/modules/50-loops/30-syntactic-sugar/SolutionTest.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace HexletBasics\Loops\SyntacticSugar;
+
+use HexletBasics\Exercise\TestCase;
+
+class SolutionTest extends TestCase
+{
+    public function test()
+    {
+        $this->assertEquals('-----', buildProgressBar(0, 5));
+        $this->assertEquals('###--', buildProgressBar(3, 5));
+        $this->assertEquals('#####', buildProgressBar(5, 5));
+    }
+}
diff --git a/modules/50-loops/30-syntax-sugar/description.es.yml b/modules/50-loops/30-syntactic-sugar/description.es.yml
similarity index 100%
rename from modules/50-loops/30-syntax-sugar/description.es.yml
rename to modules/50-loops/30-syntactic-sugar/description.es.yml
diff --git a/modules/50-loops/30-syntax-sugar/en/EXERCISE.md b/modules/50-loops/30-syntactic-sugar/en/EXERCISE.md
similarity index 100%
rename from modules/50-loops/30-syntax-sugar/en/EXERCISE.md
rename to modules/50-loops/30-syntactic-sugar/en/EXERCISE.md
diff --git a/modules/50-loops/30-syntax-sugar/en/README.md b/modules/50-loops/30-syntactic-sugar/en/README.md
similarity index 100%
rename from modules/50-loops/30-syntax-sugar/en/README.md
rename to modules/50-loops/30-syntactic-sugar/en/README.md
diff --git a/modules/50-loops/30-syntax-sugar/en/data.yml b/modules/50-loops/30-syntactic-sugar/en/data.yml
similarity index 100%
rename from modules/50-loops/30-syntax-sugar/en/data.yml
rename to modules/50-loops/30-syntactic-sugar/en/data.yml
diff --git a/modules/50-loops/30-syntax-sugar/es/EXERCISE.md b/modules/50-loops/30-syntactic-sugar/es/EXERCISE.md
similarity index 100%
rename from modules/50-loops/30-syntax-sugar/es/EXERCISE.md
rename to modules/50-loops/30-syntactic-sugar/es/EXERCISE.md
diff --git a/modules/50-loops/30-syntax-sugar/es/README.md b/modules/50-loops/30-syntactic-sugar/es/README.md
similarity index 100%
rename from modules/50-loops/30-syntax-sugar/es/README.md
rename to modules/50-loops/30-syntactic-sugar/es/README.md
diff --git a/modules/50-loops/30-syntax-sugar/es/data.yml b/modules/50-loops/30-syntactic-sugar/es/data.yml
similarity index 100%
rename from modules/50-loops/30-syntax-sugar/es/data.yml
rename to modules/50-loops/30-syntactic-sugar/es/data.yml
diff --git a/modules/50-loops/30-syntactic-sugar/ru/EXERCISE.md b/modules/50-loops/30-syntactic-sugar/ru/EXERCISE.md
new file mode 100644
index 00000000..1787413e
--- /dev/null
+++ b/modules/50-loops/30-syntactic-sugar/ru/EXERCISE.md
@@ -0,0 +1,16 @@
+
+Операторы синтаксического сахара особенно удобны, когда нужно постепенно собрать итоговое значение.
+
+Реализуйте функцию `buildProgressBar()`, которая принимает количество выполненных шагов и общее количество шагов, а затем возвращает строку-индикатор прогресса.
+
+Выполненные шаги обозначаются символом `#`, а оставшиеся — символом `-`. Старайтесь не использовать встроенные функции работы со строкой в своем решении.
+
+```php
+<?php
+
+buildProgressBar(0, 5); // '-----'
+buildProgressBar(3, 5); // '###--'
+buildProgressBar(5, 5); // '#####'
+```
+
+Вам пригодится оператор `.=`, чтобы постепенно собирать новую строку внутри цикла `while`. А оператор `+=` будет полезен, чтобы управлять условием цикла.
diff --git a/modules/50-loops/30-syntactic-sugar/ru/README.md b/modules/50-loops/30-syntactic-sugar/ru/README.md
new file mode 100644
index 00000000..e26f9802
--- /dev/null
+++ b/modules/50-loops/30-syntactic-sugar/ru/README.md
@@ -0,0 +1,71 @@
+В программировании часто встречаются повторяющиеся конструкции. В PHP, как и во многих других языках, есть возможность сокращать их запись. Такие упрощения называются **синтаксическим сахаром**, потому что они делают процесс написания кода немного проще и приятнее, «подслащивая» его :)
+
+## Сокращенные формы присваивания
+
+Часто требуется изменить значение переменной, прибавив или вычтя что-то, умножив или разделив на число. Базовый вариант выглядит так:
+
+```php
+<?php
+
+$index = $index + 1;
+$count = $count * 2;
+$total = $total - 5;
+$price = $price / 3;
+```
+
+PHP позволяет записывать это короче, с помощью комбинированных операторов:
+
+```php
+<?php
+
+$index += 1; // то же самое, что $index = $index + 1
+$count *= 2; // то же самое, что $count = $count * 2
+$total -= 5; // то же самое, что $total = $total - 5
+$price /= 3; // то же самое, что $price = $price / 3
+```
+
+Важно понимать, что отличия исключительно в способе записи. Интерпретатор превращает сокращенную конструкцию в развернутую.
+
+В циклах такие сокращения встречаются особенно часто. В них мы обычно меняем счетчик и накапливаем результат:
+
+```php
+<?php
+
+$sum = 0;
+$index = 1;
+
+while ($index <= 5) {
+    $sum += $index;   // то же самое, что $sum = $sum + $index
+    $index += 1;      // то же самое, что $index = $index + 1
+}
+
+print_r($sum); // => 15
+```
+
+Без сокращений тело цикла было бы длиннее:
+
+```php
+<?php
+
+while ($index <= 5) {
+    $sum = $sum + $index;
+    $index = $index + 1;
+}
+```
+
+## Другие операции
+
+Такая запись работает с числами и с другими типами данных.
+
+Для строк используется оператор конкатенации:
+
+```php
+<?php
+
+$text = 'Hello';
+$text .= ' World'; // то же самое, что $text = $text . ' World'
+```
+
+## Поддерживаемые сокращения
+
+Существует сокращенная форма почти для всех операторов: `+=`, `-=`, `*=`, `/=`, `%=`, `**=`, `.=`. Все они работают по одному принципу: берут текущее значение переменной, применяют операцию и сохраняют результат в ту же переменную.
diff --git a/modules/50-loops/30-syntax-sugar/ru/data.yml b/modules/50-loops/30-syntactic-sugar/ru/data.yml
similarity index 100%
rename from modules/50-loops/30-syntax-sugar/ru/data.yml
rename to modules/50-loops/30-syntactic-sugar/ru/data.yml
diff --git a/modules/50-loops/30-syntax-sugar/SolutionTest.php b/modules/50-loops/30-syntax-sugar/SolutionTest.php
deleted file mode 100644
index cd6f39db..00000000
--- a/modules/50-loops/30-syntax-sugar/SolutionTest.php
+++ /dev/null
@@ -1,20 +0,0 @@
-<?php
-
-namespace HexletBasics\Loops\SyntaxSugar;
-
-use PHPUnit\Framework\TestCase;
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        require 'index.php';
-
-        $text = 'If I look back I am lost';
-        $result1 = filterString($text, 'I');
-        $this->assertEquals('f  look back  am lost', $result1);
-
-        $result2 = filterString('zz zorro', 'z');
-        $this->assertEquals(' orro', $result2);
-    }
-}
diff --git a/modules/50-loops/30-syntax-sugar/index.php b/modules/50-loops/30-syntax-sugar/index.php
deleted file mode 100644
index 7063b878..00000000
--- a/modules/50-loops/30-syntax-sugar/index.php
+++ /dev/null
@@ -1,22 +0,0 @@
-<?php
-
-namespace HexletBasics\Loops\SyntaxSugar;
-
-// BEGIN
-function filterString($str, $char)
-{
-    $i = 0;
-    $result = '';
-    while ($i < strlen($str)) {
-        $currentChar = $str[$i];
-
-        if ($currentChar !== $char) {
-            $result = "{$result}{$currentChar}";
-        }
-
-        $i += 1;
-    }
-
-    return $result;
-}
-// END
diff --git a/modules/50-loops/30-syntax-sugar/ru/EXERCISE.md b/modules/50-loops/30-syntax-sugar/ru/EXERCISE.md
deleted file mode 100644
index f414c487..00000000
--- a/modules/50-loops/30-syntax-sugar/ru/EXERCISE.md
+++ /dev/null
@@ -1,10 +0,0 @@
-
-Реализуйте функцию `filterString()`, принимающую на вход строку и символ, и возвращающую новую строку, в которой удален переданный символ во всех его позициях.
-
-```php
-<?php
-
-$str = 'If I look back I am lost';
-filterString($str, 'I'); // 'f  look back  am lost'
-filterString($str, 'o'); // 'If I lk back I am lst'
-```
diff --git a/modules/50-loops/30-syntax-sugar/ru/README.md b/modules/50-loops/30-syntax-sugar/ru/README.md
deleted file mode 100644
index 7b9f4330..00000000
--- a/modules/50-loops/30-syntax-sugar/ru/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
-
-Подобные конструкции `$index = $index + 1` в PHP используются довольно часто, поэтому создатели языка добавили сокращенный вариант записи: `$index += 1`. Такие сокращения принято называть **синтаксическим сахаром**, потому что они делают процесс написания кода немного проще и приятнее, «подслащивая» его :)
-
-Важно понимать, что отличия исключительно в способе записи. Интерпретатор превращает сокращённую конструкцию в развернутую.
-
-Существуют сокращённые формы для всех арифметических операций и для конкатенации строк:
-
-- `$a = $a + 1` → `$a += 1`
-- `$a = $a - 1` → `$a -= 1`
-- `$a = $a * 2` → `$a *= 2`
-- `$a = $a / 1` → `$a /= 1`
-- `$a = $a . 'bla'` → `$a .= 'bla'`
diff --git a/modules/50-loops/50-mutators/index.php b/modules/50-loops/50-mutators/Solution.php
similarity index 89%
rename from modules/50-loops/50-mutators/index.php
rename to modules/50-loops/50-mutators/Solution.php
index 316e1245..136f141f 100644
--- a/modules/50-loops/50-mutators/index.php
+++ b/modules/50-loops/50-mutators/Solution.php
@@ -3,7 +3,7 @@
 namespace HexletBasics\Loops\Mutators;
 
 // BEGIN
-function makeItFunny($str, $n)
+function makeItFunny(string $str, int $n): string
 {
     $i = 0;
     $result = '';
diff --git a/modules/50-loops/50-mutators/SolutionTest.php b/modules/50-loops/50-mutators/SolutionTest.php
index 8dad8c17..ea1b3a2c 100644
--- a/modules/50-loops/50-mutators/SolutionTest.php
+++ b/modules/50-loops/50-mutators/SolutionTest.php
@@ -2,13 +2,12 @@
 
 namespace HexletBasics\Loops\Mutators;
 
-use PHPUnit\Framework\TestCase;
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        require 'index.php';
         $text = 'I never look back';
         $this->assertEquals('I NevEr LooK bAck', makeItFunny($text, 3));
         $this->assertEquals('hElLo', makeItFunny('hello', 2));
diff --git a/modules/50-loops/55-return-from-loop/SolutionTest.php b/modules/50-loops/55-return-from-loop/SolutionTest.php
deleted file mode 100644
index 3cbcfb3e..00000000
--- a/modules/50-loops/55-return-from-loop/SolutionTest.php
+++ /dev/null
@@ -1,17 +0,0 @@
-<?php
-
-namespace HexletBasics\Loops\ReturnFromLoop;
-
-use PHPUnit\Framework\TestCase;
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        require 'index.php';
-        $this->assertTrue(hasChar('Hexlet', 'H'));
-        $this->assertFalse(hasChar('Hexlet', 'h'));
-        $this->assertTrue(hasChar('Awesomeness', 'm'));
-        $this->assertFalse(hasChar('Awesomeness', 'd'));
-    }
-}
diff --git a/modules/50-loops/55-return-from-loop/index.php b/modules/50-loops/55-return-from-loop/index.php
deleted file mode 100644
index 6f27833a..00000000
--- a/modules/50-loops/55-return-from-loop/index.php
+++ /dev/null
@@ -1,21 +0,0 @@
-<?php
-
-namespace HexletBasics\Loops\ReturnFromLoop;
-
-// BEGIN
-function hasChar($str, $char)
-{
-    $length = strlen($str);
-    $index = 0;
-    while ($index < $length) {
-        $currentChar = $str[$index];
-        if ($currentChar === $char) {
-            return true;
-        }
-
-        $index++;
-    }
-
-    return false;
-}
-// END
diff --git a/modules/50-loops/55-return-from-loop/ru/EXERCISE.md b/modules/50-loops/55-return-from-loop/ru/EXERCISE.md
deleted file mode 100644
index ab0879de..00000000
--- a/modules/50-loops/55-return-from-loop/ru/EXERCISE.md
+++ /dev/null
@@ -1,16 +0,0 @@
-
-Реализуйте функцию `hasChar()`, которая проверяет, содержит ли строка букву в указанном регистре. Функция принимает два параметра:
-
-* Строка
-* Буква для поиска
-
-Пример вызова:
-
-```php
-<?php
-
-hasChar('Hexlet', 'H'); // true
-hasChar('Hexlet', 'h'); // false
-hasChar('Awesomeness', 'm'); // true
-hasChar('Awesomeness', 'd'); // false
-```
diff --git a/modules/60-deep-into-strings/30-locales/Makefile b/modules/50-loops/55-return-from-loops/Makefile
similarity index 100%
rename from modules/60-deep-into-strings/30-locales/Makefile
rename to modules/50-loops/55-return-from-loops/Makefile
diff --git a/modules/50-loops/55-return-from-loops/Solution.php b/modules/50-loops/55-return-from-loops/Solution.php
new file mode 100644
index 00000000..d8f02810
--- /dev/null
+++ b/modules/50-loops/55-return-from-loops/Solution.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace HexletBasics\Loops\ReturnFromLoops;
+
+// BEGIN
+function hasAtSymbol(string $email): bool
+{
+    $index = 0;
+    while ($index < strlen($email)) {
+        if ($email[$index] === '@') {
+            return true;
+        }
+
+        $index += 1;
+    }
+
+    return false;
+}
+// END
diff --git a/modules/50-loops/55-return-from-loops/SolutionTest.php b/modules/50-loops/55-return-from-loops/SolutionTest.php
new file mode 100644
index 00000000..6a72042e
--- /dev/null
+++ b/modules/50-loops/55-return-from-loops/SolutionTest.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace HexletBasics\Loops\ReturnFromLoops;
+
+use HexletBasics\Exercise\TestCase;
+
+class SolutionTest extends TestCase
+{
+    public function test()
+    {
+        $this->assertTrue(hasAtSymbol('support@example.com'));
+        $this->assertFalse(hasAtSymbol('wrong-email'));
+        $this->assertTrue(hasAtSymbol('@admin'));
+        $this->assertTrue(hasAtSymbol('admin@'));
+    }
+}
diff --git a/modules/50-loops/55-return-from-loop/description.es.yml b/modules/50-loops/55-return-from-loops/description.es.yml
similarity index 100%
rename from modules/50-loops/55-return-from-loop/description.es.yml
rename to modules/50-loops/55-return-from-loops/description.es.yml
diff --git a/modules/50-loops/55-return-from-loop/en/EXERCISE.md b/modules/50-loops/55-return-from-loops/en/EXERCISE.md
similarity index 100%
rename from modules/50-loops/55-return-from-loop/en/EXERCISE.md
rename to modules/50-loops/55-return-from-loops/en/EXERCISE.md
diff --git a/modules/50-loops/55-return-from-loop/en/README.md b/modules/50-loops/55-return-from-loops/en/README.md
similarity index 100%
rename from modules/50-loops/55-return-from-loop/en/README.md
rename to modules/50-loops/55-return-from-loops/en/README.md
diff --git a/modules/50-loops/55-return-from-loop/en/data.yml b/modules/50-loops/55-return-from-loops/en/data.yml
similarity index 100%
rename from modules/50-loops/55-return-from-loop/en/data.yml
rename to modules/50-loops/55-return-from-loops/en/data.yml
diff --git a/modules/50-loops/55-return-from-loop/es/EXERCISE.md b/modules/50-loops/55-return-from-loops/es/EXERCISE.md
similarity index 100%
rename from modules/50-loops/55-return-from-loop/es/EXERCISE.md
rename to modules/50-loops/55-return-from-loops/es/EXERCISE.md
diff --git a/modules/50-loops/55-return-from-loop/es/README.md b/modules/50-loops/55-return-from-loops/es/README.md
similarity index 100%
rename from modules/50-loops/55-return-from-loop/es/README.md
rename to modules/50-loops/55-return-from-loops/es/README.md
diff --git a/modules/50-loops/55-return-from-loop/es/data.yml b/modules/50-loops/55-return-from-loops/es/data.yml
similarity index 100%
rename from modules/50-loops/55-return-from-loop/es/data.yml
rename to modules/50-loops/55-return-from-loops/es/data.yml
diff --git a/modules/50-loops/55-return-from-loops/ru/EXERCISE.md b/modules/50-loops/55-return-from-loops/ru/EXERCISE.md
new file mode 100644
index 00000000..e419e9fa
--- /dev/null
+++ b/modules/50-loops/55-return-from-loops/ru/EXERCISE.md
@@ -0,0 +1,12 @@
+
+Реализуйте функцию `hasAtSymbol()`, которая проверяет, есть ли в email символ `@`.
+
+Функция должна вернуть `true`, как только найдет `@`. Если цикл дошел до конца строки и символ не найден, функция должна вернуть `false`.
+
+```php
+<?php
+
+hasAtSymbol('support@example.com'); // true
+hasAtSymbol('wrong-email');         // false
+hasAtSymbol('@admin');              // true
+```
diff --git a/modules/50-loops/55-return-from-loop/ru/README.md b/modules/50-loops/55-return-from-loops/ru/README.md
similarity index 51%
rename from modules/50-loops/55-return-from-loop/ru/README.md
rename to modules/50-loops/55-return-from-loops/ru/README.md
index 60d611c9..0efdba5e 100644
--- a/modules/50-loops/55-return-from-loop/ru/README.md
+++ b/modules/50-loops/55-return-from-loops/ru/README.md
@@ -1,17 +1,25 @@
-
 Работа с циклами обычно сводится к двум сценариям:
 
 1. Агрегация. Накопление результата во время итераций и работа с ним после цикла. Переворот строки как раз относится к такому варианту.
 2. Выполнение цикла до достижения необходимого результата и выход. Например, задача поиска простых чисел. Напомним, что простое число — это число, которое делится без остатка только на себя и на единицу.
 
-Рассмотрим простой алгоритм проверки простоты числа. Будем делить искомое число `x` на все числа из диапазона от двух до `x - 1` и смотреть остаток. Если в этом диапазоне не найден делитель, который делит число `x` без остатка, значит перед нами простое число.
+Рассмотрим алгоритм проверки простоты числа. Будем делить искомое число `x` на все числа из диапазона от двух до `x - 1` и смотреть остаток. Если в этом диапазоне не найден делитель, который делит число `x` без остатка, значит перед нами простое число.
+
+## Проверка простоты числа 5: пошаговый разбор
+
+1. Берем число x = 5. Возможные делители ищем в диапазоне от 2 до x - 1, то есть от 2 до 4.
+2. Делим 5 на 2. Остаток равен 1, делителя не нашли, продолжаем.
+3. Делим 5 на 3. Остаток равен 2, делителя не нашли, продолжаем.
+4. Делим 5 на 4. Остаток равен 1, делителя не нашли, завершаем перебор.
 
-Если задуматься, то можно заметить, что достаточно проверять числа не до `x - 1`, а до половины числа. Например, 11 не делится на 2, 3, 4, 5. Но и дальше гарантированно не будет делиться на числа больше своей половины. Значит, можно провести небольшую оптимизацию и проверять деление только до `x / 2`.
+Итог. В диапазоне 2…4 не нашлось ни одного числа, на которое 5 делится без остатка. Следовательно, 5 является простым числом.
+
+Если задуматься, то можно заметить, что достаточно проверять числа не до `x - 1`, а до половины числа. Например, 11 не делится на 2, 3, 4, 5. Но и дальше гарантированно не будет делиться на числа больше своей половины. Значит, можно провести небольшую оптимизацию и проверять деление только до `x / 2`:
 
 ```php
 <?php
 
-function isPrime($number)
+function isPrime(int $number): bool
 {
     if ($number < 2) {
         return false;
@@ -30,10 +38,23 @@ function isPrime($number)
     return true;
 }
 
-isPrime(1); // false
-isPrime(2); // true
-isPrime(3); // true
-isPrime(4); // false
+var_dump(isPrime(1)); // => bool(false)
+var_dump(isPrime(2)); // => bool(true)
+var_dump(isPrime(3)); // => bool(true)
+var_dump(isPrime(4)); // => bool(false)
+```
+
+*Если быть честными до конца, то для решения задачи хватит проверки чисел до значения квадратного корня `$number`, но в нашем случае важно сосредоточиться на понимании работы с условиями внутри цикла.*
+
+```text
+while (...) {
+    if (условие) {
+        return значение;  ← выход из функции (и из цикла)
+    }
+    ...
+}
+─────────────────────────
+Без return цикл продолжается до конца
 ```
 
 Алгоритм построен таким образом, что если во время последовательного деления на числа до `x / 2` находится хоть одно, которое делит без остатка, то переданный аргумент — не простое число, а значит дальнейшие вычисления не имеют смысла. В этом месте стоит возврат `false`.
diff --git a/modules/50-loops/55-return-from-loop/ru/data.yml b/modules/50-loops/55-return-from-loops/ru/data.yml
similarity index 100%
rename from modules/50-loops/55-return-from-loop/ru/data.yml
rename to modules/50-loops/55-return-from-loops/ru/data.yml
diff --git a/modules/50-loops/70-for/Solution.php b/modules/50-loops/70-for/Solution.php
new file mode 100644
index 00000000..2890e4e3
--- /dev/null
+++ b/modules/50-loops/70-for/Solution.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace HexletBasics\Loops\ForLoop;
+
+// BEGIN
+function normalizeFilename(string $filename): string
+{
+    $result = '';
+
+    for ($i = 0; $i < strlen($filename); $i += 1) {
+        $currentChar = $filename[$i];
+
+        if ($currentChar === ' ') {
+            $result .= '_';
+        } else {
+            $result .= $currentChar;
+        }
+    }
+
+    return $result;
+}
+// END
diff --git a/modules/50-loops/70-for/SolutionTest.php b/modules/50-loops/70-for/SolutionTest.php
index fff2a459..9f020630 100644
--- a/modules/50-loops/70-for/SolutionTest.php
+++ b/modules/50-loops/70-for/SolutionTest.php
@@ -2,16 +2,15 @@
 
 namespace HexletBasics\Loops\ForLoop;
 
-use PHPUnit\Framework\TestCase;
+use HexletBasics\Exercise\TestCase;
 
 class SolutionTest extends TestCase
 {
     public function test()
     {
-        require 'index.php';
-
-        $this->assertEquals(1, sumOfSeries(1, 1));
-        $this->assertEquals(3, sumOfSeries(1, 2));
-        $this->assertEquals(24, sumOfSeries(7, 9));
+        $this->assertEquals('my_photo.png', normalizeFilename('my photo.png'));
+        $this->assertEquals('final_report.pdf', normalizeFilename('final report.pdf'));
+        $this->assertEquals('already_ready.txt', normalizeFilename('already_ready.txt'));
+        $this->assertEquals('two__spaces.txt', normalizeFilename('two  spaces.txt'));
     }
 }
diff --git a/modules/50-loops/70-for/index.php b/modules/50-loops/70-for/index.php
deleted file mode 100644
index 50eafea6..00000000
--- a/modules/50-loops/70-for/index.php
+++ /dev/null
@@ -1,22 +0,0 @@
-<?php
-
-namespace HexletBasics\Loops\ForLoop;
-
-// BEGIN
-function sumOfSeries($start, $finish)
-{
-    /*
-    * Note: we create a new variable here,
-    * rather than use the argument as a counter.
-    * Counter will be changing as the function works,
-    * and changing arguments is considered harmful.
-    */
-
-    $sum = 0;
-    for ($i = $start; $i <= $finish; $i++) {
-        $sum += $i;
-    }
-
-    return $sum;
-}
-// END
diff --git a/modules/50-loops/70-for/ru/EXERCISE.md b/modules/50-loops/70-for/ru/EXERCISE.md
index 36ffaad0..2ccb6c43 100644
--- a/modules/50-loops/70-for/ru/EXERCISE.md
+++ b/modules/50-loops/70-for/ru/EXERCISE.md
@@ -1,20 +1,12 @@
 
-Реализуйте функцию `sumOfSeries()`, которая считает сумму [ряда целых чисел](https://ru.wikipedia.org/wiki/Числовой_ряд). Ряд задаётся двумя числами — начальным и конечным.
+Реализуйте функцию `normalizeFilename()`, которая подготавливает имя файла для сохранения. Функция принимает строку и возвращает новую строку, где все пробелы заменены на символ `_`.
 
-Функция принимает два аргумента-числа и возвращает сумму ряда. Например, для аргументов `4` и `7` сумма будет `4 + 5 + 6 + 7 = 22`.
+Пример вызова:
 
 ```php
 <?php
 
-sumOfSeries(1, 2); // 3
-sumOfSeries(1, 3); // 6
-sumOfSeries(4, 7); // 22
-```
-
-Если начальное и конечное числа равны, то результатом будет то же число:
-
-```php
-<?php
-
-sumOfSeries(1, 1); // 1
+normalizeFilename('my photo.png');      // 'my_photo.png'
+normalizeFilename('final report.pdf');  // 'final_report.pdf'
+normalizeFilename('already_ready.txt'); // 'already_ready.txt'
 ```
diff --git a/modules/50-loops/70-for/ru/README.md b/modules/50-loops/70-for/ru/README.md
index 8d942df7..8838cc8d 100644
--- a/modules/50-loops/70-for/ru/README.md
+++ b/modules/50-loops/70-for/ru/README.md
@@ -1,31 +1,102 @@
-Цикл `while` идеален для ситуаций, когда количество итераций неизвестно заранее — например, при поиске простого числа. Когда количество итераций известно, предпочтительнее использовать цикл `for`. Именно его мы изучим в этом уроке.
+С помощью цикла `while` решают любую задачу перебора элементов, но его отличает многословность. Для `while` нужно заранее вводить счетчик, задавать условие остановки и не забывать менять счетчик в теле цикла. Когда циклов немного, то это нормально, но в реальном коде циклы встречаются на каждом шагу. Поэтому управлять счетчиком вручную утомительно, особенно когда схема всегда одна и та же.
 
-Посмотрим реализацию переворота строки через цикл `for`:
+Для таких ситуаций в PHP есть цикл `for`. Он собирает все управление счетчиком в одном месте — в круглых скобках:
+
+```text
+while:                      for:
+
+$i = 0;                     for ($i = 0; $i < 5; $i += 1) {
+while ($i < 5) {                ...
+    ...                     }
+    $i += 1;
+}
+│                           │
+└── управление разбросано   └── все управление в одной строке
+```
+
+Посмотрим, что находится в круглых скобках:
+
+1. Начальное значение счетчика — этот код выполняется ровно один раз перед первой итерацией
+2. Предикат (условие повторения цикла) — выполняется на каждой итерации, как и в `while`
+3. Описание изменения счетчика — этот код выполняется в конце каждой итерации
+
+В остальном принцип работы точно такой же, как у цикла `while`.
+
+Посмотрим, как реализовать функцию переворота строки через цикл `for`. Такое задание встречается на собеседованиях:
 
 ```php
 <?php
 
-function reverseString($str)
+function reverseString(string $str): string
 {
+    // Начальное значение
     $result = '';
 
     for ($i = 0; $i < strlen($str); $i += 1) {
         $currentChar = $str[$i];
+        // Соединяем в обратном порядке
         $result = "{$currentChar}{$result}";
     }
 
+    // Цикл заканчивается, когда пройдена вся строка
     return $result;
 }
+
+print_r(reverseString('go!')); // => !og
 ```
 
 Этот код можно прочитать так:
 
 > Цикл с индексом `$i` повторяется, пока соблюдается условие `$i < strlen($str)`, и после каждого шага `$i` увеличивается на 1
 
-Посмотрим, что находится в круглых скобках:
+Разберем подробно, как отрабатывает цикл в примере выше на каждом шаге итераций:
 
-1. Начальное значение счетчика — этот код выполняется ровно один раз перед первой итерацией
-2. Предикат (условие повторения циклов) — выполняется на каждой итерации, как и в `while`
-3. Описание изменения счетчика — этот код выполняется в конце каждой итерации
+```text
+reverseString('go!')
 
-В остальном принцип работы точно такой же, как у цикла `while`.
+до цикла: result = ''
+
+1 итерация: currentChar = 'g'
+result = currentChar . result
+       = 'g' . ''
+       = 'g'
+
+2 итерация: currentChar = 'o'
+result = currentChar . result
+       = 'o' . 'g'
+       = 'og'
+
+3 итерация: currentChar = '!'
+result = currentChar . result
+       = '!' . 'og'
+       = '!og'
+```
+
+Теперь посчитаем количество упоминаний символа в строке без учета регистра:
+
+```php
+<?php
+
+// $text - произвольный текст
+// $char - символ, который нужно учитывать
+function charsCount(string $text, string $char): int
+{
+    // Так как ищем сумму, то начальное значение 0
+    $result = 0;
+
+    for ($i = 0; $i < strlen($text); $i += 1) {
+        // Приводим все к нижнему регистру,
+        // чтобы не зависеть от текущего регистра
+        if (strtolower($text[$i]) === strtolower($char)) {
+            $result += 1;
+        }
+    }
+
+    return $result;
+}
+
+charsCount('hexlet!', 'e'); // 2
+charsCount('hExlet!', 'e'); // 2
+charsCount('hExlet!', 'E'); // 2
+charsCount('hexlet!', 'a'); // 0
+```
diff --git a/modules/60-deep-into-strings/40-startwith/Makefile b/modules/50-loops/80-for-in-range/Makefile
similarity index 100%
rename from modules/60-deep-into-strings/40-startwith/Makefile
rename to modules/50-loops/80-for-in-range/Makefile
diff --git a/modules/50-loops/80-for-in-range/Solution.php b/modules/50-loops/80-for-in-range/Solution.php
new file mode 100644
index 00000000..154e24e0
--- /dev/null
+++ b/modules/50-loops/80-for-in-range/Solution.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace HexletBasics\Loops\ForInRange;
+
+// BEGIN
+function fizzbuzz(int $n): string
+{
+    $result = '';
+
+    foreach (range(1, $n) as $i) {
+        if ($i % 3 === 0 && $i % 5 === 0) {
+            $word = 'FizzBuzz';
+        } elseif ($i % 3 === 0) {
+            $word = 'Fizz';
+        } elseif ($i % 5 === 0) {
+            $word = 'Buzz';
+        } else {
+            $word = (string) $i;
+        }
+
+        if ($result === '') {
+            $result = $word;
+        } else {
+            $result .= " {$word}";
+        }
+    }
+
+    return $result;
+}
+// END
diff --git a/modules/50-loops/80-for-in-range/SolutionTest.php b/modules/50-loops/80-for-in-range/SolutionTest.php
new file mode 100644
index 00000000..36d4c006
--- /dev/null
+++ b/modules/50-loops/80-for-in-range/SolutionTest.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace HexletBasics\Loops\ForInRange;
+
+use HexletBasics\Exercise\TestCase;
+
+class SolutionTest extends TestCase
+{
+    public function test()
+    {
+        $this->assertEquals('1', fizzbuzz(1));
+        $this->assertEquals('1 2 Fizz', fizzbuzz(3));
+        $this->assertEquals('1 2 Fizz 4 Buzz', fizzbuzz(5));
+        $this->assertEquals('1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz', fizzbuzz(15));
+    }
+}
diff --git a/modules/50-loops/80-for-in-range/description.es.yml b/modules/50-loops/80-for-in-range/description.es.yml
new file mode 100644
index 00000000..984b7f24
--- /dev/null
+++ b/modules/50-loops/80-for-in-range/description.es.yml
@@ -0,0 +1,111 @@
+---
+
+name: Bucle foreach y función range
+theory: |
+  Imagina que tenemos una serie de números del 0 al 9. Queremos sumar estos números. Podríamos hacerlo así:
+
+  ```php
+  <?php
+
+  $sum = 0;
+  $i = 0;
+
+  while ($i < 10) {
+      $sum += $i;
+      $i += 1;
+  }
+
+  print_r($sum); // => 45
+  ```
+
+  Podemos reescribir este código usando el bucle `foreach` y la función `range()`:
+
+  ```php
+  <?php
+
+  $sum = 0;
+
+  foreach (range(0, 9) as $i) {
+      $sum += $i;
+  }
+
+  print_r($sum); // => 45
+  ```
+
+  La función `range()` crea una secuencia de números dentro de un rango determinado. La llamada `range(0, 9)` devuelve un conjunto de números del 0 al 9. El bucle `foreach` recorre este conjunto: en cada iteración escribe el siguiente número en la variable indicada después de la palabra clave `as` y ejecuta el cuerpo del bucle.
+
+  No se necesita ningún contador. El bucle `foreach` sabe por sí mismo cuándo detenerse: cuando se acaban los números del conjunto. Por eso aquí es imposible olvidarse de cambiar el contador y obtener un bucle infinito.
+
+  La función `range()` admite varias formas de llamada. La forma `range(start, end)` crea una secuencia desde `start` hasta `end`. Ten en cuenta que en PHP el valor final está **incluido** en el rango — en muchos otros lenguajes no es así. La forma `range(start, end, step)` crea una secuencia con el paso `step`.
+
+  Las variantes de `range()` se ven así:
+
+  ```text
+  range(1, 5)     →  1, 2, 3, 4, 5
+  range(0, 3)     →  0, 1, 2, 3
+  range(0, 10, 2) →  0, 2, 4, 6, 8, 10
+                      └── ambos extremos incluidos
+  ```
+
+  El ejemplo de la suma lo vimos arriba. Veamos otro: imprimir los números del 1 al 3:
+
+  ```php
+  <?php
+
+  foreach (range(1, 3) as $i) {
+      print_r("{$i}\n");
+  }
+
+  // => 1
+  // => 2
+  // => 3
+  ```
+
+  Ahora intentemos mostrar los números en orden inverso. Si el inicio del rango es mayor que el final, `range()` construye por sí mismo una secuencia descendente:
+
+  ```php
+  <?php
+
+  foreach (range(3, 1) as $i) {
+      print_r("{$i}\n");
+  }
+
+  // => 3
+  // => 2
+  // => 1
+  ```
+
+  La estructura `foreach` con la función `range()` es la forma más corta de recorrer un rango de números. Cuando se necesita control total sobre el contador, por ejemplo para cambiarlo según una regla compleja, los bucles `for` y `while` acuden al rescate.
+
+instructions: |
+  FizzBuzz es una de las tareas de entrevista más famosas para programadores principiantes. Se utiliza para comprobar la habilidad de trabajar con bucles y condiciones. Implementa una función `fizzbuzz()` que devuelva una cadena con los números del 1 a `$n`.
+
+  Las reglas:
+
+  - si un número es divisible por 3, se sustituye por la palabra `Fizz`,
+  - si un número es divisible por 5 — por la palabra `Buzz`,
+  - si es divisible por 3 y por 5 a la vez — por la palabra `FizzBuzz`.
+
+  Todos los elementos deben unirse con un espacio.
+
+  Esta tarea aparece a menudo en entrevistas de programación, por lo que es útil saber resolverla.
+
+  Ejemplo de llamada de la función:
+
+  ```php
+  <?php
+
+  fizzbuzz(15);
+  // '1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz'
+  ```
+
+  ### Algoritmo
+
+  1. Declarar el elemento neutro de la agregación (una cadena vacía)
+  2. Usar un bucle con los números del 1 a `$n`
+  3. Comprobar cada número con las condiciones de división
+  4. Añadir el resultado de cada iteración al resultado final usando un espacio
+
+tips:
+  - |
+    [range](https://www.php.net/manual/es/function.range.php)
diff --git a/modules/50-loops/80-for-in-range/en/EXERCISE.md b/modules/50-loops/80-for-in-range/en/EXERCISE.md
new file mode 100644
index 00000000..bc988735
--- /dev/null
+++ b/modules/50-loops/80-for-in-range/en/EXERCISE.md
@@ -0,0 +1,28 @@
+
+FizzBuzz is one of the most famous interview tasks for beginner programmers. It is given to test the ability to work with loops and conditions. Implement a function `fizzbuzz()` that returns a string with the numbers from 1 to `$n`.
+
+The rules:
+
+- if a number is divisible by 3, it is replaced with the word `Fizz`,
+- if a number is divisible by 5 — with the word `Buzz`,
+- if it is divisible by both 3 and 5 — with the word `FizzBuzz`.
+
+All elements must be joined with a space.
+
+This task often comes up in programming interviews, so it is useful to know how to solve it.
+
+Function call example:
+
+```php
+<?php
+
+fizzbuzz(15);
+// '1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz'
+```
+
+### Algorithm
+
+1. Declare the neutral element of aggregation (an empty string)
+2. Use a loop with the numbers from 1 to `$n`
+3. Check each number against the division conditions
+4. Add the result of each iteration to the final result using a space
diff --git a/modules/50-loops/80-for-in-range/en/README.md b/modules/50-loops/80-for-in-range/en/README.md
new file mode 100644
index 00000000..dc65e6f9
--- /dev/null
+++ b/modules/50-loops/80-for-in-range/en/README.md
@@ -0,0 +1,74 @@
+Imagine we have a series of numbers from 0 to 9. We want to add these numbers together. We could do it like this:
+
+```php
+<?php
+
+$sum = 0;
+$i = 0;
+
+while ($i < 10) {
+    $sum += $i;
+    $i += 1;
+}
+
+print_r($sum); // => 45
+```
+
+We can rewrite this code using the `foreach` loop and the `range()` function:
+
+```php
+<?php
+
+$sum = 0;
+
+foreach (range(0, 9) as $i) {
+    $sum += $i;
+}
+
+print_r($sum); // => 45
+```
+
+The `range()` function creates a sequence of numbers within a specific range. The call `range(0, 9)` returns a set of numbers from 0 to 9. The `foreach` loop iterates over this set: on each iteration, it writes the next number into the variable specified after the `as` keyword and executes the loop body.
+
+No counter is needed. The `foreach` loop knows when to stop by itself — when the numbers in the set run out. So it is impossible to forget to change the counter and get an infinite loop here.
+
+The `range()` function supports several call variants. The form `range(start, end)` creates a sequence from `start` to `end`. Note that in PHP the end value is **included** in the range — in many other languages it is not. The form `range(start, end, step)` creates a sequence with the step `step`.
+
+The `range()` variants look like this:
+
+```text
+range(1, 5)     →  1, 2, 3, 4, 5
+range(0, 3)     →  0, 1, 2, 3
+range(0, 10, 2) →  0, 2, 4, 6, 8, 10
+                    └── both ends are included
+```
+
+We covered the sum example above. Let's look at another one — printing the numbers from 1 to 3:
+
+```php
+<?php
+
+foreach (range(1, 3) as $i) {
+    print_r("{$i}\n");
+}
+
+// => 1
+// => 2
+// => 3
+```
+
+Now let's try to print the numbers in reverse order. If the start of the range is greater than the end, `range()` builds a descending sequence on its own:
+
+```php
+<?php
+
+foreach (range(3, 1) as $i) {
+    print_r("{$i}\n");
+}
+
+// => 3
+// => 2
+// => 1
+```
+
+The `foreach` construct with the `range()` function is the shortest way to walk over a range of numbers. When full control over the counter is needed, for example changing it by a complex rule, the `for` and `while` loops come to the rescue.
diff --git a/modules/50-loops/80-for-in-range/en/data.yml b/modules/50-loops/80-for-in-range/en/data.yml
new file mode 100644
index 00000000..779c31ac
--- /dev/null
+++ b/modules/50-loops/80-for-in-range/en/data.yml
@@ -0,0 +1,5 @@
+---
+name: Foreach loop and range function
+tips:
+  - |
+    [range](https://www.php.net/manual/en/function.range.php)
diff --git a/modules/50-loops/80-for-in-range/es/EXERCISE.md b/modules/50-loops/80-for-in-range/es/EXERCISE.md
new file mode 100644
index 00000000..8c836617
--- /dev/null
+++ b/modules/50-loops/80-for-in-range/es/EXERCISE.md
@@ -0,0 +1,28 @@
+
+FizzBuzz es una de las tareas de entrevista más famosas para programadores principiantes. Se utiliza para comprobar la habilidad de trabajar con bucles y condiciones. Implementa una función `fizzbuzz()` que devuelva una cadena con los números del 1 a `$n`.
+
+Las reglas:
+
+- si un número es divisible por 3, se sustituye por la palabra `Fizz`,
+- si un número es divisible por 5 — por la palabra `Buzz`,
+- si es divisible por 3 y por 5 a la vez — por la palabra `FizzBuzz`.
+
+Todos los elementos deben unirse con un espacio.
+
+Esta tarea aparece a menudo en entrevistas de programación, por lo que es útil saber resolverla.
+
+Ejemplo de llamada de la función:
+
+```php
+<?php
+
+fizzbuzz(15);
+// '1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz'
+```
+
+### Algoritmo
+
+1. Declarar el elemento neutro de la agregación (una cadena vacía)
+2. Usar un bucle con los números del 1 a `$n`
+3. Comprobar cada número con las condiciones de división
+4. Añadir el resultado de cada iteración al resultado final usando un espacio
diff --git a/modules/50-loops/80-for-in-range/es/README.md b/modules/50-loops/80-for-in-range/es/README.md
new file mode 100644
index 00000000..8f0457df
--- /dev/null
+++ b/modules/50-loops/80-for-in-range/es/README.md
@@ -0,0 +1,74 @@
+Imagina que tenemos una serie de números del 0 al 9. Queremos sumar estos números. Podríamos hacerlo así:
+
+```php
+<?php
+
+$sum = 0;
+$i = 0;
+
+while ($i < 10) {
+    $sum += $i;
+    $i += 1;
+}
+
+print_r($sum); // => 45
+```
+
+Podemos reescribir este código usando el bucle `foreach` y la función `range()`:
+
+```php
+<?php
+
+$sum = 0;
+
+foreach (range(0, 9) as $i) {
+    $sum += $i;
+}
+
+print_r($sum); // => 45
+```
+
+La función `range()` crea una secuencia de números dentro de un rango determinado. La llamada `range(0, 9)` devuelve un conjunto de números del 0 al 9. El bucle `foreach` recorre este conjunto: en cada iteración escribe el siguiente número en la variable indicada después de la palabra clave `as` y ejecuta el cuerpo del bucle.
+
+No se necesita ningún contador. El bucle `foreach` sabe por sí mismo cuándo detenerse: cuando se acaban los números del conjunto. Por eso aquí es imposible olvidarse de cambiar el contador y obtener un bucle infinito.
+
+La función `range()` admite varias formas de llamada. La forma `range(start, end)` crea una secuencia desde `start` hasta `end`. Ten en cuenta que en PHP el valor final está **incluido** en el rango — en muchos otros lenguajes no es así. La forma `range(start, end, step)` crea una secuencia con el paso `step`.
+
+Las variantes de `range()` se ven así:
+
+```text
+range(1, 5)     →  1, 2, 3, 4, 5
+range(0, 3)     →  0, 1, 2, 3
+range(0, 10, 2) →  0, 2, 4, 6, 8, 10
+                    └── ambos extremos incluidos
+```
+
+El ejemplo de la suma lo vimos arriba. Veamos otro: imprimir los números del 1 al 3:
+
+```php
+<?php
+
+foreach (range(1, 3) as $i) {
+    print_r("{$i}\n");
+}
+
+// => 1
+// => 2
+// => 3
+```
+
+Ahora intentemos mostrar los números en orden inverso. Si el inicio del rango es mayor que el final, `range()` construye por sí mismo una secuencia descendente:
+
+```php
+<?php
+
+foreach (range(3, 1) as $i) {
+    print_r("{$i}\n");
+}
+
+// => 3
+// => 2
+// => 1
+```
+
+La estructura `foreach` con la función `range()` es la forma más corta de recorrer un rango de números. Cuando se necesita control total sobre el contador, por ejemplo para cambiarlo según una regla compleja, los bucles `for` y `while` acuden al rescate.
diff --git a/modules/50-loops/80-for-in-range/es/data.yml b/modules/50-loops/80-for-in-range/es/data.yml
new file mode 100644
index 00000000..e358111d
--- /dev/null
+++ b/modules/50-loops/80-for-in-range/es/data.yml
@@ -0,0 +1,5 @@
+---
+name: Bucle foreach y función range
+tips:
+  - |
+    [range](https://www.php.net/manual/es/function.range.php)
diff --git a/modules/50-loops/80-for-in-range/ru/EXERCISE.md b/modules/50-loops/80-for-in-range/ru/EXERCISE.md
new file mode 100644
index 00000000..f7c7e534
--- /dev/null
+++ b/modules/50-loops/80-for-in-range/ru/EXERCISE.md
@@ -0,0 +1,28 @@
+
+FizzBuzz — одно из самых известных заданий на собеседованиях для начинающих программистов. Его дают, чтобы проверить умение работать с циклами и условиями. Реализуйте функцию `fizzbuzz()`, которая возвращает строку с числами от 1 до `$n`.
+
+При этом:
+
+- если число делится на 3, вместо него подставляется слово `Fizz`,
+- если число делится на 5 — слово `Buzz`,
+- если делится и на 3, и на 5 — слово `FizzBuzz`.
+
+Все элементы должны соединяться пробелом.
+
+Это задание нередко встречается на собеседованиях для программистов, поэтому полезно уметь его решать.
+
+Пример вызова функции:
+
+```php
+<?php
+
+fizzbuzz(15);
+// '1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz'
+```
+
+### Алгоритм
+
+1. Объявить нейтральный элемент агрегации (пустая строка)
+2. Использовать цикл с числами от 1 до `$n`
+3. Проверять число на условия деления
+4. Результат каждой итерации добавить в итоговый результат с помощью пробела
diff --git a/modules/50-loops/80-for-in-range/ru/README.md b/modules/50-loops/80-for-in-range/ru/README.md
new file mode 100644
index 00000000..1f476ea6
--- /dev/null
+++ b/modules/50-loops/80-for-in-range/ru/README.md
@@ -0,0 +1,74 @@
+Представьте, что у нас есть ряд чисел от 0 до 9. Мы хотим сложить эти числа. Мы могли бы сделать это так:
+
+```php
+<?php
+
+$sum = 0;
+$i = 0;
+
+while ($i < 10) {
+    $sum += $i;
+    $i += 1;
+}
+
+print_r($sum); // => 45
+```
+
+Такой код мы можем переписать с помощью цикла `foreach` и функции `range()`:
+
+```php
+<?php
+
+$sum = 0;
+
+foreach (range(0, 9) as $i) {
+    $sum += $i;
+}
+
+print_r($sum); // => 45
+```
+
+Функция `range()` создает последовательность чисел внутри определенного диапазона. Вызов `range(0, 9)` возвращает набор чисел от 0 до 9. А цикл `foreach` перебирает этот набор: на каждой итерации он записывает очередное число в переменную, указанную после ключевого слова `as`, и выполняет тело цикла.
+
+Счетчик при этом не нужен. Цикл `foreach` сам знает, когда нужно остановиться — когда числа в наборе закончатся. Поэтому забыть изменить счетчик и получить бесконечный цикл здесь невозможно.
+
+Функция `range()` поддерживает несколько вариантов вызова. Форма `range(start, end)` создает последовательность от `start` до `end`. Обратите внимание: в PHP конечное значение **входит** в диапазон — во многих других языках это не так. Форма `range(start, end, step)` создает последовательность с шагом `step`.
+
+Наглядно варианты `range()` выглядят так:
+
+```text
+range(1, 5)     →  1, 2, 3, 4, 5
+range(0, 3)     →  0, 1, 2, 3
+range(0, 10, 2) →  0, 2, 4, 6, 8, 10
+                    └── обе границы включены
+```
+
+Пример с суммой мы рассмотрели выше. Рассмотрим другой — распечатаем на экран числа от 1 до 3:
+
+```php
+<?php
+
+foreach (range(1, 3) as $i) {
+    print_r("{$i}\n");
+}
+
+// => 1
+// => 2
+// => 3
+```
+
+Теперь попробуем вывести числа в обратном порядке. Если начало диапазона больше конца, `range()` сам построит убывающую последовательность:
+
+```php
+<?php
+
+foreach (range(3, 1) as $i) {
+    print_r("{$i}\n");
+}
+
+// => 3
+// => 2
+// => 1
+```
+
+Конструкция `foreach` с функцией `range()` — самый короткий способ пройти по диапазону чисел. Когда же нужен полный контроль над счетчиком, например изменение по сложному правилу, на помощь приходят циклы `for` и `while`.
diff --git a/modules/50-loops/80-for-in-range/ru/data.yml b/modules/50-loops/80-for-in-range/ru/data.yml
new file mode 100644
index 00000000..5bfd10a0
--- /dev/null
+++ b/modules/50-loops/80-for-in-range/ru/data.yml
@@ -0,0 +1,6 @@
+---
+name: Цикл foreach и функция range
+tips:
+  - |
+    [range](https://www.php.net/manual/ru/function.range.php)
+definitions: []
diff --git a/modules/70-dates/10-timestamp/Makefile b/modules/50-loops/90-debug/Makefile
similarity index 100%
rename from modules/70-dates/10-timestamp/Makefile
rename to modules/50-loops/90-debug/Makefile
diff --git a/modules/50-loops/90-debug/Solution.php b/modules/50-loops/90-debug/Solution.php
new file mode 100644
index 00000000..dd334e80
--- /dev/null
+++ b/modules/50-loops/90-debug/Solution.php
@@ -0,0 +1,34 @@
+<?php
+
+namespace HexletBasics\Loops\Debug;
+
+// BEGIN
+function compress(string $string): string
+{
+    if ($string === '') {
+        return '';
+    }
+
+    $result = '';
+    $count = 1;
+
+    for ($i = 1; $i < strlen($string); $i += 1) {
+        if ($string[$i] === $string[$i - 1]) {
+            $count += 1;
+        } else {
+            $result .= $string[$i - 1];
+            if ($count > 1) {
+                $result .= $count;
+            }
+            $count = 1;
+        }
+    }
+
+    $result .= $string[-1];
+    if ($count > 1) {
+        $result .= $count;
+    }
+
+    return $result;
+}
+// END
diff --git a/modules/50-loops/90-debug/SolutionTest.php b/modules/50-loops/90-debug/SolutionTest.php
new file mode 100644
index 00000000..e56f2a32
--- /dev/null
+++ b/modules/50-loops/90-debug/SolutionTest.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace HexletBasics\Loops\Debug;
+
+use HexletBasics\Exercise\TestCase;
+
+class SolutionTest extends TestCase
+{
+    public function test()
+    {
+        $this->assertEquals('a3bc4', compress('aaabcccc'));
+        $this->assertEquals('abcd', compress('abcd'));
+        $this->assertEquals('a2b2a2', compress('aabbaa'));
+        $this->assertEquals('a', compress('a'));
+        $this->assertEquals('', compress(''));
+        $this->assertEquals('z3', compress('zzz'));
+    }
+}
diff --git a/modules/50-loops/90-debug/description.es.yml b/modules/50-loops/90-debug/description.es.yml
new file mode 100644
index 00000000..e795ae89
--- /dev/null
+++ b/modules/50-loops/90-debug/description.es.yml
@@ -0,0 +1,153 @@
+---
+
+name: Depuración
+theory: |
+  Incluso los desarrolladores más experimentados rara vez escriben código que funcione perfectamente a la primera. Cuanto más experimentado es un desarrollador, con más confianza lo **depura**, es decir, analiza los errores y los corrige.
+
+  La habilidad de depurar no aparece por sí sola. Hay que desarrollarla, y cuanto antes mejor. A lo largo del aprendizaje realizarás tareas y practicarás, y con el tiempo el análisis de errores se convertirá en un hábito.
+
+  ## Cómo encontrar un error en el código
+
+  Depurar a base de prueba y error lleva mucho tiempo. Es mucho más productivo entender primero qué fue exactamente lo que salió mal y luego eliminar la causa. Todo trabajo con errores comienza con la comprensión.
+
+  En primer lugar, estudia el **mensaje de error**. PHP siempre indica en él el archivo y la línea donde surgió el problema. Por ejemplo:
+
+  ```bash
+  Error: Call to undefined function create() in /code/users.php:5
+  ```
+
+  El mensaje dice que la función `create()` no está definida. Este error suele significar una errata en el nombre. Si tu inglés todavía no es muy bueno, un traductor te ayudará.
+
+  Junto con el mensaje, PHP muestra la **pila de llamadas** (stack trace). Contiene la lista de todas las llamadas a funciones desde el inicio del programa hasta el lugar del error. En ella se ve qué funciones se ejecutaron con éxito y dónde surgieron los problemas. Cada entrada indica el archivo, la línea y la función en ejecución.
+
+  Imagina que escribiste código en el archivo `users.php`: la función `main()` llama a la función `create()`, y la propia llamada a `main()` está en la octava línea. La salida completa del error se verá así:
+
+  ```bash
+  PHP Fatal error:  Uncaught Error: Call to undefined function create() in /code/users.php:5
+  Stack trace:
+  #0 /code/users.php(8): main()
+  #1 {main}
+    thrown in /code/users.php on line 5
+  ```
+
+  Toda la cadena de eventos se ve de inmediato. El programa arrancó (`{main}`), llegó con éxito a `main()` en la octava línea y aquí se topó con un error de nombre en la quinta.
+
+  ## Tipos de errores
+
+  Los errores más comprensibles en PHP se llaman **errores de sintaxis**. Surgen cuando el código está mal formado, por ejemplo por una comilla equivocada o un paréntesis omitido. En la salida siempre aparece `Parse error:`.
+
+  Veamos un ejemplo. Aquí hay un error de sintaxis porque la comilla de apertura `"` no coincide con la de cierre `'`:
+
+  ```bash
+  PHP Parse error:  Unclosed '(' on line 3 in /code/users.php on line 4
+  ```
+
+  El intérprete ni siquiera empieza a ejecutar un programa así: no puede analizarlo.
+
+  Los más difíciles de corregir son los **errores de programación**. Aquí entran la llamada a una función inexistente, el uso de una variable no declarada o el paso de argumentos de tipo incorrecto. Normalmente surgen en un lugar distinto al de la causa real, lo que complica el diagnóstico.
+
+  Contra los que más cuesta luchar es contra los **errores lógicos**. El programa funciona sin fallos, pero produce un resultado incorrecto con algunos datos de entrada. No hay ningún mensaje de error, solo una salida inesperada. Por ejemplo, una función debe calcular la suma, pero calcula la diferencia:
+
+  ```php
+  <?php
+
+  // La función debe calcular la suma de los números, pero calcula la diferencia:
+  function sum(int $a, int $b): int
+  {
+      return $a - $b;
+  }
+
+  // Con esta llamada el error no es evidente, porque
+  // tanto la suma como la resta dan el mismo resultado
+  sum(4, 0); // 4
+  ```
+
+  ## Métodos de depuración
+
+  En la base de cualquier método de depuración está la observación de las variables durante la ejecución. Veamos una función concreta.
+
+  Abajo hay una función que calcula la suma de los números desde `$start` hasta `$finish`. Con `$start = 3` y `$finish = 5` debe calcular `3 + 4 + 5`:
+
+  ```php
+  <?php
+
+  function sumOfSeries(int $start, int $finish): int
+  {
+      $result = 0;
+      $n = $start;
+
+      while ($n < $finish) {
+          $result = $result + $n;
+          $n = $n + 1;
+      }
+
+      return $result;
+  }
+  ```
+
+  Las variables clave de la función son `$n` y `$result`. Para encontrar el error, hay que ver qué valores toman en cada iteración.
+
+  Para esto existen los **depuradores visuales**, como Xdebug. Se integran en los editores de código populares y permiten ejecutar el programa paso a paso, observando las variables en tiempo real. Puedes encontrar uno adecuado buscando «PHP debuggers» en Google.
+
+  En Hexlet, en lugar de un depurador se usa la **impresión de depuración**. El principio es el mismo, solo que los valores de las variables se muestran con un `print_r()` normal. Lo que se imprime aparece en la pestaña `OUTPUT`:
+
+  ```php
+  <?php
+
+  function sumOfSeries(int $start, int $finish): int
+  {
+      $result = 0;
+      $n = $start;
+
+      while ($n < $finish) {
+          print_r("new iteration !!!!\n");
+          print_r("{$n}\n");
+          $result = $result + $n;
+          $n = $n + 1;
+          print_r("{$result}\n");
+      }
+
+      return $result;
+  }
+
+  sumOfSeries(3, 5);
+
+  // => new iteration !!!!
+  // => 3
+  // => 3
+  // => new iteration !!!!
+  // => 4
+  // => 7
+  ```
+
+  La salida muestra que hay una iteración menos de las necesarias. El cinco (`$finish`) no entró en la suma. En la condición está `$n < $finish` en lugar de `$n <= $finish`. Hay que sustituir el signo `<` por `<=`.
+
+  Los desarrolladores principiantes a menudo se disgustan por los errores y se consideran descuidados. Todos cometemos errores, tanto los juniors como los seniors. La diferencia está en con cuánta confianza los encuentras.
+
+  Los principiantes piensan que un buen desarrollador mira el código y entiende de inmediato qué está mal. En la práctica esto rara vez funciona. Un fragmento de código sin contexto dice poco. **Si quieres pedir consejo a un desarrollador experimentado, muéstrale primero el mensaje de error.**
+
+instructions: |
+  Implementa una función `compress()` que comprima una cadena con el método RLE (Run-Length Encoding).
+
+  El algoritmo: si un carácter se repite varias veces seguidas, se sustituye por el carácter y el número de repeticiones. Los caracteres únicos se escriben sin cifra.
+
+  Ejemplos:
+
+  ```php
+  <?php
+
+  compress('aaabcccc'); // 'a3bc4'
+  compress('abcd');     // 'abcd'
+  compress('aabbaa');   // 'a2b2a2'
+  compress('');         // ''
+  ```
+
+  Este algoritmo se usa en formatos reales de compresión de datos — por ejemplo, en los antiguos protocolos de fax y en los archivos BMP.
+
+  ### Algoritmo
+
+  1. Recorrer la cadena contando el número de caracteres idénticos seguidos
+  2. En cuanto el carácter cambie — escribir el carácter anterior y el contador (si es mayor que 1)
+  3. No olvidar procesar el último grupo después de terminar el bucle
+
+tips: []
diff --git a/modules/50-loops/90-debug/en/EXERCISE.md b/modules/50-loops/90-debug/en/EXERCISE.md
new file mode 100644
index 00000000..6d1c3853
--- /dev/null
+++ b/modules/50-loops/90-debug/en/EXERCISE.md
@@ -0,0 +1,23 @@
+
+Implement a function `compress()` that compresses a string using RLE (Run-Length Encoding).
+
+The algorithm: if a character repeats several times in a row, it is replaced with the character and the number of repetitions. Single characters are written without a digit.
+
+Examples:
+
+```php
+<?php
+
+compress('aaabcccc'); // 'a3bc4'
+compress('abcd');     // 'abcd'
+compress('aabbaa');   // 'a2b2a2'
+compress('');         // ''
+```
+
+This algorithm is used in real data compression formats — for example, in old fax protocols and BMP files.
+
+### Algorithm
+
+1. Walk along the string, counting the number of identical characters in a row
+2. As soon as the character changes — write down the previous character and the counter (if greater than 1)
+3. Do not forget to handle the last group after the loop ends
diff --git a/modules/50-loops/90-debug/en/README.md b/modules/50-loops/90-debug/en/README.md
new file mode 100644
index 00000000..74872f84
--- /dev/null
+++ b/modules/50-loops/90-debug/en/README.md
@@ -0,0 +1,123 @@
+Even the most experienced developers rarely write code that works perfectly on the first try. The more experienced a developer is, the more confidently they **debug** it, that is, analyze errors and fix them.
+
+The debugging skill does not appear by itself. It needs to be developed, and as early as possible. As you study, you will complete tasks and practice, and over time, error analysis will become a habit.
+
+## How to find an error in code
+
+Debugging by trial and error takes a lot of time. It is much more productive to first understand what exactly went wrong, and then fix the cause. Any work with errors starts with understanding.
+
+First of all, study the **error message**. PHP always indicates the file and line where the problem occurred. For example:
+
+```bash
+Error: Call to undefined function create() in /code/users.php:5
+```
+
+The message says that the function `create()` is not defined. Such an error most often means a typo in the name. If your English is not great yet, a translator will help.
+
+Along with the message, PHP outputs a **stack trace**. It contains a list of all function calls from the start of the program to the place with the error. It shows which functions completed successfully and where problems occurred. Each entry points to a file, a line, and the function being executed.
+
+Imagine you wrote code in the file `users.php`: the function `main()` calls the function `create()`, and the call to `main()` itself is on line eight. The full error output will look like this:
+
+```bash
+PHP Fatal error:  Uncaught Error: Call to undefined function create() in /code/users.php:5
+Stack trace:
+#0 /code/users.php(8): main()
+#1 {main}
+  thrown in /code/users.php on line 5
+```
+
+The whole chain of events is visible at once. The program started (`{main}`), successfully reached `main()` on line eight, and here it ran into a naming error on line five.
+
+## Types of errors
+
+The most understandable errors in PHP are called **syntax errors**. They occur when the code is formatted incorrectly, for example because of a wrong quote or a missing bracket. The output always contains `Parse error:`.
+
+Let's look at an example. Here there is a syntax error because the opening quote `"` does not match the closing one `'`:
+
+```bash
+PHP Parse error:  Unclosed '(' on line 3 in /code/users.php on line 4
+```
+
+The interpreter does not even start executing such a program — it cannot parse it.
+
+The hardest to fix are **programming errors**. These include calling a non-existent function, using an undeclared variable, and passing arguments of the wrong type. They usually occur in a different place than the real cause, which complicates the diagnosis.
+
+The hardest to fight are **logical errors**. The program runs without failures but produces an incorrect result for some input data. There is no error message, only unexpected output. For example, a function should calculate a sum but calculates a difference:
+
+```php
+<?php
+
+// The function should calculate the sum of numbers but calculates the difference:
+function sum(int $a, int $b): int
+{
+    return $a - $b;
+}
+
+// With this call, the error is not obvious, because
+// both addition and subtraction give the same result
+sum(4, 0); // 4
+```
+
+## Debugging methods
+
+Any debugging method is based on observing variables during execution. Let's look at a specific function.
+
+Below is a function that calculates the sum of numbers from `$start` to `$finish`. With `$start = 3` and `$finish = 5`, it should calculate `3 + 4 + 5`:
+
+```php
+<?php
+
+function sumOfSeries(int $start, int $finish): int
+{
+    $result = 0;
+    $n = $start;
+
+    while ($n < $finish) {
+        $result = $result + $n;
+        $n = $n + 1;
+    }
+
+    return $result;
+}
+```
+
+The key variables in the function are `$n` and `$result`. To find the error, you need to see what values they take on each iteration.
+
+For this, there are **visual debuggers**, such as Xdebug. They integrate into popular code editors and let you run the program step by step, watching the variables in real time. You can find a suitable one by searching for "PHP debuggers" on Google.
+
+On Hexlet, **debug printing** is used instead of a debugger. The principle is the same, only the variable values are printed using a regular `print_r()`. What is printed is shown in the `OUTPUT` tab:
+
+```php
+<?php
+
+function sumOfSeries(int $start, int $finish): int
+{
+    $result = 0;
+    $n = $start;
+
+    while ($n < $finish) {
+        print_r("new iteration !!!!\n");
+        print_r("{$n}\n");
+        $result = $result + $n;
+        $n = $n + 1;
+        print_r("{$result}\n");
+    }
+
+    return $result;
+}
+
+sumOfSeries(3, 5);
+
+// => new iteration !!!!
+// => 3
+// => 3
+// => new iteration !!!!
+// => 4
+// => 7
+```
+
+The output shows that there is one iteration fewer than needed. The five (`$finish`) did not make it into the addition. The condition uses `$n < $finish` instead of `$n <= $finish`. The `<` sign needs to be replaced with `<=`.
+
+Beginner developers often get upset about errors and consider themselves careless. Everyone makes mistakes, both juniors and seniors. The difference is how confidently you find them.
+
+Beginners think that a good developer looks at code and immediately understands what is wrong. This rarely works in practice. A code fragment without context says little. **If you want to ask an experienced developer for advice, show them the error message first.**
diff --git a/modules/50-loops/90-debug/en/data.yml b/modules/50-loops/90-debug/en/data.yml
new file mode 100644
index 00000000..02c70e9e
--- /dev/null
+++ b/modules/50-loops/90-debug/en/data.yml
@@ -0,0 +1,3 @@
+---
+name: Debugging
+tips: []
diff --git a/modules/50-loops/90-debug/es/EXERCISE.md b/modules/50-loops/90-debug/es/EXERCISE.md
new file mode 100644
index 00000000..e0c6567e
--- /dev/null
+++ b/modules/50-loops/90-debug/es/EXERCISE.md
@@ -0,0 +1,23 @@
+
+Implementa una función `compress()` que comprima una cadena con el método RLE (Run-Length Encoding).
+
+El algoritmo: si un carácter se repite varias veces seguidas, se sustituye por el carácter y el número de repeticiones. Los caracteres únicos se escriben sin cifra.
+
+Ejemplos:
+
+```php
+<?php
+
+compress('aaabcccc'); // 'a3bc4'
+compress('abcd');     // 'abcd'
+compress('aabbaa');   // 'a2b2a2'
+compress('');         // ''
+```
+
+Este algoritmo se usa en formatos reales de compresión de datos — por ejemplo, en los antiguos protocolos de fax y en los archivos BMP.
+
+### Algoritmo
+
+1. Recorrer la cadena contando el número de caracteres idénticos seguidos
+2. En cuanto el carácter cambie — escribir el carácter anterior y el contador (si es mayor que 1)
+3. No olvidar procesar el último grupo después de terminar el bucle
diff --git a/modules/50-loops/90-debug/es/README.md b/modules/50-loops/90-debug/es/README.md
new file mode 100644
index 00000000..965c03a0
--- /dev/null
+++ b/modules/50-loops/90-debug/es/README.md
@@ -0,0 +1,123 @@
+Incluso los desarrolladores más experimentados rara vez escriben código que funcione perfectamente a la primera. Cuanto más experimentado es un desarrollador, con más confianza lo **depura**, es decir, analiza los errores y los corrige.
+
+La habilidad de depurar no aparece por sí sola. Hay que desarrollarla, y cuanto antes mejor. A lo largo del aprendizaje realizarás tareas y practicarás, y con el tiempo el análisis de errores se convertirá en un hábito.
+
+## Cómo encontrar un error en el código
+
+Depurar a base de prueba y error lleva mucho tiempo. Es mucho más productivo entender primero qué fue exactamente lo que salió mal y luego eliminar la causa. Todo trabajo con errores comienza con la comprensión.
+
+En primer lugar, estudia el **mensaje de error**. PHP siempre indica en él el archivo y la línea donde surgió el problema. Por ejemplo:
+
+```bash
+Error: Call to undefined function create() in /code/users.php:5
+```
+
+El mensaje dice que la función `create()` no está definida. Este error suele significar una errata en el nombre. Si tu inglés todavía no es muy bueno, un traductor te ayudará.
+
+Junto con el mensaje, PHP muestra la **pila de llamadas** (stack trace). Contiene la lista de todas las llamadas a funciones desde el inicio del programa hasta el lugar del error. En ella se ve qué funciones se ejecutaron con éxito y dónde surgieron los problemas. Cada entrada indica el archivo, la línea y la función en ejecución.
+
+Imagina que escribiste código en el archivo `users.php`: la función `main()` llama a la función `create()`, y la propia llamada a `main()` está en la octava línea. La salida completa del error se verá así:
+
+```bash
+PHP Fatal error:  Uncaught Error: Call to undefined function create() in /code/users.php:5
+Stack trace:
+#0 /code/users.php(8): main()
+#1 {main}
+  thrown in /code/users.php on line 5
+```
+
+Toda la cadena de eventos se ve de inmediato. El programa arrancó (`{main}`), llegó con éxito a `main()` en la octava línea y aquí se topó con un error de nombre en la quinta.
+
+## Tipos de errores
+
+Los errores más comprensibles en PHP se llaman **errores de sintaxis**. Surgen cuando el código está mal formado, por ejemplo por una comilla equivocada o un paréntesis omitido. En la salida siempre aparece `Parse error:`.
+
+Veamos un ejemplo. Aquí hay un error de sintaxis porque la comilla de apertura `"` no coincide con la de cierre `'`:
+
+```bash
+PHP Parse error:  Unclosed '(' on line 3 in /code/users.php on line 4
+```
+
+El intérprete ni siquiera empieza a ejecutar un programa así: no puede analizarlo.
+
+Los más difíciles de corregir son los **errores de programación**. Aquí entran la llamada a una función inexistente, el uso de una variable no declarada o el paso de argumentos de tipo incorrecto. Normalmente surgen en un lugar distinto al de la causa real, lo que complica el diagnóstico.
+
+Contra los que más cuesta luchar es contra los **errores lógicos**. El programa funciona sin fallos, pero produce un resultado incorrecto con algunos datos de entrada. No hay ningún mensaje de error, solo una salida inesperada. Por ejemplo, una función debe calcular la suma, pero calcula la diferencia:
+
+```php
+<?php
+
+// La función debe calcular la suma de los números, pero calcula la diferencia:
+function sum(int $a, int $b): int
+{
+    return $a - $b;
+}
+
+// Con esta llamada el error no es evidente, porque
+// tanto la suma como la resta dan el mismo resultado
+sum(4, 0); // 4
+```
+
+## Métodos de depuración
+
+En la base de cualquier método de depuración está la observación de las variables durante la ejecución. Veamos una función concreta.
+
+Abajo hay una función que calcula la suma de los números desde `$start` hasta `$finish`. Con `$start = 3` y `$finish = 5` debe calcular `3 + 4 + 5`:
+
+```php
+<?php
+
+function sumOfSeries(int $start, int $finish): int
+{
+    $result = 0;
+    $n = $start;
+
+    while ($n < $finish) {
+        $result = $result + $n;
+        $n = $n + 1;
+    }
+
+    return $result;
+}
+```
+
+Las variables clave de la función son `$n` y `$result`. Para encontrar el error, hay que ver qué valores toman en cada iteración.
+
+Para esto existen los **depuradores visuales**, como Xdebug. Se integran en los editores de código populares y permiten ejecutar el programa paso a paso, observando las variables en tiempo real. Puedes encontrar uno adecuado buscando «PHP debuggers» en Google.
+
+En Hexlet, en lugar de un depurador se usa la **impresión de depuración**. El principio es el mismo, solo que los valores de las variables se muestran con un `print_r()` normal. Lo que se imprime aparece en la pestaña `OUTPUT`:
+
+```php
+<?php
+
+function sumOfSeries(int $start, int $finish): int
+{
+    $result = 0;
+    $n = $start;
+
+    while ($n < $finish) {
+        print_r("new iteration !!!!\n");
+        print_r("{$n}\n");
+        $result = $result + $n;
+        $n = $n + 1;
+        print_r("{$result}\n");
+    }
+
+    return $result;
+}
+
+sumOfSeries(3, 5);
+
+// => new iteration !!!!
+// => 3
+// => 3
+// => new iteration !!!!
+// => 4
+// => 7
+```
+
+La salida muestra que hay una iteración menos de las necesarias. El cinco (`$finish`) no entró en la suma. En la condición está `$n < $finish` en lugar de `$n <= $finish`. Hay que sustituir el signo `<` por `<=`.
+
+Los desarrolladores principiantes a menudo se disgustan por los errores y se consideran descuidados. Todos cometemos errores, tanto los juniors como los seniors. La diferencia está en con cuánta confianza los encuentras.
+
+Los principiantes piensan que un buen desarrollador mira el código y entiende de inmediato qué está mal. En la práctica esto rara vez funciona. Un fragmento de código sin contexto dice poco. **Si quieres pedir consejo a un desarrollador experimentado, muéstrale primero el mensaje de error.**
diff --git a/modules/50-loops/90-debug/es/data.yml b/modules/50-loops/90-debug/es/data.yml
new file mode 100644
index 00000000..090be8be
--- /dev/null
+++ b/modules/50-loops/90-debug/es/data.yml
@@ -0,0 +1,3 @@
+---
+name: Depuración
+tips: []
diff --git a/modules/50-loops/90-debug/ru/EXERCISE.md b/modules/50-loops/90-debug/ru/EXERCISE.md
new file mode 100644
index 00000000..4fc41b3f
--- /dev/null
+++ b/modules/50-loops/90-debug/ru/EXERCISE.md
@@ -0,0 +1,23 @@
+
+Реализуйте функцию `compress()`, которая сжимает строку методом RLE (Run-Length Encoding).
+
+Алгоритм: если символ повторяется несколько раз подряд, он заменяется на символ и количество повторений. Одиночные символы записываются без цифры.
+
+Примеры:
+
+```php
+<?php
+
+compress('aaabcccc'); // 'a3bc4'
+compress('abcd');     // 'abcd'
+compress('aabbaa');   // 'a2b2a2'
+compress('');         // ''
+```
+
+Этот алгоритм используется в реальных форматах сжатия данных — например, в старых факс-протоколах и BMP-файлах.
+
+### Алгоритм
+
+1. Идти по строке, считая количество подряд идущих одинаковых символов
+2. Как только символ меняется — записать предыдущий символ и счетчик (если больше 1)
+3. Не забыть обработать последнюю группу после окончания цикла
diff --git a/modules/50-loops/90-debug/ru/README.md b/modules/50-loops/90-debug/ru/README.md
new file mode 100644
index 00000000..315bfc1b
--- /dev/null
+++ b/modules/50-loops/90-debug/ru/README.md
@@ -0,0 +1,123 @@
+Даже у самых опытных разработчиков код редко работает идеально с первого раза. Чем опытнее разработчик, тем увереннее он **отлаживает** его, то есть анализирует ошибки и устраняет их.
+
+Навык отладки сам по себе не появится. Его нужно развивать, причем как можно раньше. По ходу обучения вы будете выполнять задания и практиковаться, и со временем анализ ошибок войдет в привычку.
+
+## Как найти ошибку в коде
+
+Отладка методом тыка занимает много времени. Гораздо продуктивнее сначала понять, что именно пошло не так, а потом устранять причину. С понимания начинается любая работа с ошибками.
+
+Первым делом изучите **сообщение об ошибке**. PHP всегда указывает в нем файл и строчку, где возникла проблема. Например:
+
+```bash
+Error: Call to undefined function create() in /code/users.php:5
+```
+
+Сообщение говорит, что функция `create()` не определена. Такая ошибка чаще всего означает опечатку в имени. Если английский еще не очень, поможет переводчик.
+
+Вместе с сообщением PHP выводит **стек вызовов** (stack trace). Он содержит список всех вызовов функций от старта программы до места с ошибкой. По нему видно, какие функции выполнились успешно, а где возникли проблемы. Каждая запись указывает на файл, строчку и выполняемую функцию.
+
+Представим, что вы написали код в файле `users.php`: функция `main()` вызывает функцию `create()`, а сам вызов `main()` находится на восьмой строчке. Полный вывод ошибки будет выглядеть так:
+
+```bash
+PHP Fatal error:  Uncaught Error: Call to undefined function create() in /code/users.php:5
+Stack trace:
+#0 /code/users.php(8): main()
+#1 {main}
+  thrown in /code/users.php on line 5
+```
+
+Вся цепочка событий видна сразу. Программа стартовала (`{main}`), успешно дошла до `main()` на восьмой строчке и здесь столкнулась с ошибкой в названии на пятой.
+
+## Типы ошибок
+
+Самые понятные ошибки в PHP называются **синтаксическими**. Они возникают, когда код оформлен неверно, например из-за не той кавычки или пропущенной скобки. В выводе всегда присутствует `Parse error:`.
+
+Посмотрим на пример. Здесь синтаксическая ошибка из-за того, что открывающая кавычка `"` не совпадает с закрывающей `'`:
+
+```bash
+PHP Parse error:  Unclosed '(' on line 3 in /code/users.php on line 4
+```
+
+Интерпретатор даже не начинает выполнять такую программу — он не может ее разобрать.
+
+Труднее всего исправлять **ошибки программирования**. Сюда входят вызов несуществующей функции, использование необъявленной переменной, передача аргументов неверного типа. Обычно они возникают не в том месте, где настоящая причина, что и усложняет диагностику.
+
+Сложнее всего бороться с **логическими ошибками**. Программа работает без сбоев, но выдает неверный результат при некоторых входных данных. Никакого сообщения об ошибке нет, только неожиданный вывод. Например, функция должна считать сумму, но считает разность:
+
+```php
+<?php
+
+// Функция должна считать сумму чисел, но считает разность:
+function sum(int $a, int $b): int
+{
+    return $a - $b;
+}
+
+// При таком вызове ошибка неочевидна, потому что
+// и при сложении, и при вычитании будет один и тот же результат
+sum(4, 0); // 4
+```
+
+## Способы отладки
+
+В основе любого метода отладки лежит наблюдение за переменными в процессе выполнения. Посмотрим на конкретную функцию.
+
+Ниже функция, которая считает сумму чисел от `$start` до `$finish`. При `$start = 3` и `$finish = 5` она должна вычислить `3 + 4 + 5`:
+
+```php
+<?php
+
+function sumOfSeries(int $start, int $finish): int
+{
+    $result = 0;
+    $n = $start;
+
+    while ($n < $finish) {
+        $result = $result + $n;
+        $n = $n + 1;
+    }
+
+    return $result;
+}
+```
+
+В функции ключевые переменные `$n` и `$result`. Чтобы найти ошибку, нужно посмотреть, какие значения они принимают на каждой итерации.
+
+Для этого существуют **визуальные отладчики**, например Xdebug. Они встраиваются в популярные редакторы кода и позволяют выполнить программу по шагам, наблюдая за переменными в реальном времени. Найти подходящий можно по запросу «PHP debuggers» в Google.
+
+На Хекслете вместо отладчика используется **отладочная печать**. Принцип тот же, только значения переменных выводятся через обычный `print_r()`. То, что печатается, отображается во вкладке `OUTPUT`:
+
+```php
+<?php
+
+function sumOfSeries(int $start, int $finish): int
+{
+    $result = 0;
+    $n = $start;
+
+    while ($n < $finish) {
+        print_r("new iteration !!!!\n");
+        print_r("{$n}\n");
+        $result = $result + $n;
+        $n = $n + 1;
+        print_r("{$result}\n");
+    }
+
+    return $result;
+}
+
+sumOfSeries(3, 5);
+
+// => new iteration !!!!
+// => 3
+// => 3
+// => new iteration !!!!
+// => 4
+// => 7
+```
+
+Вывод показывает, что итераций на одну меньше, чем нужно. Пятерка (`$finish`) в сложение не попала. В условии стоит `$n < $finish` вместо `$n <= $finish`. Нужно заменить знак `<` на `<=`.
+
+Начинающие разработчики часто расстраиваются из-за ошибок и считают себя невнимательными. Ошибки есть у всех, и у джунов, и у сеньоров. Разница в том, насколько уверенно ты их находишь.
+
+Начинающие думают, что хороший разработчик смотрит на код и сразу понимает, что не так. Это редко работает на практике. Фрагмент кода без контекста мало что говорит. **Если хотите попросить совет у опытного разработчика, первым делом покажите сообщение об ошибке.**
diff --git a/modules/70-dates/10-timestamp/es/data.yml b/modules/50-loops/90-debug/ru/data.yml
similarity index 58%
rename from modules/70-dates/10-timestamp/es/data.yml
rename to modules/50-loops/90-debug/ru/data.yml
index e9c93f1e..32222bd2 100644
--- a/modules/70-dates/10-timestamp/es/data.yml
+++ b/modules/50-loops/90-debug/ru/data.yml
@@ -1,4 +1,4 @@
 ---
-name: Tiempo
+name: Отладка
 tips: []
 definitions: []
diff --git a/modules/60-deep-into-strings/10-unicode/SolutionTest.php b/modules/60-deep-into-strings/10-unicode/SolutionTest.php
deleted file mode 100644
index 93e8d94b..00000000
--- a/modules/60-deep-into-strings/10-unicode/SolutionTest.php
+++ /dev/null
@@ -1,17 +0,0 @@
-<?php
-
-namespace HexletBasics\DeepIntoStrings\Unicode;
-
-use PHPUnit\Framework\TestCase;
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        require 'index.php';
-        $this->assertEquals('ONE', invertCase('one'));
-        $this->assertEquals('two', invertCase('TWO'));
-        $this->assertEquals('tHrEE', invertCase('ThRee'));
-        $this->assertEquals('пРиВеТ!', invertCase('ПрИвЕт!'));
-    }
-}
diff --git a/modules/60-deep-into-strings/10-unicode/index.php b/modules/60-deep-into-strings/10-unicode/index.php
deleted file mode 100644
index 6bdada65..00000000
--- a/modules/60-deep-into-strings/10-unicode/index.php
+++ /dev/null
@@ -1,22 +0,0 @@
-<?php
-
-namespace HexletBasics\DeepIntoStrings\Unicode;
-
-function invertCase($text)
-{
-    // BEGIN
-    $len = mb_strlen($text);
-    $result = '';
-    for ($i = 0; $i < $len; $i++) {
-        $symbol = mb_substr($text, $i, 1);
-        $lowerSymbol = mb_strtolower($symbol);
-        if ($symbol === $lowerSymbol) {
-            $result .= mb_strtoupper($symbol);
-        } else {
-            $result .= $lowerSymbol;
-        }
-    }
-
-    return $result;
-    // END
-}
diff --git a/modules/60-deep-into-strings/10-unicode/ru/EXERCISE.md b/modules/60-deep-into-strings/10-unicode/ru/EXERCISE.md
deleted file mode 100644
index cea71a8f..00000000
--- a/modules/60-deep-into-strings/10-unicode/ru/EXERCISE.md
+++ /dev/null
@@ -1,9 +0,0 @@
-
-Допишите реализацию функции `invertCase()`, которая инвертирует регистр каждого символа в переданной строке.
-
-```php
-<?php
-
-$str = 'ПрИвЕт!';
-invertCase($str); // пРиВеТ!
-```
diff --git a/modules/60-deep-into-strings/40-startwith/SolutionTest.php b/modules/60-deep-into-strings/40-startwith/SolutionTest.php
deleted file mode 100644
index e93912fd..00000000
--- a/modules/60-deep-into-strings/40-startwith/SolutionTest.php
+++ /dev/null
@@ -1,17 +0,0 @@
-<?php
-
-namespace HexletBasics\DeepIntoStrings\StartWith;
-
-use PHPUnit\Framework\TestCase;
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        require 'index.php';
-        $this->assertTrue(startsWith('one', 'o'));
-        $this->assertFalse(startsWith('one', 'ne'));
-        $this->assertTrue(startsWith('one', 'on'));
-        $this->assertTrue(startsWith('one', 'one'));
-    }
-}
diff --git a/modules/60-deep-into-strings/40-startwith/index.php b/modules/60-deep-into-strings/40-startwith/index.php
deleted file mode 100644
index de0d888c..00000000
--- a/modules/60-deep-into-strings/40-startwith/index.php
+++ /dev/null
@@ -1,10 +0,0 @@
-<?php
-
-namespace HexletBasics\DeepIntoStrings\StartWith;
-
-function startsWith($text, $substr)
-{
-    // BEGIN
-    return mb_strpos($text, $substr) === 0;
-    // END
-}
diff --git a/modules/60-deep-into-strings/40-startwith/ru/EXERCISE.md b/modules/60-deep-into-strings/40-startwith/ru/EXERCISE.md
deleted file mode 100644
index 1e97feb6..00000000
--- a/modules/60-deep-into-strings/40-startwith/ru/EXERCISE.md
+++ /dev/null
@@ -1,8 +0,0 @@
-Допишите реализацию функции `startsWith()`, которая определяет, начинается ли строка с подстроки.
-
-```php
-<?php
-
-startsWith('Хекслет', 'ет'); // false
-startsWith('Хекслет', 'Хек'); // true
-```
diff --git a/modules/60-deep-into-strings/40-startwith/ru/README.md b/modules/60-deep-into-strings/40-startwith/ru/README.md
deleted file mode 100644
index 9e502fe9..00000000
--- a/modules/60-deep-into-strings/40-startwith/ru/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
-Часто в работе со строками нужно определить, является ли одна строка **подстрокой** — частью другой строки. В большинстве языков программирования есть встроенная функция, предназначенная именно для этой задачи.
-
-В PHP такая функция появилась лишь в восьмой версии. До этого ее имитировали с помощью функции [mb_strpos()](https://php.net/manual/ru/function.mb-strpos.php). Эта функция ищет позицию первого вхождения одной строки в другую. Пока мы будем использовать именно `mb_strpos()`:
-
-```php
-<?php
-
-if (mb_strpos('Валар Моргулис', 'Моргулис')) { // 6
-    // ...
-}
-```
-
-В примере выше функция вернет 6, что соответствует индексу буквы М:
-
-```php
-<?php
-
-if (mb_strpos('Валар Моргулис', 'Валар')) { // 0
-    // ...
-}
-```
-
-А в этом примере вернется `0`, что соответствует первой букве строки. В этом коде скрыта ошибка, которую часто допускают новички. В PHP `0` рассматривается, как `false` — значит, условие не выполнится. Правильная проверка выглядит так:
-
-```php
-<?php
-
-if (mb_strpos('Валар Моргулис', 'Валар') !== false) {
-    // ...
-}
-```
-
-Функция `mb_strpos()` возвращает `false`, если подстрока не была найдена. Значит, можно воспользоваться строгим сравнением с `false`.
diff --git a/modules/60-deep-into-strings/description.en.yml b/modules/60-deep-into-strings/description.en.yml
deleted file mode 100644
index 04003d39..00000000
--- a/modules/60-deep-into-strings/description.en.yml
+++ /dev/null
@@ -1,5 +0,0 @@
----
-
-name: Diving into the lines
-description: |
-  СModern string encoding and handling of strings in PHP using functions for multi-byte encodings. Localization.
diff --git a/modules/60-deep-into-strings/description.es.yml b/modules/60-deep-into-strings/description.es.yml
deleted file mode 100644
index eb7c2744..00000000
--- a/modules/60-deep-into-strings/description.es.yml
+++ /dev/null
@@ -1,5 +0,0 @@
----
-
-name: Sumergiéndose en las cadenas
-description: |
-  Codificación moderna de cadenas y su manipulación en PHP utilizando funciones para codificaciones multibyte. Localización.
diff --git a/modules/60-deep-into-strings/description.ru.yml b/modules/60-deep-into-strings/description.ru.yml
deleted file mode 100644
index 682536f6..00000000
--- a/modules/60-deep-into-strings/description.ru.yml
+++ /dev/null
@@ -1,5 +0,0 @@
----
-
-name: Погружаясь в строки
-description: |
-  Современное кодирование строк и работа с ними в PHP, используя функции для многобайтовых кодировок. Локализация.
diff --git a/modules/70-dates/10-timestamp/SolutionTest.php b/modules/70-dates/10-timestamp/SolutionTest.php
deleted file mode 100644
index 5067c572..00000000
--- a/modules/70-dates/10-timestamp/SolutionTest.php
+++ /dev/null
@@ -1,17 +0,0 @@
-<?php
-
-namespace HexletBasics\Dates\Timestamp;
-
-use PHPUnit\Framework\TestCase;
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        require 'index.php';
-
-        $this->assertEquals(2018, getYear(1532435204));
-        $this->assertEquals(1986, getYear(532435204));
-        $this->assertEquals(1970, getYear(5324352));
-    }
-}
diff --git a/modules/70-dates/10-timestamp/description.es.yml b/modules/70-dates/10-timestamp/description.es.yml
deleted file mode 100644
index 31192b3f..00000000
--- a/modules/70-dates/10-timestamp/description.es.yml
+++ /dev/null
@@ -1,43 +0,0 @@
----
-
-name: Tiempo
-theory: |
-  ¿Alguna vez te has preguntado cómo se almacena el tiempo en una computadora? En esta lección discutiremos cómo funcionan el tiempo y la fecha, y dónde se almacenan.
-
-  ## Tiempo
-
-  Como sabes, encender y apagar la computadora no afecta los relojes. Podemos concluir que los relojes en la computadora funcionan por sí mismos.
-
-  Esto es realmente cierto. Los relojes principales de la computadora son **hardware**. Viven una vida independiente y tienen su propia batería. Al encender la computadora, lee los datos de estos relojes, los guarda en la memoria y comienza a contar el tiempo de forma independiente. Estos relojes se llaman **sistema**. Cualquier cambio en los relojes del sistema también afecta a los relojes de hardware.
-
-  En Linux, Unix, MacOS y la mayoría de otros sistemas operativos, el tiempo del sistema se representa en formato _Unix Time_. Se define como la cantidad de segundos transcurridos desde este momento:
-
-  > 00:00:00 UTC 1 de enero de 1970 (jueves)
-
-  El tiempo desde este momento se llama "época de Unix" (_Unix Epoch_). El tiempo Unix se representa como un número entero que aumenta con cada segundo transcurrido, sin necesidad de cálculos para determinar el año, mes, día, hora o minuto.
-
-  Una fecha específica en formato Unix Time se llama **timestamp** - sello de tiempo. Por ejemplo, para obtener el _timestamp_ actual en PHP, se utiliza la función `time()`:
-
-  ```php
-  <?php
-
-  time(); // 1532435204
-  ```
-
-instructions: |
-  Completa la implementación de la función `getYear()`, que devuelve el año del timestamp proporcionado:
-
-  Ejemplos de uso:
-
-  ```php
-  <?php
-
-  getYear(1532435204); // 2018
-  ```
-
-  * Para redondear hacia abajo, utiliza la función [floor()](https://php.net/manual/es/function.floor.php)
-  * No olvides convertir el número resultante a tipo `int`
-
-tips: []
-
-definitions: []
diff --git a/modules/70-dates/10-timestamp/en/EXERCISE.md b/modules/70-dates/10-timestamp/en/EXERCISE.md
deleted file mode 100644
index af109302..00000000
--- a/modules/70-dates/10-timestamp/en/EXERCISE.md
+++ /dev/null
@@ -1,13 +0,0 @@
-
-Complete the implementation of the `getYear()` function, which returns the year of the timestamp passed:
-
-Call examples:
-
-```php
-<?php
-
-getYear(1532435204); // 2018
-```
-
-* To round down, use the  [floor()](https://www.php.net/manual/en/function.floor.php)
-* Don't forget to convert the resulting number to the `int` type
diff --git a/modules/70-dates/10-timestamp/en/README.md b/modules/70-dates/10-timestamp/en/README.md
deleted file mode 100644
index 487d87ea..00000000
--- a/modules/70-dates/10-timestamp/en/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
-
-Have you ever wondered how time is stored in a computer? Turning the computer on and off has no effect on the clock. We can there conclude that the clock in the computer works by itself.
-
-This is very much the case. The computer's main clock is a hardware clock, it lives its own life and has its own battery. When you turn on the computer, it reads the data from this clock, writes it to its memory and starts counting the time itself. This clock is called a system clock. Any change in the system clock will also affect the hardware clock.
-
-In most operating systems (Linux, Unix, MacOS) the system time is presented in Unix time format. It's defined as the number of seconds elapsed since midnight (00:00:00 UTC) on January 1, 1970 (Thursday). The time since then is called the "Unix Epoch". Unix time is represented by an integer number which is incremented with each passing second without needing calculations to determine the year, month, day, hour or minute, which is easy for people to understand.
-
-A specific date in Unix time format is called a timestamp. For example, PHP uses the `time()` function to get the current timestamp.
-
-```php
-<?php
-
-time(); // 1532435204
-```
diff --git a/modules/70-dates/10-timestamp/en/data.yml b/modules/70-dates/10-timestamp/en/data.yml
deleted file mode 100644
index 3bed1b0b..00000000
--- a/modules/70-dates/10-timestamp/en/data.yml
+++ /dev/null
@@ -1,2 +0,0 @@
----
-name: Time
diff --git a/modules/70-dates/10-timestamp/es/EXERCISE.md b/modules/70-dates/10-timestamp/es/EXERCISE.md
deleted file mode 100644
index 77dda366..00000000
--- a/modules/70-dates/10-timestamp/es/EXERCISE.md
+++ /dev/null
@@ -1,12 +0,0 @@
-Completa la implementación de la función `getYear()`, que devuelve el año del timestamp proporcionado:
-
-Ejemplos de uso:
-
-```php
-<?php
-
-getYear(1532435204); // 2018
-```
-
-* Para redondear hacia abajo, utiliza la función [floor()](https://php.net/manual/es/function.floor.php)
-* No olvides convertir el número resultante a tipo `int`
diff --git a/modules/70-dates/10-timestamp/es/README.md b/modules/70-dates/10-timestamp/es/README.md
deleted file mode 100644
index a23dd31e..00000000
--- a/modules/70-dates/10-timestamp/es/README.md
+++ /dev/null
@@ -1,21 +0,0 @@
-¿Alguna vez te has preguntado cómo se almacena el tiempo en una computadora? En esta lección discutiremos cómo funcionan el tiempo y la fecha, y dónde se almacenan.
-
-## Tiempo
-
-Como sabes, encender y apagar la computadora no afecta los relojes. Podemos concluir que los relojes en la computadora funcionan por sí mismos.
-
-Esto es realmente cierto. Los relojes principales de la computadora son **hardware**. Viven una vida independiente y tienen su propia batería. Al encender la computadora, lee los datos de estos relojes, los guarda en la memoria y comienza a contar el tiempo de forma independiente. Estos relojes se llaman **sistema**. Cualquier cambio en los relojes del sistema también afecta a los relojes de hardware.
-
-En Linux, Unix, MacOS y la mayoría de otros sistemas operativos, el tiempo del sistema se representa en formato _Unix Time_. Se define como la cantidad de segundos transcurridos desde este momento:
-
-> 00:00:00 UTC 1 de enero de 1970 (jueves)
-
-El tiempo desde este momento se llama "época de Unix" (_Unix Epoch_). El tiempo Unix se representa como un número entero que aumenta con cada segundo transcurrido, sin necesidad de cálculos para determinar el año, mes, día, hora o minuto.
-
-Una fecha específica en formato Unix Time se llama **timestamp** - sello de tiempo. Por ejemplo, para obtener el _timestamp_ actual en PHP, se utiliza la función `time()`:
-
-```php
-<?php
-
-time(); // 1532435204
-```
diff --git a/modules/70-dates/10-timestamp/index.php b/modules/70-dates/10-timestamp/index.php
deleted file mode 100644
index 325d8935..00000000
--- a/modules/70-dates/10-timestamp/index.php
+++ /dev/null
@@ -1,12 +0,0 @@
-<?php
-
-namespace HexletBasics\Dates\Timestamp;
-
-const SECONDS_IN_YEAR = 60 * 60 * 24 * 365;
-
-function getYear($timestamp)
-{
-    // BEGIN
-    return 1970 + (int) floor($timestamp / SECONDS_IN_YEAR);
-    // END
-}
diff --git a/modules/70-dates/10-timestamp/ru/EXERCISE.md b/modules/70-dates/10-timestamp/ru/EXERCISE.md
deleted file mode 100644
index 4679b348..00000000
--- a/modules/70-dates/10-timestamp/ru/EXERCISE.md
+++ /dev/null
@@ -1,12 +0,0 @@
-Допишите реализацию функции `getYear()`, которая возвращает год переданного timestamp:
-
-Примеры вызова:
-
-```php
-<?php
-
-getYear(1532435204); // 2018
-```
-
-* Для округления в нижнюю сторону воспользуйтесь функцией [floor()](https://php.net/manual/ru/function.floor.php)
-* Не забудьте потом привести получившееся число к типу `int`
diff --git a/modules/70-dates/10-timestamp/ru/README.md b/modules/70-dates/10-timestamp/ru/README.md
deleted file mode 100644
index f868451d..00000000
--- a/modules/70-dates/10-timestamp/ru/README.md
+++ /dev/null
@@ -1,21 +0,0 @@
-Вы когда-нибудь задумывались о том, как хранится в компьютере время? В этом уроке мы обсудим, как работают время и дата и где они хранятся.
-
-## Время
-
-Как вы знаете, включение и выключение компьютера никак не влияет на часы. Можно сделать вывод, что часы в компьютере работают сами по себе.
-
-Это действительно так. Основные часы компьютера — **аппаратные**. Они живут самостоятельной жизнью и имеют свою собственную батарею. При включении компьютер считывает данные этих часов, записывает к себе в память и начинает самостоятельно отсчитывать время. Эти часы называются **системными**. Любое изменение системных часов влияет и на аппаратные.
-
-В Linux, Unix, MacOS и большинстве других операционных систем системное время представляется в формате _Unix Time_. Оно определяется как количество секунд, прошедших с этого момента:
-
-> 00:00:00 UTC 1 января 1970 года (четверг)
-
-Время с этого момента называют «эрой Unix» (_Unix Epoch_). Unix-время представлено целым числом, которое увеличивается с каждой прошедшей секундой без необходимости вычислений для определения года, месяца, дня, часа или минуты.
-
-Конкретная дата в формате Unix Time называется **timestamp** — временной штамп. Например, для получения текущего _timestamp_ в PHP используется функция `time()`:
-
-```php
-<?php
-
-time(); // 1532435204
-```
diff --git a/modules/70-dates/10-timestamp/ru/data.yml b/modules/70-dates/10-timestamp/ru/data.yml
deleted file mode 100644
index 420eb1ad..00000000
--- a/modules/70-dates/10-timestamp/ru/data.yml
+++ /dev/null
@@ -1,4 +0,0 @@
----
-name: Время
-tips: []
-definitions: []
diff --git a/modules/70-dates/20-date/Makefile b/modules/70-dates/20-date/Makefile
deleted file mode 100644
index d0d0a48c..00000000
--- a/modules/70-dates/20-date/Makefile
+++ /dev/null
@@ -1,2 +0,0 @@
-test:
-	@ test.sh
diff --git a/modules/70-dates/20-date/SolutionTest.php b/modules/70-dates/20-date/SolutionTest.php
deleted file mode 100644
index 2c3dae9a..00000000
--- a/modules/70-dates/20-date/SolutionTest.php
+++ /dev/null
@@ -1,17 +0,0 @@
-<?php
-
-namespace HexletBasics\Dates\DateFunction;
-
-use PHPUnit\Framework\TestCase;
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        require 'index.php';
-
-        $this->assertEquals('24/07/2018', getCustomDate(1532435204));
-        $this->assertEquals('15/11/1986', getCustomDate(532435204));
-        $this->assertEquals('03/03/1970', getCustomDate(5324352));
-    }
-}
diff --git a/modules/70-dates/20-date/description.es.yml b/modules/70-dates/20-date/description.es.yml
deleted file mode 100644
index ee6e6857..00000000
--- a/modules/70-dates/20-date/description.es.yml
+++ /dev/null
@@ -1,49 +0,0 @@
----
-
-name: Fecha
-theory: |
-  Una de las principales funciones para trabajar con fechas en PHP es [date()](https://php.net/manual/ru/function.date.php). Convierte una marca de tiempo (_timestamp_) en un formato legible por humanos.
-
-  El primer parámetro de esta función es una descripción del formato de fecha, similar a los formatos utilizados en la función [sprintf()](https://php.net/manual/ru/function.sprintf.php):
-
-  ```php
-  <?php
-
-  // Y representa el año
-  date('Y'); // 2018
-  ```
-
-  Por defecto, `date()` utiliza la hora actual. Sin embargo, se puede pasar un _timestamp_ específico si es necesario:
-
-  ```php
-  <?php
-
-  date('M', 123123123); // Nov
-  ```
-
-  Hay docenas de opciones de formato en la función `date()`. Todas ellas se enumeran detalladamente en la página de documentación. No es necesario memorizarlas todas, pero es útil entender el principio de funcionamiento general. Todas las opciones se pueden combinar de diversas formas:
-
-  ```php
-  <?php
-
-  date('l jS \of F Y h:i:s A'); // jueves 26 de julio de 2018 10:58:55 AM
-  ```
-
-instructions: |
-  Complete la implementación de la función `getCustomDate()`, que devuelve una fecha en el formato `15/03/1985` basada en el _timestamp_ proporcionado.
-
-  Ejemplos de uso:
-
-  ```php
-  <?php
-
-  getCustomDate(1532435204); // 24/07/2018;
-  getCustomDate(532435204);  // 15/11/1986;
-  getCustomDate(5324352);    // 03/03/1970;
-  ```
-
-tips:
-  - |
-    [Ejemplos de formatos de fecha](https://www.php.net/manual/ru/datetime.format.php)
-
-definitions: []
diff --git a/modules/70-dates/20-date/en/EXERCISE.md b/modules/70-dates/20-date/en/EXERCISE.md
deleted file mode 100644
index cd2d3ff7..00000000
--- a/modules/70-dates/20-date/en/EXERCISE.md
+++ /dev/null
@@ -1,12 +0,0 @@
-
-Write an implementation of the `getCustomDate()` function that returns the date in the format `15/03/1985` based on the timestamp passed.
-
-Call examples:
-
-```php
-<?php
-
-getCustomDate(1532435204); // 24/07/2018;
-getCustomDate(532435204);  // 15/11/1986;
-getCustomDate(5324352);    // 03/03/1970;
-```
diff --git a/modules/70-dates/20-date/en/README.md b/modules/70-dates/20-date/en/README.md
deleted file mode 100644
index e512dd3e..00000000
--- a/modules/70-dates/20-date/en/README.md
+++ /dev/null
@@ -1,25 +0,0 @@
-
-One of the main date functions in PHP is [date()](https://www.php.net/manual/en/function.date.php). It converts the timestamp to a human-readable format. The first parameter you need to pass to this function is the date format, which is arranged similarly to the formats for [sprintf()](https://www.php.net/manual/en/function.sprintf.php).
-
-```php
-<?php
-
-// Y means year
-date('Y'); // 2018
-```
-
-`date()` uses the current time by default. But if necessary, you can pass it a specific timestamp.
-
-```php
-<?php
-
-date('M', 123123123); // Nov
-```
-
-There are dozens of different formatting options in the `date()` function. They're all listed in detail on the documentation page. It's not at all necessary to memorize them all, but it's useful to understand the general principle of how it should work. All options can be combined with each other in any variation.
-
-```php
-<?php
-
-date('l jS \of F Y h:i:s A'); // Thursday 26th of July 2018 10:58:55 AM
-```
diff --git a/modules/70-dates/20-date/en/data.yml b/modules/70-dates/20-date/en/data.yml
deleted file mode 100644
index fb6ef877..00000000
--- a/modules/70-dates/20-date/en/data.yml
+++ /dev/null
@@ -1,6 +0,0 @@
----
-name: Date
-tips:
-  - >
-    [Examples of date
-    formats](https://www.php.net/manual/en/datetime.format.php)
diff --git a/modules/70-dates/20-date/es/EXERCISE.md b/modules/70-dates/20-date/es/EXERCISE.md
deleted file mode 100644
index c0a40093..00000000
--- a/modules/70-dates/20-date/es/EXERCISE.md
+++ /dev/null
@@ -1,11 +0,0 @@
-Complete la implementación de la función `getCustomDate()`, que devuelve una fecha en el formato `15/03/1985` basada en el _timestamp_ proporcionado.
-
-Ejemplos de uso:
-
-```php
-<?php
-
-getCustomDate(1532435204); // 24/07/2018;
-getCustomDate(532435204);  // 15/11/1986;
-getCustomDate(5324352);    // 03/03/1970;
-```
diff --git a/modules/70-dates/20-date/es/README.md b/modules/70-dates/20-date/es/README.md
deleted file mode 100644
index d11d1113..00000000
--- a/modules/70-dates/20-date/es/README.md
+++ /dev/null
@@ -1,26 +0,0 @@
-Una de las principales funciones para trabajar con fechas en PHP es [date()](https://php.net/manual/ru/function.date.php). Convierte una marca de tiempo (_timestamp_) en un formato legible por humanos.
-
-El primer parámetro de esta función es una descripción del formato de fecha, similar a los formatos utilizados en la función [sprintf()](https://php.net/manual/ru/function.sprintf.php):
-
-```php
-<?php
-
-// Y representa el año
-date('Y'); // 2018
-```
-
-Por defecto, `date()` utiliza la hora actual. Sin embargo, se puede pasar un _timestamp_ específico si es necesario:
-
-```php
-<?php
-
-date('M', 123123123); // Nov
-```
-
-Hay docenas de opciones de formato en la función `date()`. Todas ellas se enumeran detalladamente en la página de documentación. No es necesario memorizarlas todas, pero es útil entender el principio de funcionamiento general. Todas las opciones se pueden combinar de diversas formas:
-
-```php
-<?php
-
-date('l jS \of F Y h:i:s A'); // jueves 26 de julio de 2018 10:58:55 AM
-```
diff --git a/modules/70-dates/20-date/es/data.yml b/modules/70-dates/20-date/es/data.yml
deleted file mode 100644
index 48a8c517..00000000
--- a/modules/70-dates/20-date/es/data.yml
+++ /dev/null
@@ -1,7 +0,0 @@
----
-name: Fecha
-tips:
-  - >
-    [Ejemplos de formatos de
-    fecha](https://www.php.net/manual/ru/datetime.format.php)
-definitions: []
diff --git a/modules/70-dates/20-date/index.php b/modules/70-dates/20-date/index.php
deleted file mode 100644
index 9b7015b1..00000000
--- a/modules/70-dates/20-date/index.php
+++ /dev/null
@@ -1,10 +0,0 @@
-<?php
-
-namespace HexletBasics\Dates\DateFunction;
-
-function getCustomDate($timestamp)
-{
-    // BEGIN
-    return date('d/m/Y', $timestamp);
-    // END
-}
diff --git a/modules/70-dates/20-date/ru/EXERCISE.md b/modules/70-dates/20-date/ru/EXERCISE.md
deleted file mode 100644
index 12587259..00000000
--- a/modules/70-dates/20-date/ru/EXERCISE.md
+++ /dev/null
@@ -1,11 +0,0 @@
-Допишите реализацию функции `getCustomDate()`, которая возвращает дату в формате `15/03/1985` на основе переданного timestamp.
-
-Примеры вызова:
-
-```php
-<?php
-
-getCustomDate(1532435204); // 24/07/2018;
-getCustomDate(532435204);  // 15/11/1986;
-getCustomDate(5324352);    // 03/03/1970;
-```
diff --git a/modules/70-dates/20-date/ru/README.md b/modules/70-dates/20-date/ru/README.md
deleted file mode 100644
index e2a59275..00000000
--- a/modules/70-dates/20-date/ru/README.md
+++ /dev/null
@@ -1,26 +0,0 @@
-Одна из главных функций по работе с датами в PHP — [date()](https://php.net/manual/ru/function.date.php). Она конвертирует _timestamp_ в человекочитаемый формат.
-
-Первым параметром в эту функцию передается описание формата даты, которое похоже на форматы для функции [sprintf()](https://php.net/manual/ru/function.sprintf.php):
-
-```php
-<?php
-
-// Y означает год
-date('Y'); // 2018
-```
-
-По умолчанию `date()` использует текущее время. Но если нужно, ей можно передать конкретный _timestamp_:
-
-```php
-<?php
-
-date('M', 123123123); // Nov
-```
-
-Различных опций форматирования в функции `date()` — десятки. Все они подробно перечислены на странице документации. Вряд ли стоит их все запоминать, но понимать общий принцип работы — полезно. Все опции могут комбинироваться между собой в любых вариациях:
-
-```php
-<?php
-
-date('l jS \of F Y h:i:s A'); // Thursday 26th of July 2018 10:58:55 AM
-```
diff --git a/modules/70-dates/20-date/ru/data.yml b/modules/70-dates/20-date/ru/data.yml
deleted file mode 100644
index aa58a949..00000000
--- a/modules/70-dates/20-date/ru/data.yml
+++ /dev/null
@@ -1,6 +0,0 @@
----
-name: Date
-tips:
-  - |
-    [Примеры форматов дат](https://www.php.net/manual/ru/datetime.format.php)
-definitions: []
diff --git a/modules/70-dates/30-mktime/Makefile b/modules/70-dates/30-mktime/Makefile
deleted file mode 100644
index d0d0a48c..00000000
--- a/modules/70-dates/30-mktime/Makefile
+++ /dev/null
@@ -1,2 +0,0 @@
-test:
-	@ test.sh
diff --git a/modules/70-dates/30-mktime/SolutionTest.php b/modules/70-dates/30-mktime/SolutionTest.php
deleted file mode 100644
index e1584765..00000000
--- a/modules/70-dates/30-mktime/SolutionTest.php
+++ /dev/null
@@ -1,15 +0,0 @@
-<?php
-
-namespace HexletBasics\Dates\Mkdtime;
-
-use PHPUnit\Framework\TestCase;
-
-class SolutionTest extends TestCase
-{
-    public function test()
-    {
-        require 'index.php';
-
-        $this->assertEquals(1325376000, getHexletBirthday());
-    }
-}
diff --git a/modules/70-dates/30-mktime/description.es.yml b/modules/70-dates/30-mktime/description.es.yml
deleted file mode 100644
index 9771811c..00000000
--- a/modules/70-dates/30-mktime/description.es.yml
+++ /dev/null
@@ -1,38 +0,0 @@
----
-
-name: mktime()
-theory: |
-  La función [mktime()](https://php.net/manual/ru/function.mktime.php) genera una marca de tiempo (_timestamp_) a partir de la información de tiempo: segundos, horas, minutos y fecha:
-
-  ```bash
-  mktime(
-      int $hora,
-      ?int $minuto = null,
-      ?int $segundo = null,
-      ?int $mes = null,
-      ?int $dia = null,
-      ?int $año = null
-  ): int|false
-  ```
-
-  `mktime()` es una función que acepta múltiples argumentos, donde cada parte de la fecha y el tiempo se pasa como un parámetro separado:
-
-  ```php
-  <?php
-
-  mktime(0, 0, 0, 7, 1, 2000); // 962409600
-  ```
-
-instructions: |
-
-  Implementa la función `getHexletBirthday()`, que devuelve la fecha de fundación de Hexlet en formato de marca de tiempo. Hexlet fue fundado el 01.01.2012.
-
-  ```php
-  <?php
-
-  getHexletBirthday();
-  ```
-
-tips: []
-
-definitions: []
diff --git a/modules/70-dates/30-mktime/en/EXERCISE.md b/modules/70-dates/30-mktime/en/EXERCISE.md
deleted file mode 100644
index b82cc59a..00000000
--- a/modules/70-dates/30-mktime/en/EXERCISE.md
+++ /dev/null
@@ -1,8 +0,0 @@
-
-Implement the `getHexletBirthday()`, function, which returns the founding date of the Hexlet as a timestamp. Hexlet was founded on 01/01/2012.
-
-```php
-<?php
-
-getHexletBirthday();
-```
diff --git a/modules/70-dates/30-mktime/en/README.md b/modules/70-dates/30-mktime/en/README.md
deleted file mode 100644
index a805d232..00000000
--- a/modules/70-dates/30-mktime/en/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
-
-The [mktime()](https://www.php.net/manual/en/function.mktime.php) function generates timestamp from time information: seconds, hours, minutes, and date.
-
-```
-int mktime ([ int $hour = date("H") [, int $minute = date("i") [, int $second = date("s") [, int $month = date("n") [, int $day = date("j") [, int $year = date("Y") ]]]]]] )
-```
-
-`mktime()` is a multi-word function, each part of the date and time is passed as a separate parameter.
-
-```php
-<?php
-
-mktime(0, 0, 0, 7, 1, 2000); // 962409600
-```
diff --git a/modules/70-dates/30-mktime/en/data.yml b/modules/70-dates/30-mktime/en/data.yml
deleted file mode 100644
index 503d4e4d..00000000
--- a/modules/70-dates/30-mktime/en/data.yml
+++ /dev/null
@@ -1,2 +0,0 @@
----
-name: mktime()
diff --git a/modules/70-dates/30-mktime/es/EXERCISE.md b/modules/70-dates/30-mktime/es/EXERCISE.md
deleted file mode 100644
index 2d74eb3e..00000000
--- a/modules/70-dates/30-mktime/es/EXERCISE.md
+++ /dev/null
@@ -1,8 +0,0 @@
-
-Implementa la función `getHexletBirthday()`, que devuelve la fecha de fundación de Hexlet en formato de marca de tiempo. Hexlet fue fundado el 01.01.2012.
-
-```php
-<?php
-
-getHexletBirthday();
-```
diff --git a/modules/70-dates/30-mktime/es/README.md b/modules/70-dates/30-mktime/es/README.md
deleted file mode 100644
index 08b54d7e..00000000
--- a/modules/70-dates/30-mktime/es/README.md
+++ /dev/null
@@ -1,20 +0,0 @@
-La función [mktime()](https://php.net/manual/ru/function.mktime.php) genera una marca de tiempo (_timestamp_) a partir de la información de tiempo: segundos, horas, minutos y fecha:
-
-```bash
-mktime(
-    int $hora,
-    ?int $minuto = null,
-    ?int $segundo = null,
-    ?int $mes = null,
-    ?int $dia = null,
-    ?int $año = null
-): int|false
-```
-
-`mktime()` es una función que acepta múltiples argumentos, donde cada parte de la fecha y el tiempo se pasa como un parámetro separado:
-
-```php
-<?php
-
-mktime(0, 0, 0, 7, 1, 2000); // 962409600
-```
diff --git a/modules/70-dates/30-mktime/es/data.yml b/modules/70-dates/30-mktime/es/data.yml
deleted file mode 100644
index 8c077d17..00000000
--- a/modules/70-dates/30-mktime/es/data.yml
+++ /dev/null
@@ -1,4 +0,0 @@
----
-name: mktime()
-tips: []
-definitions: []
diff --git a/modules/70-dates/30-mktime/index.php b/modules/70-dates/30-mktime/index.php
deleted file mode 100644
index fb40c835..00000000
--- a/modules/70-dates/30-mktime/index.php
+++ /dev/null
@@ -1,10 +0,0 @@
-<?php
-
-namespace HexletBasics\Dates\Mkdtime;
-
-// BEGIN
-function getHexletBirthday()
-{
-    return mktime(0, 0, 0, 1, 1, 2012);
-}
-// END
diff --git a/modules/70-dates/30-mktime/ru/EXERCISE.md b/modules/70-dates/30-mktime/ru/EXERCISE.md
deleted file mode 100644
index 0d9deadc..00000000
--- a/modules/70-dates/30-mktime/ru/EXERCISE.md
+++ /dev/null
@@ -1,8 +0,0 @@
-
-Реализуйте функцию `getHexletBirthday()`, которая возвращает дату основания Хекслета в виде timestamp. Хекслет был основан 01.01.2012.
-
-```php
-<?php
-
-getHexletBirthday();
-```
diff --git a/modules/70-dates/30-mktime/ru/README.md b/modules/70-dates/30-mktime/ru/README.md
deleted file mode 100644
index c1d32b75..00000000
--- a/modules/70-dates/30-mktime/ru/README.md
+++ /dev/null
@@ -1,20 +0,0 @@
-Функция [mktime()](https://php.net/manual/ru/function.mktime.php) генерирует _timestamp_ по информации о времени: секундах, часах, минутах и дате:
-
-```bash
-mktime(
-    int $hour,
-    ?int $minute = null,
-    ?int $second = null,
-    ?int $month = null,
-    ?int $day = null,
-    ?int $year = null
-): int|false
-```
-
-`mktime()` — многословная функция, в которой каждая часть даты и времени передается как отдельный параметр:
-
-```php
-<?php
-
-mktime(0, 0, 0, 7, 1, 2000); // 962409600
-```
diff --git a/modules/70-dates/30-mktime/ru/data.yml b/modules/70-dates/30-mktime/ru/data.yml
deleted file mode 100644
index 8c077d17..00000000
--- a/modules/70-dates/30-mktime/ru/data.yml
+++ /dev/null
@@ -1,4 +0,0 @@
----
-name: mktime()
-tips: []
-definitions: []
diff --git a/modules/70-dates/40-timezone/Makefile b/modules/70-dates/40-timezone/Makefile
deleted file mode 100644
index d0d0a48c..00000000
--- a/modules/70-dates/40-timezone/Makefile
+++ /dev/null
@@ -1,2 +0,0 @@
-test:
-	@ test.sh
diff --git a/modules/70-dates/40-timezone/description.es.yml b/modules/70-dates/40-timezone/description.es.yml
deleted file mode 100644
index 72e6688a..00000000
--- a/modules/70-dates/40-timezone/description.es.yml
+++ /dev/null
@@ -1,23 +0,0 @@
----
-
-name: Zonas horarias
-theory: |
-  Una de las partes más complicadas al trabajar con fechas son las zonas horarias (_time zones_).
-
-  La Tierra se divide en 24 zonas horarias, por lo que en zonas adyacentes, la hora suele diferir en una hora. El tiempo universal coordinado (UTC) se considera el tiempo cero. Las zonas horarias alrededor del mundo se expresan como un desplazamiento positivo o negativo con respecto al UTC. Por ejemplo, en Moscú, la zona horaria es +3.
-
-  Un detalle interesante de este mecanismo es el cambio de horario de verano e invierno. Mientras que las zonas horarias son fijas, el cambio de horario de verano e invierno es una prerrogativa de los países que periódicamente lo implementan o lo cancelan. El tiempo UTC nunca se cambia, los desplazamientos ocurren en relación a él. Además, hay mil y un problema más.
-
-  La regla principal al trabajar con fechas es almacenar y comparar en formato UTC. Sin embargo, es mejor mostrar las fechas en la zona horaria del usuario.
-
-  Si necesita verificar la zona horaria actual, puede utilizar la función `date_default_timezone_get()`. Para establecer la zona, utilice la función `date_default_timezone_set()`.
-
-instructions: |
-
-  Muestre en pantalla la zona horaria actual.
-
-tips:
-  - |
-    [Lista de zonas horarias admitidas en PHP](https://php.net/manual/es/timezones.php)
-
-definitions: []
diff --git a/modules/70-dates/40-timezone/en/EXERCISE.md b/modules/70-dates/40-timezone/en/EXERCISE.md
deleted file mode 100644
index b9e27402..00000000
--- a/modules/70-dates/40-timezone/en/EXERCISE.md
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Display the current time zone.
diff --git a/modules/70-dates/40-timezone/en/README.md b/modules/70-dates/40-timezone/en/README.md
deleted file mode 100644
index 66ca9943..00000000
--- a/modules/70-dates/40-timezone/en/README.md
+++ /dev/null
@@ -1,8 +0,0 @@
-
-One of the most difficult parts of working with dates is time zones. The entire earth is divided into 24 time zones, meaning that in neighboring zones the time is often different by one hour. Zero time is [Coordinated Universal Time](https://en.wikipedia.org/wiki/Coordinated_Universal_Time) (UTC). Time zones around the globe are expressed as a positive or negative offset from UTC. For example, the time zone in Moscow is +3.
-
-The transition to daylight saving time and winter time adds a little zest to this system. And while the zones are strictly fixed, the transition to winter and summer time is the prerogative of individual states, which periodically introduce or cancel it. UTC time is never translated, shifts occur relative to it. On top of that, there are a thousand and one other problems.
-
-The main rule when working with dates is that storage and comparison should be made in UTC format. But it's better to display the dates in the zone in which the user lives.
-
-You can check the current zone with `date_default_timezone_get()`. Set the zone with the `date_default_timezone_set()`.
diff --git a/modules/70-dates/40-timezone/en/data.yml b/modules/70-dates/40-timezone/en/data.yml
deleted file mode 100644
index 2884f3c9..00000000
--- a/modules/70-dates/40-timezone/en/data.yml
+++ /dev/null
@@ -1,6 +0,0 @@
----
-name: Time Zones (Time Zones)
-tips:
-  - >
-    [List of supported time zones in
-    PHP](https://www.php.net/manual/en/timezones.php)
diff --git a/modules/70-dates/40-timezone/es/EXERCISE.md b/modules/70-dates/40-timezone/es/EXERCISE.md
deleted file mode 100644
index 8ada5e26..00000000
--- a/modules/70-dates/40-timezone/es/EXERCISE.md
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Muestre en pantalla la zona horaria actual.
diff --git a/modules/70-dates/40-timezone/es/README.md b/modules/70-dates/40-timezone/es/README.md
deleted file mode 100644
index 03407e19..00000000
--- a/modules/70-dates/40-timezone/es/README.md
+++ /dev/null
@@ -1,9 +0,0 @@
-Una de las partes más complicadas al trabajar con fechas son las zonas horarias (_time zones_).
-
-La Tierra se divide en 24 zonas horarias, por lo que en zonas adyacentes, la hora suele diferir en una hora. El tiempo universal coordinado (UTC) se considera el tiempo cero. Las zonas horarias alrededor del mundo se expresan como un desplazamiento positivo o negativo con respecto al UTC. Por ejemplo, en Moscú, la zona horaria es +3.
-
-Un detalle interesante de este mecanismo es el cambio de horario de verano e invierno. Mientras que las zonas horarias son fijas, el cambio de horario de verano e invierno es una prerrogativa de los países que periódicamente lo implementan o lo cancelan. El tiempo UTC nunca se cambia, los desplazamientos ocurren en relación a él. Además, hay mil y un problema más.
-
-La regla principal al trabajar con fechas es almacenar y comparar en formato UTC. Sin embargo, es mejor mostrar las fechas en la zona horaria del usuario.
-
-Si necesita verificar la zona horaria actual, puede utilizar la función `date_default_timezone_get()`. Para establecer la zona, utilice la función `date_default_timezone_set()`.
diff --git a/modules/70-dates/40-timezone/es/data.yml b/modules/70-dates/40-timezone/es/data.yml
deleted file mode 100644
index dd52d632..00000000
--- a/modules/70-dates/40-timezone/es/data.yml
+++ /dev/null
@@ -1,7 +0,0 @@
----
-name: Zonas horarias
-tips:
-  - >
-    [Lista de zonas horarias admitidas en
-    PHP](https://php.net/manual/es/timezones.php)
-definitions: []
diff --git a/modules/70-dates/40-timezone/index.php b/modules/70-dates/40-timezone/index.php
deleted file mode 100644
index 164d71f5..00000000
--- a/modules/70-dates/40-timezone/index.php
+++ /dev/null
@@ -1,5 +0,0 @@
-<?php
-
-// BEGIN
-print_r(date_default_timezone_get());
-// END
diff --git a/modules/70-dates/40-timezone/ru/EXERCISE.md b/modules/70-dates/40-timezone/ru/EXERCISE.md
deleted file mode 100644
index d2bcdf6f..00000000
--- a/modules/70-dates/40-timezone/ru/EXERCISE.md
+++ /dev/null
@@ -1,2 +0,0 @@
-
-Выведите на экран текущий часовой пояс.
diff --git a/modules/70-dates/40-timezone/ru/README.md b/modules/70-dates/40-timezone/ru/README.md
deleted file mode 100644
index 3d94f22d..00000000
--- a/modules/70-dates/40-timezone/ru/README.md
+++ /dev/null
@@ -1,9 +0,0 @@
-Одна из самых сложных деталей при работе с датами — часовые пояса (_time zones_).
-
-Вся Земля делится на 24 часовых пояса, так что в соседних поясах время чаще всего отличается на час. Нулевым временем считается [всемирное координированное время](https://ru.wikipedia.org/wiki/Всемирное_координированное_время) (UTC). Часовые пояса вокруг земного шара выражаются, как положительное или отрицательное смещение от UTC. Например, в Москве часовой пояс +3.
-
-Изюминку в этот механизм добавляет переход на летнее и зимнее время. Причем если пояса строго фиксированы, то переход на зимнее и летнее время — прерогатива конкретных государств, которые периодически его вводят или отменяют. Время UTC никогда не переводят, смещения происходят относительно него. Кроме этого есть еще тысяча и одна проблема.
-
-Главное правило при работе с датами — хранение и сравнение должно производиться в UTC формате. А вот выводить даты лучше в той зоне, в которой живет пользователь.
-
-Если вам нужно проверить текущую таймзону, можно воспользоваться функцией `date_default_timezone_get()`. Установить зону функцией `date_default_timezone_set()`.
diff --git a/modules/70-dates/40-timezone/ru/data.yml b/modules/70-dates/40-timezone/ru/data.yml
deleted file mode 100644
index a89e0740..00000000
--- a/modules/70-dates/40-timezone/ru/data.yml
+++ /dev/null
@@ -1,7 +0,0 @@
----
-name: Часовые пояса (тайм зоны)
-tips:
-  - >
-    [Список поддерживаемых временных зон в
-    PHP](https://php.net/manual/ru/timezones.php)
-definitions: []
diff --git a/modules/70-dates/description.en.yml b/modules/70-dates/description.en.yml
deleted file mode 100644
index 4a1a1b7c..00000000
--- a/modules/70-dates/description.en.yml
+++ /dev/null
@@ -1,5 +0,0 @@
----
-
-name: Date and Time
-description: |
-  ПThe concept of time in computers. Hardware Timer and System Timer. Functions for working with date and time in PHP. Timezones
diff --git a/modules/70-dates/description.es.yml b/modules/70-dates/description.es.yml
deleted file mode 100644
index cfd6fe77..00000000
--- a/modules/70-dates/description.es.yml
+++ /dev/null
@@ -1,5 +0,0 @@
----
-
-name: Fecha y Hora
-description: |
-  El concepto de tiempo en las computadoras. Temporizadores de hardware y de sistema. Funciones para trabajar con fechas y horas en PHP. Zonas horarias.
diff --git a/modules/70-dates/description.ru.yml b/modules/70-dates/description.ru.yml
deleted file mode 100644
index 5a611aaa..00000000
--- a/modules/70-dates/description.ru.yml
+++ /dev/null
@@ -1,5 +0,0 @@
----
-
-name: Дата и Время
-description: |
-  Понятие времени в компьютерах. Аппаратный и Системный таймеры. Функции для работы с датой и временем в PHP. Таймзоны
diff --git a/spec.yml b/spec.yml
index f3a492ea..0a3602a7 100644
--- a/spec.yml
+++ b/spec.yml
@@ -3,7 +3,7 @@
 language:
   docker_image: "ghcr.io/hexlet-basics/exercises-php"
   extension: php
-  exercise_filename: index.php
+  exercise_filename: Solution.php
   exercise_test_filename: SolutionTest.php
   learn_as: first_language
   progress: completed
diff --git a/src/Functions.php b/src/Functions.php
deleted file mode 100644
index 2c1f6870..00000000
--- a/src/Functions.php
+++ /dev/null
@@ -1,9 +0,0 @@
-<?php
-
-namespace HexletBasics\Functions;
-
-function runScript()
-{
-    require 'index.php';
-    print_r("\n");
-}
diff --git a/src/TestCase.php b/src/TestCase.php
new file mode 100644
index 00000000..6b7a8411
--- /dev/null
+++ b/src/TestCase.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace HexletBasics\Exercise;
+
+use PHPUnit\Framework\TestCase as BaseTestCase;
+use ReflectionObject;
+
+abstract class TestCase extends BaseTestCase
+{
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $solutionPath = dirname((new ReflectionObject($this))->getFileName()) . '/Solution.php';
+        require $solutionPath;
+    }
+}