From 5089338206c7337af9e6fa61edfddfdb6316233b Mon Sep 17 00:00:00 2001 From: Nikolay Gagarinov Date: Thu, 2 Jul 2026 19:59:52 +0500 Subject: [PATCH] =?UTF-8?q?feat(10-basics):=20=D0=BB=D0=BE=D0=BA=D0=B0?= =?UTF-8?q?=D0=BB=D0=B8=20en/es=20=E2=80=94=20=D0=BF=D0=B5=D1=80=D0=B5?= =?UTF-8?q?=D0=B2=D0=BE=D0=B4=20=D0=BF=D0=BE=D0=B4=20=D0=BD=D0=BE=D0=B2?= =?UTF-8?q?=D1=8B=D0=B9=20ru?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - es/: ресинхрон 5 уроков под переписанную ru-теорию (python-alignment) - en/: создание 5 уроков с нуля (README, EXERCISE, data.yml) - 20-comments/App.java: нейтрализация русского комментария в TODO - description.en.yml модуля создан, description.es.yml приведён к ru Проверки: schema-validate + description-lint + make test — passed (71 модуль). Co-Authored-By: Claude Opus 4.8 (1M context) --- .../10-basics/10-hello-world/en/EXERCISE.md | 11 +++ modules/10-basics/10-hello-world/en/README.md | 69 +++++++++++++++++ modules/10-basics/10-hello-world/en/data.yml | 8 ++ .../10-basics/10-hello-world/es/EXERCISE.md | 2 +- modules/10-basics/10-hello-world/es/README.md | 54 ++++++++++--- modules/10-basics/20-comments/App.java | 2 +- modules/10-basics/20-comments/en/EXERCISE.md | 9 +++ modules/10-basics/20-comments/en/README.md | 64 ++++++++++++++++ modules/10-basics/20-comments/en/data.yml | 11 +++ modules/10-basics/20-comments/es/EXERCISE.md | 8 +- modules/10-basics/20-comments/es/README.md | 75 +++++++++++++------ modules/10-basics/20-comments/es/data.yml | 9 +++ .../10-basics/30-statements/en/EXERCISE.md | 9 +++ modules/10-basics/30-statements/en/README.md | 73 ++++++++++++++++++ modules/10-basics/30-statements/en/data.yml | 14 ++++ .../10-basics/30-statements/es/EXERCISE.md | 4 +- modules/10-basics/30-statements/es/README.md | 70 ++++++++++++++--- modules/10-basics/30-statements/es/data.yml | 15 +++- modules/10-basics/40-testing/en/EXERCISE.md | 7 ++ modules/10-basics/40-testing/en/README.md | 23 ++++++ modules/10-basics/40-testing/en/data.yml | 12 +++ modules/10-basics/40-testing/es/README.md | 18 +++-- .../10-basics/50-syntax-error/en/EXERCISE.md | 13 ++++ .../10-basics/50-syntax-error/en/README.md | 52 +++++++++++++ modules/10-basics/50-syntax-error/en/data.yml | 13 ++++ .../10-basics/50-syntax-error/es/EXERCISE.md | 13 +++- .../10-basics/50-syntax-error/es/README.md | 39 ++++++++-- modules/10-basics/50-syntax-error/es/data.yml | 10 ++- modules/10-basics/description.en.yml | 5 ++ modules/10-basics/description.es.yml | 2 +- 30 files changed, 644 insertions(+), 70 deletions(-) create mode 100644 modules/10-basics/10-hello-world/en/EXERCISE.md create mode 100644 modules/10-basics/10-hello-world/en/README.md create mode 100644 modules/10-basics/10-hello-world/en/data.yml create mode 100644 modules/10-basics/20-comments/en/EXERCISE.md create mode 100644 modules/10-basics/20-comments/en/README.md create mode 100644 modules/10-basics/20-comments/en/data.yml create mode 100644 modules/10-basics/30-statements/en/EXERCISE.md create mode 100644 modules/10-basics/30-statements/en/README.md create mode 100644 modules/10-basics/30-statements/en/data.yml create mode 100644 modules/10-basics/40-testing/en/EXERCISE.md create mode 100644 modules/10-basics/40-testing/en/README.md create mode 100644 modules/10-basics/40-testing/en/data.yml create mode 100644 modules/10-basics/50-syntax-error/en/EXERCISE.md create mode 100644 modules/10-basics/50-syntax-error/en/README.md create mode 100644 modules/10-basics/50-syntax-error/en/data.yml create mode 100644 modules/10-basics/description.en.yml diff --git a/modules/10-basics/10-hello-world/en/EXERCISE.md b/modules/10-basics/10-hello-world/en/EXERCISE.md new file mode 100644 index 00000000..6785c384 --- /dev/null +++ b/modules/10-basics/10-hello-world/en/EXERCISE.md @@ -0,0 +1,11 @@ +Type the code from the exercise into the editor character by character and click "Verify". + +```java +class App { + public static void main(String[] args) { + System.out.println("Hello, World!"); + } +} +``` + +If you write *heLLo, woRld!* instead of *Hello, World!*, it will be treated as different text, because uppercase and lowercase letters are different characters. The size of a letter is called *case*, and they say: **case matters!** This applies to almost everything in code, so get used to always paying attention to case. diff --git a/modules/10-basics/10-hello-world/en/README.md b/modules/10-basics/10-hello-world/en/README.md new file mode 100644 index 00000000..9efdde0c --- /dev/null +++ b/modules/10-basics/10-hello-world/en/README.md @@ -0,0 +1,69 @@ +Learning a programming language traditionally begins with the "Hello, World!" program, which prints this text on the screen. + +```text +Hello, World! +``` + +In Java, this program looks like this: + +```java +class App { + public static void main(String[] args) { + System.out.println("Hello, World!"); + } +} +``` + +The text *Hello, World!* appears on the screen thanks to the `System.out.println()` command, where `println()` is short for the English *print line*. It prints the value specified in the parentheses `("Hello, World!")` — in this case, a string. Instead of the example, you can print any other text: + +```java +System.out.println("Hexlet — a programming school"); +``` + +The command stays the same; only the content of the parentheses changes. + +So that the program understands that the parentheses contain text, it is enclosed in quotes. In Java, a string is always wrapped in **double** quotes `"..."`. You cannot use single quotes `'...'` for a string: they hold a single character (the `char` type), for example `'A'`. If you wrap a string in single quotes, the compiler will point out a syntax error: + +```bash +# For example, like this +App.java:5: error: unclosed character literal +System.out.println('Hello, World!'); +``` + +The command itself is located inside several constructs that are needed even for the simplest Java programs. In this case, these are the `App` class and the `main()` method. + +For now, we won't dwell on them, because understanding them requires a bit of programming knowledge. So in many exercises they are given "as is", meaning you won't have to write them yourself. When the time comes, we'll go through them. + +## The meaning of characters + +Code consists of commands, and each of them must be written in a specific form. Besides letters, quotes `"`, parentheses `()`, curly braces `{}`, and the semicolon `;` matter in code. A missing or mixed-up character will cause the program to fail to compile. Try to figure out what mistake is made in each of the lines: + +```java +System.out.println("I am the King"); +System.out.println("I am the King"; +System.out.println(I am the King"); +System.ouprintln("I am the King"); +System.out.println("I am the King") +``` + +Even a small difference — an extra letter, a lost parenthesis, or a forgotten `;` — can prevent the program from working. This also applies to case, that is, the difference between uppercase and lowercase letters. While in ordinary text `Hello` and `hello` look the same, for Java they are different words. Java treats `println`, `Println`, and `PRINTLN` as different names, and only the first option will work. + +## Where to practice + +Theory sinks in better when you run code alongside it and see the result. As you move through the lessons, you'll constantly come across code examples and descriptions of how they work. To understand them better and be able to use the language, you need to practice and experiment constantly — whenever possible, run all the examples from the theory. + +The easiest way to get started with Java is on the [onecompiler](https://onecompiler.com/jshell) website, which lets you run code line by line right in the browser using JShell. Try going there right now and typing this code: + +```text +System.out.println(85 * 3); +``` + +How does this work technically? Unlike languages that are executed line by line by an interpreter, Java code first passes through a compiler and is then executed by the Java Virtual Machine (JVM), which prints the result on the screen: + +```text +Code Compiler + JVM Screen +┌──────────────────┐ ┌─────────────────┐ ┌──────────────┐ +│ System.out │ ──→ │ javac + JVM │ ──→ │ Hello, World!│ +│ .println(…) │ │ │ │ │ +└──────────────────┘ └─────────────────┘ └──────────────┘ +``` diff --git a/modules/10-basics/10-hello-world/en/data.yml b/modules/10-basics/10-hello-world/en/data.yml new file mode 100644 index 00000000..270a0406 --- /dev/null +++ b/modules/10-basics/10-hello-world/en/data.yml @@ -0,0 +1,8 @@ +--- +name: Hello, World! +tips: + - > + If the editor contains `// BEGIN` and `// END` lines, the code must be + written between those lines. + - | + [What is a compiler?](https://guides.hexlet.io/compiler/) diff --git a/modules/10-basics/10-hello-world/es/EXERCISE.md b/modules/10-basics/10-hello-world/es/EXERCISE.md index e2dbe21c..67f00583 100644 --- a/modules/10-basics/10-hello-world/es/EXERCISE.md +++ b/modules/10-basics/10-hello-world/es/EXERCISE.md @@ -8,4 +8,4 @@ class App { } ``` -Si escribes *heLLo, woRld!* en lugar de *¡Hola, Mundo!*, se considerará un texto diferente, ya que las mayúsculas y minúsculas son caracteres distintos. El tamaño de las letras se llama *mayúsculas y minúsculas*, y se dice: **¡las mayúsculas y minúsculas importan!** Esto se aplica a casi todo el código, así que acostúmbrate a prestar siempre atención a las mayúsculas y minúsculas. +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 la letra se llama *mayúsculas y minúsculas* (*case*), y se dice: **¡las mayúsculas y minúsculas importan!** 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. diff --git a/modules/10-basics/10-hello-world/es/README.md b/modules/10-basics/10-hello-world/es/README.md index c00fa482..71986d05 100644 --- a/modules/10-basics/10-hello-world/es/README.md +++ b/modules/10-basics/10-hello-world/es/README.md @@ -1,39 +1,69 @@ -Tradicionalmente, se comienza a aprender un lenguaje de programación con el programa "Hello, World!", que muestra este texto en la pantalla. +Tradicionalmente, aprender un lenguaje de programación comienza con el programa "Hello, World!", que muestra este texto en la pantalla. ```text -¡Hola, Mundo! +Hello, World! ``` -En Java, este programa se vería así: +En Java, este programa se ve así: ```java class App { public static void main(String[] args) { - System.out.println("¡Hola, Mundo!"); + System.out.println("Hello, World!"); } } ``` -El texto *¡Hola, Mundo!* aparecerá en la pantalla gracias al comando `System.out.println()`, donde `println()` es una abreviatura de la expresión en inglés *print line*. Este comando muestra en la pantalla el valor especificado entre paréntesis `("¡Hola, Mundo!")`, en este caso, una cadena de texto. La cadena de texto se encierra entre comillas dobles `""`. Si no se hace esto, el compilador mostrará un error de sintaxis: +El texto *Hello, World!* aparece en la pantalla gracias al comando `System.out.println()`, donde `println()` es la abreviatura del inglés *print line*. Muestra en la pantalla el valor indicado entre paréntesis `("Hello, World!")` — en este caso, una cadena de texto. En lugar del ejemplo, puedes mostrar cualquier otro texto: + +```java +System.out.println("Hexlet — escuela de programación"); +``` + +El comando sigue siendo el mismo; solo cambia el contenido de los paréntesis. + +Para que el programa entienda que entre los paréntesis hay texto, este se encierra entre comillas. En Java, una cadena siempre se enmarca con comillas **dobles** `"..."`. No se pueden usar comillas simples `'...'` para una cadena: en ellas se escribe un único carácter (el tipo `char`), por ejemplo `'A'`. Si enmarcas una cadena con comillas simples, el compilador señalará un error de sintaxis: ```bash # Por ejemplo, así App.java:5: error: unclosed character literal -System.out.println('¡Hola, Mundo!'); +System.out.println('Hello, World!'); ``` -Este comando se encuentra dentro de varias construcciones que son necesarias incluso para los programas más simples en Java. En este caso, se trata de la clase `App` y el método `main()`. +El comando en sí se encuentra dentro de varias construcciones que son necesarias incluso para los programas más simples en Java. En este caso, se trata de la clase `App` y el método `main()`. + +Por ahora no nos detendremos en ellas, ya que para entenderlas hace falta saber programar un poco. Por eso, en muchos ejercicios se dan "tal cual", es decir, no tendrás que escribirlas tú mismo. Cuando llegue el momento, las analizaremos. + +## El significado de los símbolos -Por ahora, no nos detendremos en ellos, ya que para entenderlos es necesario tener un poco de conocimiento en programación. Por lo tanto, en muchos ejercicios se proporcionan "tal cual", es decir, no tendrás que definirlos tú mismo. Cuando llegue el momento, los analizaremos. +El código se compone de comandos, y cada uno de ellos debe escribirse de una forma determinada. Además de las letras, en el código importan las comillas `"`, los paréntesis `()`, las llaves `{}` y el punto y coma `;`. Un símbolo omitido o confundido hará que el programa no compile. ¿Puedes averiguar qué error hay en cada una de las líneas? -## JShell +```java +System.out.println("I am the King"); +System.out.println("I am the King"; +System.out.println(I am the King"); +System.ouprintln("I am the King"); +System.out.println("I am the King") +``` -A medida que avances en las lecciones, te encontrarás constantemente con ejemplos de código y descripciones de su funcionamiento. Para comprenderlos mejor y poder utilizar el lenguaje, es necesario practicar y experimentar constantemente. +Incluso una pequeña diferencia — una letra de más, un paréntesis perdido o un `;` olvidado — 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. Si en un texto normal `Hola` y `hola` se ven iguales, para Java son palabras distintas. Java considera `println`, `Println` y `PRINTLN` como nombres diferentes, y solo funcionará la primera opción. -Por lo tanto, siempre que sea posible, ejecuta todos los ejemplos de la teoría y realiza experimentos con los aspectos que no entiendas. +## Dónde practicar -La forma más sencilla de comenzar con Java es en el sitio web [onecompiler](https://onecompiler.com/jshell), que te permite ejecutar el código línea por línea directamente en el navegador. Intenta ir allí ahora mismo y escribir este código: +La teoría se asimila mejor cuando ejecutas el código en paralelo y ves el resultado. A medida que avances por las lecciones, te encontrarás constantemente con ejemplos de código y descripciones de su funcionamiento. Para entenderlos mejor y saber usar el lenguaje, hay que practicar y experimentar constantemente — siempre que sea posible, ejecuta todos los ejemplos de la teoría. + +Lo más fácil para empezar con Java es el sitio [onecompiler](https://onecompiler.com/jshell), que permite ejecutar el código línea por línea directamente en el navegador con JShell. Intenta ir allí ahora mismo y escribir este código: ```text System.out.println(85 * 3); ``` + +¿Cómo funciona esto técnicamente? A diferencia de los lenguajes que se ejecutan línea por línea con un intérprete, el código en Java primero pasa por un compilador y luego lo ejecuta la máquina virtual de Java (JVM), que muestra el resultado en la pantalla: + +```text +Código Compilador + JVM Pantalla +┌──────────────────┐ ┌─────────────────┐ ┌──────────────┐ +│ System.out │ ──→ │ javac + JVM │ ──→ │ Hello, World!│ +│ .println(…) │ │ │ │ │ +└──────────────────┘ └─────────────────┘ └──────────────┘ +``` diff --git a/modules/10-basics/20-comments/App.java b/modules/10-basics/20-comments/App.java index 2795fbf0..9aee1d21 100644 --- a/modules/10-basics/20-comments/App.java +++ b/modules/10-basics/20-comments/App.java @@ -1,7 +1,7 @@ class App { public static void main(String[] args) { // BEGIN - // TODO: добавить метод приветствия + // TODO: add a greeting method // END } } diff --git a/modules/10-basics/20-comments/en/EXERCISE.md b/modules/10-basics/20-comments/en/EXERCISE.md new file mode 100644 index 00000000..5ed1e028 --- /dev/null +++ b/modules/10-basics/20-comments/en/EXERCISE.md @@ -0,0 +1,9 @@ +You're writing a program and realize that one part needs to be finished later. So as not to forget, programmers leave themselves notes right in the code — TODO comments. + +Add the following single-line comment to the file: + +```text +// TODO: add a greeting method +``` + +When you come back to this spot later, the comment will remind you that there's still unfinished work here. diff --git a/modules/10-basics/20-comments/en/README.md b/modules/10-basics/20-comments/en/README.md new file mode 100644 index 00000000..892017dc --- /dev/null +++ b/modules/10-basics/20-comments/en/README.md @@ -0,0 +1,64 @@ +Almost all programming languages let you leave comments in the code. Comments are not used by the code and are meant solely for people: so that a programmer can leave notes for themselves and for other programmers, explain how the code works, mark errors, or remind themselves of what still needs to be done. + +```java +// Delete the line below after implementing the registration task +System.out.println(10); +``` + +The compiler completely ignores comments — they don't affect how the program runs: + +```text +// comment ──→ [ skipped by the compiler ] +System.out.println("hello"); ──→ [ executed → hello ] +// another one ──→ [ skipped by the compiler ] +``` + +There are three kinds of comments in Java: + +**Single-line comments** start with `//`. Any text can follow these two characters; the entire line will not be analyzed or executed. + +A comment can take up the whole line: + +```java +// For Winterfell! +``` + +A comment can also be on the same line after some code: + +```java +System.out.println("I am the King"); // => For Lannisters! +``` + +**Multi-line comments** start with `/*` and end with `*/`. It is customary to start each line with the `*` character, although technically this is not required: + +```java +/* +* The night is dark and +* full of terrors. +*/ +System.out.println("I am the King"); // => I am the King +``` + +**Documentation comments** start with `/**` and end with `*/`. For these, it is required to start each line with the `*` character. + +Documentation comments are a subtype of multi-line comments. In addition, they serve an extra function — they can be collected using the special javadoc tool and produced as documentation for your code. We'll talk about them later, when we cover classes and methods. + +## Service comments + +While working, you'll come across code like this in our editor: + +```java +// BEGIN + +// END +``` + +*BEGIN* and *END* here are ordinary single-line comments that don't affect how the program runs at all. They show where to write the code for the exercise. + +```java +// BEGIN + +// END +``` + +When you see *BEGIN* and *END*, write your code between them and leave the rest unchanged. diff --git a/modules/10-basics/20-comments/en/data.yml b/modules/10-basics/20-comments/en/data.yml new file mode 100644 index 00000000..aa38faca --- /dev/null +++ b/modules/10-basics/20-comments/en/data.yml @@ -0,0 +1,11 @@ +--- +name: Comments +tips: + - > + [More about + comments](https://www.w3schools.com/java/java_comments.asp) +definitions: + - name: Comment + description: > + text in a program's code that does not affect functionality and is added + by programmers for themselves and their colleagues. diff --git a/modules/10-basics/20-comments/es/EXERCISE.md b/modules/10-basics/20-comments/es/EXERCISE.md index 8babe757..ab5924d9 100644 --- a/modules/10-basics/20-comments/es/EXERCISE.md +++ b/modules/10-basics/20-comments/es/EXERCISE.md @@ -1,5 +1,9 @@ -Crea un comentario de una línea con el texto: +Estás escribiendo un programa y te das cuenta de que una parte hay que terminarla más tarde. Para no olvidarlo, los programadores se dejan notas directamente en el código: los comentarios TODO. + +Agrega al archivo el siguiente comentario de una línea: ```text -No sabes nada, Jon Nieve! +// TODO: agregar un método de saludo ``` + +Cuando vuelvas a este punto más tarde, el comentario te recordará que aquí todavía queda trabajo por hacer. diff --git a/modules/10-basics/20-comments/es/README.md b/modules/10-basics/20-comments/es/README.md index 06d5e16f..38197502 100644 --- a/modules/10-basics/20-comments/es/README.md +++ b/modules/10-basics/20-comments/es/README.md @@ -1,31 +1,64 @@ -Casi todos los lenguajes de programación permiten dejar comentarios en el código. Estos comentarios no son utilizados por el código y son únicamente para las personas: para que los programadores dejen notas para sí mismos y para otros programadores. +Casi todos los lenguajes de programación permiten dejar comentarios en el código. Los comentarios no son utilizados por el código y sirven únicamente para las personas: para que el programador deje notas para sí mismo y para otros programadores, explique cómo funciona el código, marque errores o recuerde lo que aún queda por hacer. -En Java, hay tres tipos de comentarios: +```java +// Eliminar la línea de abajo tras implementar la tarea de registro +System.out.println(10); +``` -* **Comentarios de una línea** que comienzan con `//`. Después de estos dos caracteres puede seguir cualquier texto, la línea completa no será analizada ni ejecutada. +El compilador ignora por completo los comentarios: no afectan al funcionamiento del programa: - El comentario puede ocupar toda la línea: +```text +// comentario ──→ [ omitido por el compilador ] +System.out.println("hello"); ──→ [ ejecutado → hello ] +// otro más ──→ [ omitido por el compilador ] +``` - ```java - // Por Winterfell! - ``` +En Java hay tres tipos de comentarios: - También el comentario puede estar en la línea después de algún código: +**Comentarios de una línea** que comienzan con `//`. Después de estos dos caracteres puede seguir cualquier texto; la línea completa no será analizada ni ejecutada. - ```java - System.out.println("Soy el Rey"); // => Por los Lannister! - ``` +El comentario puede ocupar toda la línea: -* **Comentarios de varias líneas** que comienzan con `/*` y terminan con `*/`. Es común comenzar cada línea con el carácter `*`, aunque técnicamente no es obligatorio: +```java +// For Winterfell! +``` - ```java - /* - * La noche es oscura y - * está llena de terrores. - */ - System.out.println("Soy el Rey"); // => Soy el Rey - ``` +También el comentario puede estar en la línea, después de algún código: -* **Comentarios de documentación** que comienzan con `/**` y terminan con `*/`. Para estos comentarios es obligatorio comenzar cada línea con el carácter `*`. +```java +System.out.println("I am the King"); // => For Lannisters! +``` - Los comentarios de documentación son un subtipo de los comentarios de varias líneas. Además, tienen una función adicional: se pueden recopilar con la herramienta especial javadoc y se pueden generar como documentación para su código. Hablaremos de ellos más adelante, cuando veamos las clases y los métodos. +**Comentarios de varias líneas** que comienzan con `/*` y terminan con `*/`. Es común comenzar cada línea con el carácter `*`, aunque técnicamente no es obligatorio: + +```java +/* +* The night is dark and +* full of terrors. +*/ +System.out.println("I am the King"); // => I am the King +``` + +**Comentarios de documentación** que comienzan con `/**` y terminan con `*/`. Para estos ya es obligatorio comenzar cada línea con el carácter `*`. + +Los comentarios de documentación son un subtipo de los comentarios de varias líneas. Además, cumplen una función adicional: se pueden recopilar con la herramienta especial javadoc y generar como documentación de tu código. Hablaremos de ellos más adelante, cuando veamos las clases y los métodos. + +## Comentarios de servicio + +Durante el trabajo te encontrarás con este código en nuestro editor: + +```java +// BEGIN + +// END +``` + +*BEGIN* y *END* aquí son comentarios de una línea normales que no afectan en absoluto al funcionamiento del programa. Indican dónde escribir el código del ejercicio. + +```java +// BEGIN + +// END +``` + +Cuando veas *BEGIN* y *END*, escribe tu código entre ellos y deja el resto sin cambios. diff --git a/modules/10-basics/20-comments/es/data.yml b/modules/10-basics/20-comments/es/data.yml index f783cf65..cd81113a 100644 --- a/modules/10-basics/20-comments/es/data.yml +++ b/modules/10-basics/20-comments/es/data.yml @@ -1,2 +1,11 @@ --- name: Comentarios +tips: + - > + [Más sobre los + comentarios](https://www.w3schools.com/java/java_comments.asp) +definitions: + - name: Comentario + description: > + texto en el código de un programa que no afecta a la funcionalidad y es + añadido por los programadores para sí mismos y sus colegas. diff --git a/modules/10-basics/30-statements/en/EXERCISE.md b/modules/10-basics/30-statements/en/EXERCISE.md new file mode 100644 index 00000000..9daf8bc7 --- /dev/null +++ b/modules/10-basics/30-statements/en/EXERCISE.md @@ -0,0 +1,9 @@ +Print three names on the screen one after another: *Robert*, *Stannis*, *Renly*. As a result, the screen should display: + +```text +Robert +Stannis +Renly +``` + +Use a separate `System.out.println()` call for each name. diff --git a/modules/10-basics/30-statements/en/README.md b/modules/10-basics/30-statements/en/README.md new file mode 100644 index 00000000..0c2ae33c --- /dev/null +++ b/modules/10-basics/30-statements/en/README.md @@ -0,0 +1,73 @@ +A statement is a command for the computer. Java code is a set of statements, and each of them ends with a `;` character. There can be as many such statements as you like: each one runs after the previous one has finished, and this is how a program of any size and complexity is built from simple elements. + +```text +Statement 1: System.out.println("Hello"); → executed + ↓ +Statement 2: System.out.println("World"); → executed + ↓ +Statement 3: System.out.println("!"); → executed +``` + +Here is an example of code with two statements. These lines tell the computer to print phrases on the screen: + +```java +System.out.println("Mother of Dragons"); // First statement +System.out.println("Dracarys!"); // Second statement +``` + +When this code runs, two sentences are printed on the screen one after another: + +```text +Mother of Dragons +Dracarys! +``` + +## Order matters + +Java runs the code strictly in the order in which you wrote it. If you swap the lines: + +```java +System.out.println("Dracarys!"); +System.out.println("Mother of Dragons"); +``` + +they will swap on the screen too: + +```text +Dracarys! +Mother of Dragons +``` + +## Ending statements + +In Java, the `;` character is mandatory — it marks the end of each statement. If you forget it, the compiler will report an error. Thanks to `;`, several statements can even be written on a single line: + +```java +System.out.println("Mother of Dragons"); System.out.println("Dracarys!"); +``` + +The result on the screen will be the same, but in practice this approach is considered bad: the code is harder to read. That's why statements are almost always written one per line. + +## Why this matters + +Right now we're writing very simple programs, but over time they will start to get more complex. One of the most important skills that will help you understand them is the ability to mentally break a program down into independent statements. Only this way can you figure out what's happening in the code. Below is an example to grab your attention; you don't need to understand it yet: + +```java +static boolean isPrime(int number) { + if (number < 2) { + return false; + } + + int divider = 2; + + while (divider <= number / 2) { + if (number % divider == 0) { + return false; + } + + divider++; + } + + return true; +} +``` diff --git a/modules/10-basics/30-statements/en/data.yml b/modules/10-basics/30-statements/en/data.yml new file mode 100644 index 00000000..866f3345 --- /dev/null +++ b/modules/10-basics/30-statements/en/data.yml @@ -0,0 +1,14 @@ +--- +name: Statements +tips: + - | + [What is a compiler?](https://guides.hexlet.io/compiler/) +definitions: + - name: Compiler + description: >- + a program that converts Java source code into a format executed by the + Java Virtual Machine (JVM). + - name: Statement + description: >- + a command for the computer written in a programming language. Java code + is a set of statements, each of which ends with a `;` character. diff --git a/modules/10-basics/30-statements/es/EXERCISE.md b/modules/10-basics/30-statements/es/EXERCISE.md index c70e3289..90658c7d 100644 --- a/modules/10-basics/30-statements/es/EXERCISE.md +++ b/modules/10-basics/30-statements/es/EXERCISE.md @@ -1,4 +1,4 @@ -Imprime en pantalla uno tras otro tres nombres: *Robert*, *Stannis*, *Renly*. Como resultado, se mostrará en pantalla: +Muestra en la pantalla, uno tras otro, tres nombres: *Robert*, *Stannis*, *Renly*. Como resultado, en la pantalla debería aparecer: ```text Robert @@ -6,4 +6,4 @@ Stannis Renly ``` -Utiliza una llamada `System.out.println()` para cada nombre. +Usa una llamada `System.out.println()` propia para cada nombre. diff --git a/modules/10-basics/30-statements/es/README.md b/modules/10-basics/30-statements/es/README.md index 0172056a..af3f40bf 100644 --- a/modules/10-basics/30-statements/es/README.md +++ b/modules/10-basics/30-statements/es/README.md @@ -1,23 +1,73 @@ -Una instrucción es un comando para la computadora. El código en Java es un conjunto de instrucciones que generalmente se separan entre sí con el símbolo `;`. Aquí hay un ejemplo de código con dos instrucciones: +Una instrucción es un comando para la computadora. El código en Java es un conjunto de instrucciones, y cada una de ellas termina con el carácter `;`. Puede haber tantas instrucciones como quieras: cada una se ejecuta después de que la anterior haya terminado, y así, a partir de elementos simples, se obtiene un programa tan grande y complejo como se desee. + +```text +Instrucción 1: System.out.println("Hello"); → ejecutada + ↓ +Instrucción 2: System.out.println("World"); → ejecutada + ↓ +Instrucción 3: System.out.println("!"); → ejecutada +``` + +Aquí tienes un ejemplo de código con dos instrucciones. Estas líneas le dicen a la computadora que muestre frases en la pantalla: + +```java +System.out.println("Mother of Dragons"); // Primera instrucción +System.out.println("Dracarys!"); // Segunda instrucción +``` + +Al ejecutar este código, se muestran en la pantalla dos frases una tras otra: + +```text +Mother of Dragons +Dracarys! +``` + +## El orden importa + +Java ejecuta el código estrictamente en el orden en que lo escribiste. Si intercambias las líneas: ```java -System.out.println("Madre de Dragones"); -System.out.println("¡Dracarys!"); +System.out.println("Dracarys!"); +System.out.println("Mother of Dragons"); ``` -Al ejecutar este código, se mostrarán en pantalla dos frases de forma secuencial: +en la pantalla también se intercambiarán: ```text -Madre de Dragones -¡Dracarys! +Dracarys! +Mother of Dragons ``` -¿Por qué es importante saber esto? Una instrucción es una unidad de ejecución. El programa que ejecuta el código en Java realiza las instrucciones estrictamente en orden. Los desarrolladores deben comprender este orden y ser capaces de dividir mentalmente el programa en partes independientes que sean fáciles de analizar. +## Finalización de las instrucciones -Teóricamente, las instrucciones se pueden escribir una tras otra sin saltar a una nueva línea: +En Java, el carácter `;` es obligatorio: marca el final de cada instrucción. Si lo olvidas, el compilador informará de un error. Gracias al `;`, incluso se pueden escribir varias instrucciones en una sola línea: ```java -System.out.println("Madre de Dragones."); System.out.println("¡Dracarys!"); +System.out.println("Mother of Dragons"); System.out.println("Dracarys!"); ``` -El resultado en pantalla será el mismo, pero en la práctica, este enfoque se considera incorrecto. +El resultado en la pantalla será el mismo, pero en la práctica este enfoque se considera malo: el código es más difícil de leer. Por eso, las instrucciones casi siempre se escriben una por línea. + +## Para qué sirve + +Ahora escribimos programas muy simples, pero con el tiempo empezarán a complicarse. Una de las habilidades más importantes que te ayudará a entenderlos es la capacidad de dividir mentalmente el programa en instrucciones independientes. Solo así se puede comprender qué ocurre en el código. A continuación, un ejemplo para captar tu atención; por ahora no hace falta entenderlo: + +```java +static boolean isPrime(int number) { + if (number < 2) { + return false; + } + + int divider = 2; + + while (divider <= number / 2) { + if (number % divider == 0) { + return false; + } + + divider++; + } + + return true; +} +``` diff --git a/modules/10-basics/30-statements/es/data.yml b/modules/10-basics/30-statements/es/data.yml index cddd14af..36b3ce55 100644 --- a/modules/10-basics/30-statements/es/data.yml +++ b/modules/10-basics/30-statements/es/data.yml @@ -1,2 +1,15 @@ --- -name: Instrucciones +name: Instrucciones (Statements) +tips: + - | + [¿Qué es un compilador?](https://codica.la/guides/compiler/) +definitions: + - name: Compilador + description: >- + programa que transforma el código fuente de Java a un formato que ejecuta + la máquina virtual de Java (JVM). + - name: Instrucción (statement) + description: >- + comando para la computadora escrito en un lenguaje de programación. El + código en Java es un conjunto de instrucciones, cada una de las cuales + termina con el carácter `;`. diff --git a/modules/10-basics/40-testing/en/EXERCISE.md b/modules/10-basics/40-testing/en/EXERCISE.md new file mode 100644 index 00000000..c3aabe27 --- /dev/null +++ b/modules/10-basics/40-testing/en/EXERCISE.md @@ -0,0 +1,7 @@ +Just practice. Print the number 420262531 on the screen. + +```text +420262531 +``` + +Experiment with the output. Pass a different number or a string. Look at the system's response, try to translate it and understand it. diff --git a/modules/10-basics/40-testing/en/README.md b/modules/10-basics/40-testing/en/README.md new file mode 100644 index 00000000..148c92c8 --- /dev/null +++ b/modules/10-basics/40-testing/en/README.md @@ -0,0 +1,23 @@ +Our website automatically checks your solutions. How does it work? + +In the simplest case, the system just runs your code and looks at what was printed on the screen. Then it compares that with what we "expected" according to the exercise. + +In the following, more complex lessons, you'll write methods — small programs that take information from the outside world and perform some operations. Checking your solutions in such cases looks a bit more complicated: the system runs your solution and passes it some information. The system also knows — "expects" — exactly which answer the correct method should return for such input data. + +For example, if your task is to write code that adds two numbers, the checking system will pass it different combinations of numbers and compare your code's answer with the actual sums. If the answers match in all cases, the solution is considered correct. + +Here's a simple example: in one of the future lessons, you'll need to write code that performs calculations and produces an answer. Suppose you made a small mistake, and the method produced the wrong number. The system will respond something like this: + +```text +expected: "35" but was: "10" +``` + +The most important part comes after the colon: "expected: "35", but was "10"". That is, the correct code should have produced 35, but the current solution works incorrectly and produces 10. + +This approach is called testing, and it's used in real-world development. Tests help check whether a program works correctly and quickly spot an error after changes. That's exactly why our website says "Tests passed" when you've solved the task correctly. + +## Is it my mistake or not? + +Sometimes, while solving, it will seem that you did everything right, but the system is "being capricious" and won't accept the solution. This behavior is practically impossible. Non-working tests simply can't make it onto the website; they run automatically after every change. In the overwhelming majority of such cases (and all our projects combined have run millions of checks over many years), the error is in the solution code. It can be very subtle: instead of an English letter you accidentally typed a Russian one, you used lowercase instead of uppercase, or you forgot to print a comma. Other cases are trickier. Perhaps your solution works for one set of input data but not for another. So always read the task description and the test output carefully. There is almost certainly an indication of the error there. + +However, if you're sure of an error or have found some inaccuracy, you can always point it out. At the end of each theory there's a link to the lesson's content on GitHub (this project is completely open!). Going there, you can write an issue, look at the contents of the tests (there you can see how your code is called), and even submit a pull request. If this is still a mystery to you for now, join our community [Hexlet community on Telegram](https://t.me/hexletcommunity/12); there, in the Volunteers channel, we'll always help. diff --git a/modules/10-basics/40-testing/en/data.yml b/modules/10-basics/40-testing/en/data.yml new file mode 100644 index 00000000..fe22b495 --- /dev/null +++ b/modules/10-basics/40-testing/en/data.yml @@ -0,0 +1,12 @@ +--- +name: How we check your solutions +definitions: + - name: Tests + description: > + special code that checks programs for correctness by comparing the correct + result with the actual one. +tips: + - | + [TDD](https://en.wikipedia.org/wiki/Test-driven_development) + - | + [Hexlet community on Telegram](https://t.me/hexletcommunity/12) diff --git a/modules/10-basics/40-testing/es/README.md b/modules/10-basics/40-testing/es/README.md index 42248fd2..42ba1193 100644 --- a/modules/10-basics/40-testing/es/README.md +++ b/modules/10-basics/40-testing/es/README.md @@ -1,21 +1,23 @@ Nuestro sitio web verifica automáticamente tus soluciones. ¿Cómo funciona? -En el caso más simple, el sistema simplemente ejecuta tu código y verifica lo que se muestra en la pantalla. Luego lo compara con lo que "esperábamos" según la tarea. +En el caso más simple, el sistema simplemente ejecuta tu código y observa lo que se mostró en la pantalla. Luego lo compara con lo que "esperábamos" según la tarea. -En lecciones más avanzadas, escribirás métodos, que son pequeños programas que toman información del mundo exterior y realizan ciertas operaciones. La verificación de tus soluciones en estos casos es un poco más complicada: el sistema ejecuta tu solución y le pasa cierta información. El sistema también sabe qué respuesta exacta debería devolver el método correcto para esos datos de entrada. +En las siguientes lecciones, más complejas, escribirás métodos: pequeños programas que toman información del mundo exterior y realizan algunas operaciones. La verificación de tus soluciones en estos casos es un poco más complicada: el sistema ejecuta tu solución y le pasa cierta información. El sistema también sabe —"espera"— qué respuesta exacta debe devolver el método correcto para esos datos de entrada. -Por ejemplo, si tu tarea es escribir código para sumar dos números, el sistema de verificación le pasará diferentes combinaciones de números y comparará la respuesta de tu código con las sumas reales. Si las respuestas coinciden en todos los casos, la solución se considera correcta. +Por ejemplo, si tu tarea es escribir código que sume dos números, el sistema de verificación le pasará diferentes combinaciones de números y comparará la respuesta de tu código con las sumas reales. Si las respuestas coinciden en todos los casos, la solución se considera correcta. -Aquí tienes un ejemplo sencillo: en una de las futuras lecciones, tendrás que escribir código que realice cálculos y devuelva una respuesta. Supongamos que cometiste un pequeño error y el método devolvió un número incorrecto. El sistema responderá algo como esto: +Aquí tienes un ejemplo sencillo: en una de las lecciones futuras, tendrás que escribir código que realice cálculos y devuelva una respuesta. Supongamos que cometiste un pequeño error y el método devolvió un número incorrecto. El sistema responderá algo así: ```text expected: "35" but was: "10" ``` -Lo más importante comienza después de los dos puntos: "se esperaba: "35", pero fue "10"". Es decir, el código correcto debería haber devuelto 35, pero la solución actual no funciona correctamente y devuelve 10. +Lo más importante empieza después de los dos puntos: "se esperaba: "35", pero fue "10"". Es decir, el código correcto debería haber devuelto 35, pero la solución actual funciona mal y devuelve 10. ---- +Este enfoque se llama testing (pruebas) y se usa en el desarrollo real. Las pruebas ayudan a comprobar si un programa funciona correctamente y a detectar rápidamente un error tras los cambios. Precisamente por eso nuestro sitio dice "Pruebas superadas" cuando has resuelto la tarea correctamente. -A veces, durante el proceso de resolución, puede parecer que has hecho todo correctamente, pero el sistema se "comporta de manera caprichosa" y no acepta la solución. Este comportamiento es prácticamente imposible. Las pruebas no funcionales simplemente no pueden llegar al sitio web, se ejecutan automáticamente después de cada cambio. En la gran mayoría de estos casos (y todos nuestros proyectos en conjunto han realizado millones de verificaciones a lo largo de los años), el error se encuentra en el código de la solución. Puede ser muy sutil, como haber ingresado accidentalmente una letra rusa en lugar de una letra en inglés, haber utilizado minúsculas en lugar de mayúsculas o haber olvidado poner una coma. Otros casos son más complicados. Es posible que tu solución funcione para un conjunto de datos de entrada, pero no funcione para otro. Por lo tanto, siempre lee atentamente la descripción de la tarea y los resultados de las pruebas. Casi seguro que habrá alguna indicación del error. +## ¿Es mi error o no? -Sin embargo, si estás seguro del error o has encontrado alguna imprecisión, siempre puedes señalarlo. Al final de cada teoría hay un enlace al contenido de la lección en GitHub (¡este proyecto es completamente abierto!). Al ir allí, puedes escribir un issue, ver el contenido de las pruebas (se puede ver cómo se llama tu código) e incluso enviar un pull request. Si esto todavía te resulta confuso, únete a nuestra comunidad en [Comunidad de Hexlet en Telegram](https://t.me/hexletcommunity/12), allí en el canal de Voluntarios siempre estaremos dispuestos a ayudar. +A veces, durante la resolución, parecerá que hiciste todo bien, pero el sistema "se pone caprichoso" y no acepta la solución. Este comportamiento es prácticamente imposible. Las pruebas que no funcionan simplemente no pueden llegar al sitio; se ejecutan automáticamente después de cada cambio. En la gran mayoría de estos casos (y todos nuestros proyectos en conjunto han realizado millones de verificaciones a lo largo de los años), el error está en el código de la solución. Puede ser muy sutil: en lugar de una letra en inglés escribiste por accidente una rusa, usaste minúsculas en lugar de mayúsculas u olvidaste mostrar una coma. Otros casos son más complicados. Es posible que tu solución funcione para un conjunto de datos de entrada, pero no para otro. Por eso, lee siempre con atención el enunciado de la tarea y la salida de las pruebas. Casi seguro que allí hay una indicación del error. + +Sin embargo, si estás seguro de un error o has encontrado alguna imprecisión, siempre puedes señalarlo. Al final de cada teoría hay un enlace al contenido de la lección en GitHub (¡este proyecto es completamente abierto!). Al ir allí, puedes escribir un issue, ver el contenido de las pruebas (allí se ve cómo se llama tu código) e incluso enviar un pull request. Si por ahora esto te resulta un mundo desconocido, únete a nuestra comunidad [Comunidad de Hexlet en Telegram](https://t.me/hexletcommunity/12); allí, en el canal de Voluntarios, siempre te ayudaremos. diff --git a/modules/10-basics/50-syntax-error/en/EXERCISE.md b/modules/10-basics/50-syntax-error/en/EXERCISE.md new file mode 100644 index 00000000..268bcc23 --- /dev/null +++ b/modules/10-basics/50-syntax-error/en/EXERCISE.md @@ -0,0 +1,13 @@ +Write a program that prints on the screen: + +```text +What Is Dead May Never Die +``` + +Once the program works, deliberately break it — make one of the syntax errors: + +- remove the closing quote `"`; +- remove the closing parenthesis `)`; +- remove the semicolon `;` at the end of the line. + +Run the code and read the compiler's message. You'll see such messages often — it's important to learn to read them. Then restore the working version so the exercise passes the check. diff --git a/modules/10-basics/50-syntax-error/en/README.md b/modules/10-basics/50-syntax-error/en/README.md new file mode 100644 index 00000000..66a59e51 --- /dev/null +++ b/modules/10-basics/50-syntax-error/en/README.md @@ -0,0 +1,52 @@ +In human languages grammar matters, but text with errors can usually still be understood and read. In programming, everything is strict. The slightest violation, and the program won't run. + +An example is a forgotten `;`, incorrectly placed parentheses, and other details. Such errors are called **syntax errors**, because they break the rules of the language's syntax. + +## What is a syntax error? + +A syntax error is a violation of the grammatical rules for writing code in a specific programming language. Such errors occur when code is written with a deviation from the expected format: an unclosed string, a missing parenthesis or semicolon, a wrong order of characters, and so on. + +```text +Code with an error Compiler Result +┌──────────────────┐ ┌─────────────┐ ┌──────────────────┐ +│ println("Hi" │ ──> │ javac │ ──> │ error: ')' or │ +└──────────────────┘ └─────────────┘ │ ';' expected │ + └──────────────────┘ +``` + +Unlike natural languages, where text with errors can be understood from context, in programming even the slightest deviation makes the code non-functional. + +If a Java program is written syntactically incorrectly, the compiler prints on the screen: + +* An error message +* An indication of the file +* The line in the file where, in its opinion, the error occurred + +Below is an example of code with a syntax error: + +```java +System.out.println("alala +``` + +If you run the code above, we'll see the following message: + +```text +| Error: +| unclosed string literal +| System.out.println("alala +``` + +## Why are such errors considered simple? + +Syntax errors: + +- are easy to notice: the code is often highlighted in the editor; +- are easy to fix: it's enough to restore the missing character (`"`, `)`, `;`) or fix the structure. + +But there's a fly in the ointment. The compiler doesn't always point exactly to the place where the error was made. Sometimes the problem is a few lines higher. For example, a parenthesis that's opened but not closed on one line can "break" all the following code. + +## What to do with a syntax error? + +- Read the error message. It almost always contains useful information — the type of error and the line where the compiler "stumbled". +- Check the line indicated in the message, and the line before it: sometimes the error is "hidden" a bit earlier (a forgotten `;` on the previous line). +- Use an [editor with syntax highlighting](https://code.visualstudio.com/): it will help you immediately spot unclosed quotes, parentheses, or missing characters. diff --git a/modules/10-basics/50-syntax-error/en/data.yml b/modules/10-basics/50-syntax-error/en/data.yml new file mode 100644 index 00000000..b31ad713 --- /dev/null +++ b/modules/10-basics/50-syntax-error/en/data.yml @@ -0,0 +1,13 @@ +--- +name: Formatting (syntax) errors +tips: + - > + [Editor with syntax + highlighting](https://code.visualstudio.com/) +definitions: + - name: Compiler + description: >- + A program that converts source code into a low-level language suitable + for execution. + - name: Syntax error + description: A violation of the grammatical rules of a programming language. diff --git a/modules/10-basics/50-syntax-error/es/EXERCISE.md b/modules/10-basics/50-syntax-error/es/EXERCISE.md index 4b773853..0f48715d 100644 --- a/modules/10-basics/50-syntax-error/es/EXERCISE.md +++ b/modules/10-basics/50-syntax-error/es/EXERCISE.md @@ -1,2 +1,13 @@ +Escribe un programa que muestre en la pantalla: -Esta tarea no está directamente relacionada con la lección, pero será útil practicar la salida en pantalla. Imprime en pantalla *What Is Dead May Never Die*. +```text +What Is Dead May Never Die +``` + +Una vez que el programa funcione, rómpelo a propósito: comete uno de los errores de sintaxis: + +- quita la comilla de cierre `"`; +- quita el paréntesis de cierre `)`; +- quita el punto y coma `;` al final de la línea. + +Ejecuta el código y lee el mensaje del compilador. Verás estos mensajes a menudo, y es importante aprender a leerlos. Después, restaura la versión que funciona para que el ejercicio pase la verificación. diff --git a/modules/10-basics/50-syntax-error/es/README.md b/modules/10-basics/50-syntax-error/es/README.md index 06821519..9e75d9f1 100644 --- a/modules/10-basics/50-syntax-error/es/README.md +++ b/modules/10-basics/50-syntax-error/es/README.md @@ -1,14 +1,28 @@ -En los lenguajes humanos, la gramática es importante, pero generalmente se puede entender y leer un texto con errores. En la programación, todo es estricto. Cualquier pequeña violación y el programa no se ejecutará. +En los lenguajes humanos la gramática es importante, pero un texto con errores casi siempre se puede entender y leer. En la programación, todo es estricto. Cualquier mínima violación, y el programa no se ejecutará. -Un ejemplo puede ser un punto y coma olvidado, paréntesis mal colocados y otros detalles. Estos errores se llaman **errores de sintaxis** porque violan las reglas de sintaxis del lenguaje. +Un ejemplo puede ser un `;` olvidado, paréntesis mal colocados y otros detalles. Estos errores se llaman **errores de sintaxis**, porque violan las reglas de sintaxis del lenguaje. -Si un programa escrito en Java es sintácticamente incorrecto, el compilador muestra en pantalla: +## ¿Qué es un error de sintaxis? + +Un error de sintaxis es una violación de las reglas gramaticales para escribir código en un lenguaje de programación concreto. Estos errores surgen cuando el código se escribe con una desviación del formato esperado: una cadena sin cerrar, un paréntesis o un punto y coma omitido, un orden de caracteres alterado, etc. + +```text +Código con error Compilador Resultado +┌──────────────────┐ ┌─────────────┐ ┌──────────────────┐ +│ println("Hi" │ ──> │ javac │ ──> │ error: ')' o │ +└──────────────────┘ └─────────────┘ │ ';' expected │ + └──────────────────┘ +``` + +A diferencia de los lenguajes naturales, donde un texto con errores se puede entender por el contexto, en la programación incluso la mínima desviación hace que el código no funcione. + +Si un programa en Java está escrito de forma sintácticamente incorrecta, el compilador muestra en la pantalla: * Un mensaje de error * Una indicación del archivo -* La línea en el archivo donde, según el compilador, ocurrió el error +* La línea del archivo donde, según él, ocurrió el error -A continuación se muestra un ejemplo de código con un error de sintaxis: +A continuación, un ejemplo de código con un error de sintaxis: ```java System.out.println("alala @@ -22,6 +36,17 @@ Si ejecutamos el código anterior, veremos el siguiente mensaje: | System.out.println("alala ``` -Por un lado, los errores de sintaxis son los más simples porque están relacionados únicamente con las reglas gramaticales de escribir código, no con el significado del código en sí. Son fáciles de corregir, solo hay que encontrar la violación en la escritura. +## ¿Por qué estos errores se consideran simples? + +Los errores de sintaxis: + +- son fáciles de detectar: el código a menudo se resalta en el editor; +- son fáciles de corregir: basta con restaurar el carácter que falta (`"`, `)`, `;`) o arreglar la estructura. + +Pero hay una pega. El compilador no siempre señala exactamente el lugar donde se cometió el error. A veces el problema está unas líneas más arriba. Por ejemplo, un paréntesis abierto pero no cerrado en una línea puede "romper" todo el código siguiente. + +## ¿Qué hacer ante un error de sintaxis? -Por otro lado, el compilador no siempre puede señalar claramente esta violación. Por lo tanto, a veces es necesario colocar el paréntesis olvidado no donde indica el mensaje de error. +- Lee el mensaje de error. Casi siempre contiene información útil: el tipo de error y la línea donde el compilador "tropezó". +- Revisa la línea indicada en el mensaje, y la línea anterior: a veces el error está "escondido" un poco antes (un `;` olvidado en la línea previa). +- Usa un [editor con resaltado de sintaxis](https://code.visualstudio.com/): te ayudará a detectar de inmediato comillas o paréntesis sin cerrar, o caracteres omitidos. diff --git a/modules/10-basics/50-syntax-error/es/data.yml b/modules/10-basics/50-syntax-error/es/data.yml index 2b436816..3d2ae7b4 100644 --- a/modules/10-basics/50-syntax-error/es/data.yml +++ b/modules/10-basics/50-syntax-error/es/data.yml @@ -1,9 +1,13 @@ --- -name: Errores de sintaxis +name: Errores de formato (sintaxis) +tips: + - > + [Editor con resaltado de + sintaxis](https://code.visualstudio.com/) definitions: - name: Compilador description: >- - Un programa que realiza la transformación del código fuente a un lenguaje - de bajo nivel adecuado para la ejecución. + Un programa que transforma el código fuente a un lenguaje de bajo nivel + adecuado para la ejecución. - name: Error de sintaxis description: Una violación de las reglas gramaticales del lenguaje de programación. diff --git a/modules/10-basics/description.en.yml b/modules/10-basics/description.en.yml new file mode 100644 index 00000000..0fd4ac20 --- /dev/null +++ b/modules/10-basics/description.en.yml @@ -0,0 +1,5 @@ +--- + +name: Java Basics +description: | + We'll learn Java from scratch, from the very basics. The first module is a springboard for writing meaningful programs. In it, we'll figure out how to give the computer a command in Java and write our first code. We'll explain what statements and comments are and why they're needed. Using the example of how your solutions are checked on the site, we'll look at what testing is and how to read test output. We'll explain why you can't break the grammatical rules of a programming language. diff --git a/modules/10-basics/description.es.yml b/modules/10-basics/description.es.yml index a1c78516..801ed83b 100644 --- a/modules/10-basics/description.es.yml +++ b/modules/10-basics/description.es.yml @@ -1,4 +1,4 @@ --- name: Fundamentos de Java description: | - Aprenderemos Java desde cero, desde los conceptos básicos. El primer módulo es una base sólida para escribir programas significativos. En él, aprenderemos cómo escribir nuestro primer código en Java. Explicaremos qué son los comentarios y para qué sirven. A través de la verificación de sus soluciones, veremos qué es la prueba y cómo leer la salida de las pruebas. + Aprenderemos Java desde cero, desde lo más básico. El primer módulo es una base para escribir programas significativos. En él, veremos cómo darle un comando a la computadora en Java y escribir nuestro primer código. Explicaremos qué son las instrucciones y los comentarios y para qué sirven. A través del ejemplo de la verificación de tus soluciones en el sitio, veremos qué es el testing y cómo leer la salida de las pruebas. Explicaremos por qué no se pueden violar las reglas gramaticales de un lenguaje de programación.