sync(locales): bring en/es up to date with rewritten ru theory

modules/10-basics/10-hello-world/description.es.yml

@@ -2,25 +2,70 @@
 
 name: ¡Hola, Mundo!
 theory: |
-  Por lo general, el aprendizaje de un nuevo lenguaje de programación comienza con 'Hello, World!'. Es un programa simple que muestra un saludo en la pantalla y al mismo tiempo familiariza con el nuevo lenguaje, así como con su sintaxis y la estructura del programa.. Esta tradición tiene más de cuarenta años, por lo que no la romperemos: en la primera lección escribiremos el programa `Hello, World!`.
-
-  Este programa mostrará el siguiente texto en la pantalla:
+  El aprendizaje de un nuevo lenguaje de programación comienza tradicionalmente con un programa 'Hello, World!'. Es un programa simple que muestra un saludo en la pantalla y familiariza con la sintaxis y la estructura del nuevo lenguaje.
 
   ```text
-    Hello, World!
+  Hello, World!
+  ```
+
+  Esta tradición tiene ya más de cuarenta años, y nosotros también comenzaremos con ella. En la primera lección escribiremos un programa `Hello, World!`. En JavaScript, este programa se ve así:
+
+  ```javascript
+  console.log('Hello, World!');
   ```
 
-  Para mostrar algo en la pantalla, es necesario darle al ordenador un comando especial. En el lenguaje JavaScript, ese comando es `console.log()`.
+  El comando `console.log()` muestra en la pantalla el texto indicado entre paréntesis. En lugar del ejemplo puedes escribir cualquier otro texto.
 
+  ```javascript
+  console.log('Hexlet - escuela de programación');
+  ```
+
+  El comando sigue siendo el mismo, solo cambia el contenido entre paréntesis. Para que el programa entienda que se trata precisamente de texto, este se encierra entre comillas. Puedes usar comillas simples `'...'` o dobles `"..."`, pero las comillas de apertura y de cierre deben coincidir.
+
+  ```javascript
+  console.log("Hexlet - escuela de programación");
+  ```
+
+  Según el estilo aceptado en la comunidad de JavaScript, se recomienda usar comillas simples para las cadenas. Si dentro de la cadena hay un apóstrofo, las comillas simples romperán la sintaxis, por lo que en esos casos se usan comillas dobles.
+
+  ```javascript
+  console.log("it's JavaScript"); // apóstrofo dentro, por eso comillas dobles
+  ```
+
+  ## El significado de los símbolos
+
+  El código está formado por comandos, y cada uno de ellos debe escribirse de una forma determinada. Además de las letras, en el código son importantes las comillas `'` y `"`, los paréntesis `()` y los signos de puntuación. Un signo omitido o confundido hará que el programa no se ejecute. ¿Puedes intentar determinar qué error se cometió en cada una de las líneas?
+
+  ```javascript
+  console.log("it's JavaScript"
+  console.log(it's JavaScript")
+  consol.log("it's JavaScript")
+  console.log('it's JavaScript")
+  consolelog("it's JavaScript")
+  ```
+
+  Incluso una pequeña diferencia, por ejemplo una letra de más o un signo distinto, puede hacer que el programa no funcione. Esto también se aplica a las mayúsculas y minúsculas, es decir, a la diferencia entre letras grandes y pequeñas. Mientras que en el texto ordinario `Hola` y `hola` se ven iguales, para JavaScript son palabras diferentes. JavaScript considera `console.log`, `Console.Log` y `CONSOLE.LOG` como comandos diferentes, y solo funcionará la primera variante.
+
+  ## Dónde practicar
+
+  La teoría se asimila mejor cuando ejecutas el código en paralelo y ves el resultado. Para esto sirve la consola del navegador (DevTools), donde los comandos se ejecutan línea por línea. Todo lo que aparece en la lección vale la pena probarlo [en la consola del navegador](https://developer.chrome.com/docs/devtools/console/).
+
+  ¿Cómo funciona esto técnicamente? Cualquier código que se escribe se pasa al motor de JavaScript, que ejecuta ese código y muestra en la pantalla el resultado de su trabajo.
+
+  ```text
+  Código                 Motor JS              Pantalla
+  ┌──────────────────┐   ┌───────────┐   ┌──────────────┐
+  │ console.log(…)   │──→│JavaScript │──→│ Hello, World!│
+  └──────────────────┘   └───────────┘   └──────────────┘
+  ```
 instructions: |
   Escribe en el editor el código del ejercicio, carácter por carácter, y luego haz clic en "Comprobar".
 
   ```javascript
   console.log('Hello, World!');
   ```
 
-  Atención: si escribes `heLLo, woRld!` en lugar de `Hello, World!`, se considerará un texto diferente, ya que las mayúsculas y minúsculas son caracteres distintos. El *tamaño de las letras* es importante y es por eso que dicen que: ¡*las mayúsculas importan*!. Esto se aplica a casi todo el código, así que acostúmbrate a prestar siempre atención a las mayúsculas.
-
+  Atención: si escribes `heLLo, woRld!` en lugar de `Hello, World!`, se considerará un texto diferente, porque las mayúsculas y minúsculas son caracteres distintos. El tamaño de una letra se llama *caja* (mayúscula o minúscula), y se dice: ¡*la caja importa*! Esto se aplica a casi todo en el código, así que acostúmbrate a prestar siempre atención a las mayúsculas y minúsculas.
 tips:
   - |
     [Un poco sobre 'Hello, World!'](https://codica.la/blog/mi-gente-me-entiende-la-historia-de-la-frase-hello-world-y-sus-analogos)

modules/10-basics/10-hello-world/en/EXERCISE.md

@@ -1,6 +1,7 @@
-Copy the exact code from the instructions into the editor and run it by clicking “Run”.
+Type the code from the task into the editor character by character and click "Check".
 
 ```javascript
 console.log('Hello, World!');
 ```
-Note that if you type `hello, woRld!` instead of `Hello, World!`, it will count as different text, because upper and lowercase letters are different symbols in JavaScript. Letter size is called *case*, and any programmer will tell you that *case is important*. This rule affects almost everything in coding, so make sure you get used to paying close attention to the case at all times.
+
+Note: if you write `heLLo, woRld!` instead of `Hello, World!`, it will be considered different text, because uppercase and lowercase letters are different characters. The size of a letter is called *case*, and people say: *case matters!* This applies to almost everything in code, so get used to always paying attention to case.

modules/10-basics/10-hello-world/en/README.md

@@ -1,7 +1,56 @@
-As is tradition, we'll start by writing a 'Hello, World!' program. The program will print the following text:
+Learning a new programming language traditionally begins with a 'Hello, World!' program. This is a simple program that prints a greeting to the screen and introduces the syntax and structure of the new language.
 
 ```text
-  Hello, World!
+Hello, World!
 ```
 
-To print something, you need to give computer a special command. In JavaScript, we use `console.log()`.
+This tradition is already more than forty years old, and we will start with it too. In the first lesson, we will write a `Hello, World!` program. In JavaScript, this program looks like this:
+
+```javascript
+console.log('Hello, World!');
+```
+
+The `console.log()` command prints to the screen the text specified in parentheses. Instead of the example, you can write any other text.
+
+```javascript
+console.log('Hexlet - programming school');
+```
+
+The command stays the same, only the contents of the parentheses change. So that the program understands that this is exactly text, it is enclosed in quotes. You can use single `'...'` or double `"..."` quotes, but the opening and closing quotes must match.
+
+```javascript
+console.log("Hexlet - programming school");
+```
+
+According to the style accepted in the JavaScript community, single quotes are recommended for strings. If there is an apostrophe inside the string, single quotes will break the syntax, so in such cases double quotes are used.
+
+```javascript
+console.log("it's JavaScript"); // apostrophe inside, so double quotes
+```
+
+## The meaning of symbols
+
+Code consists of commands, and each of them must be written in a specific form. Besides letters, quotes `'` and `"`, parentheses `()`, and punctuation marks are important in code. A missing or mixed-up sign will cause the program not to run. Try to determine what error was made in each of the lines?
+
+```javascript
+console.log("it's JavaScript"
+console.log(it's JavaScript")
+consol.log("it's JavaScript")
+console.log('it's JavaScript")
+consolelog("it's JavaScript")
+```
+
+Even a small difference, for example one extra letter or a different sign, can cause the program not to work. This also applies to case, that is, to the difference between uppercase and lowercase letters. While in ordinary text `Hello` and `hello` look the same, for JavaScript these are different words. JavaScript considers `console.log`, `Console.Log`, and `CONSOLE.LOG` to be different commands, and only the first variant will work.
+
+## Where to practice
+
+Theory is absorbed better when you run code in parallel and see the result. The browser console (DevTools) is suitable for this, where commands are executed line by line. Everything that appears in the lesson is worth trying [in the browser console](https://developer.chrome.com/docs/devtools/console/).
+
+How does this work technically? Any code that is written is passed to the JavaScript engine, which executes this code and prints the result of its work to the screen.
+
+```text
+Code                   JS Engine             Screen
+┌──────────────────┐   ┌───────────┐   ┌──────────────┐
+│ console.log(…)   │──→│JavaScript │──→│ Hello, World!│
+└──────────────────┘   └───────────┘   └──────────────┘
+```

modules/10-basics/10-hello-world/en/data.yml

@@ -2,5 +2,5 @@
 name: Hello, World!
 tips:
   - >
-    [Read more about 'Hello,
+    [A bit about 'Hello,
     World!'](https://en.wikipedia.org/wiki/%22Hello,_World!%22_program)

modules/10-basics/10-hello-world/es/EXERCISE.md

@@ -4,4 +4,4 @@ Escribe en el editor el código del ejercicio, carácter por carácter, y luego
 console.log('Hello, World!');
 ```
 
-Atención: si escribes `heLLo, woRld!` en lugar de `Hello, World!`, se considerará un texto diferente, ya que las mayúsculas y minúsculas son caracteres distintos. El *tamaño de las letras* es importante y es por eso que dicen que: ¡*las mayúsculas importan*!. Esto se aplica a casi todo el código, así que acostúmbrate a prestar siempre atención a las mayúsculas.
+Atención: si escribes `heLLo, woRld!` en lugar de `Hello, World!`, se considerará un texto diferente, porque las mayúsculas y minúsculas son caracteres distintos. El tamaño de una letra se llama *caja* (mayúscula o minúscula), y se dice: ¡*la caja importa*! Esto se aplica a casi todo en el código, así que acostúmbrate a prestar siempre atención a las mayúsculas y minúsculas.

modules/10-basics/10-hello-world/es/README.md

@@ -1,9 +1,56 @@
-Por lo general, el aprendizaje de un nuevo lenguaje de programación comienza con 'Hello, World!'. Es un programa simple que muestra un saludo en la pantalla y al mismo tiempo familiariza con el nuevo lenguaje, así como con su sintaxis y la estructura del programa.. Esta tradición tiene más de cuarenta años, por lo que no la romperemos: en la primera lección escribiremos el programa `Hello, World!`.
-
-Este programa mostrará el siguiente texto en la pantalla:
+El aprendizaje de un nuevo lenguaje de programación comienza tradicionalmente con un programa 'Hello, World!'. Es un programa simple que muestra un saludo en la pantalla y familiariza con la sintaxis y la estructura del nuevo lenguaje.
 
 ```text
-  Hello, World!
+Hello, World!
+```
+
+Esta tradición tiene ya más de cuarenta años, y nosotros también comenzaremos con ella. En la primera lección escribiremos un programa `Hello, World!`. En JavaScript, este programa se ve así:
+
+```javascript
+console.log('Hello, World!');
+```
+
+El comando `console.log()` muestra en la pantalla el texto indicado entre paréntesis. En lugar del ejemplo puedes escribir cualquier otro texto.
+
+```javascript
+console.log('Hexlet - escuela de programación');
+```
+
+El comando sigue siendo el mismo, solo cambia el contenido entre paréntesis. Para que el programa entienda que se trata precisamente de texto, este se encierra entre comillas. Puedes usar comillas simples `'...'` o dobles `"..."`, pero las comillas de apertura y de cierre deben coincidir.
+
+```javascript
+console.log("Hexlet - escuela de programación");
 ```
 
-Para mostrar algo en la pantalla, es necesario darle al ordenador un comando especial. En el lenguaje JavaScript, ese comando es `console.log()`.
+Según el estilo aceptado en la comunidad de JavaScript, se recomienda usar comillas simples para las cadenas. Si dentro de la cadena hay un apóstrofo, las comillas simples romperán la sintaxis, por lo que en esos casos se usan comillas dobles.
+
+```javascript
+console.log("it's JavaScript"); // apóstrofo dentro, por eso comillas dobles
+```
+
+## El significado de los símbolos
+
+El código está formado por comandos, y cada uno de ellos debe escribirse de una forma determinada. Además de las letras, en el código son importantes las comillas `'` y `"`, los paréntesis `()` y los signos de puntuación. Un signo omitido o confundido hará que el programa no se ejecute. ¿Puedes intentar determinar qué error se cometió en cada una de las líneas?
+
+```javascript
+console.log("it's JavaScript"
+console.log(it's JavaScript")
+consol.log("it's JavaScript")
+console.log('it's JavaScript")
+consolelog("it's JavaScript")
+```
+
+Incluso una pequeña diferencia, por ejemplo una letra de más o un signo distinto, puede hacer que el programa no funcione. Esto también se aplica a las mayúsculas y minúsculas, es decir, a la diferencia entre letras grandes y pequeñas. Mientras que en el texto ordinario `Hola` y `hola` se ven iguales, para JavaScript son palabras diferentes. JavaScript considera `console.log`, `Console.Log` y `CONSOLE.LOG` como comandos diferentes, y solo funcionará la primera variante.
+
+## Dónde practicar
+
+La teoría se asimila mejor cuando ejecutas el código en paralelo y ves el resultado. Para esto sirve la consola del navegador (DevTools), donde los comandos se ejecutan línea por línea. Todo lo que aparece en la lección vale la pena probarlo [en la consola del navegador](https://developer.chrome.com/docs/devtools/console/).
+
+¿Cómo funciona esto técnicamente? Cualquier código que se escribe se pasa al motor de JavaScript, que ejecuta ese código y muestra en la pantalla el resultado de su trabajo.
+
+```text
+Código                 Motor JS              Pantalla
+┌──────────────────┐   ┌───────────┐   ┌──────────────┐
+│ console.log(…)   │──→│JavaScript │──→│ Hello, World!│
+└──────────────────┘   └───────────┘   └──────────────┘
+```

modules/10-basics/20-comments/description.es.yml

@@ -2,8 +2,7 @@
 
 name: Comentarios
 theory: |
-
-  Además del código en sí, los archivos de código fuente pueden contener comentarios. Estos son textos que no forman parte del programa y son útiles para los programadores como notas. Con ellos se pueden agregar explicaciones sobre cómo funciona el código, qué errores corregir o qué agregar más adelante.
+  Además del código, los archivos de código fuente pueden contener comentarios. Estos son textos que no forman parte del programa y son útiles para los programadores como notas. Con ellos se pueden agregar explicaciones sobre cómo funciona el código, qué errores hay que corregir aquí o recordatorios de agregar algo más adelante.
 
   ```javascript
   // Eliminar la línea de abajo después de implementar la tarea de registro
@@ -26,7 +25,7 @@ theory: |
   Un comentario puede estar en una línea después de algún código:
 
   ```javascript
-  console.log('Soy el Rey'); // For Lannisters!
+  console.log('I am the King'); // For Lannisters!
   ```
 
   ## Comentarios de varias líneas
@@ -41,26 +40,40 @@ theory: |
   console.log('I am the King');
   ```
 
-
   Estos comentarios generalmente se utilizan para la documentación del código, por ejemplo, en el caso de las funciones.
 
+  ## Comentarios de servicio
+
+  Durante el trabajo, te encontrarás con un código así en nuestro editor:
+
+  ```javascript
+  // BEGIN
+
+  // END
+  ```
+
+  *BEGIN* y *END* aquí son comentarios comunes que no afectan en absoluto el funcionamiento del programa. Indican dónde escribir el código de la tarea.
+
+  ```javascript
+  // BEGIN
+  <aquí tu solución>
+  // END
+  ```
+
+  Cuando veas *BEGIN* y *END*, escribe tu código entre ellos y deja el resto sin cambios.
 instructions: |
-  Crea un comentario de una línea con el texto: ``You know nothing, Jon Snow!`.
+  Estás escribiendo un programa y te das cuenta de que una parte debe terminarse más tarde. Para no olvidarlo, los programadores dejan notas para sí mismos directamente en el código: los comentarios TODO.
+
+  Agrega al archivo este comentario:
 
+  ```javascript
+  // TODO: add a greeting function
+  ```
+
+  Cuando vuelvas a este lugar más tarde, el comentario te recordará que aquí todavía hay trabajo sin terminar.
 tips:
   - |
     [Más información sobre comentarios](https://www.w3schools.com/js/js_comments.asp)
-
 definitions:
-  - name: Comentario
-    description: |
-      texto en el código de un programa que no afecta la funcionalidad y es agregado por los programadores para ellos mismos y sus colegas.
-
-      `// comentario de una línea`
-
-      ```
-      /*
-        comentario de varias líneas
-        comentario de varias líneas
-      */
-      ```
+  - name: "Comentario"
+    description: "texto en el código de un programa que no afecta la funcionalidad y es agregado por los programadores para ellos mismos y sus colegas."

modules/10-basics/20-comments/en/EXERCISE.md

@@ -1 +1,9 @@
-Create a single line comment with the following text: `You know nothing, Jon Snow!`.
+You are writing a program and realize that one part needs to be finished later. To avoid forgetting, programmers leave notes for themselves right in the code — TODO comments.
+
+Add such a comment to the file:
+
+```javascript
+// TODO: add a greeting function
+```
+
+When you come back to this place later, the comment will remind you that there is still unfinished work here.