diff --git a/public/blog.css b/public/blog.css
index 7e38667..612bb93 100644
--- a/public/blog.css
+++ b/public/blog.css
@@ -84,4 +84,13 @@ pre.astro-code>code .line::before {
font-weight: var(--shiki-dark-font-weight) !important;
text-decoration: var(--shiki-dark-text-decoration) !important;
}
-}
\ No newline at end of file
+}
+
+/* isso */
+#isso-thread textarea {
+ color: black;
+}
+
+#isso-thread input {
+ color: black;
+}
diff --git a/public/img/blog/es/tutorial/1x/004.png b/public/img/blog/es/tutorial/1x/004.png
deleted file mode 100644
index 91009b1..0000000
Binary files a/public/img/blog/es/tutorial/1x/004.png and /dev/null differ
diff --git a/public/img/blog/es/tutorial/1x/009-matematicas.jpg b/public/img/blog/es/tutorial/1x/009-matematicas.jpg
new file mode 100644
index 0000000..c34d7dc
Binary files /dev/null and b/public/img/blog/es/tutorial/1x/009-matematicas.jpg differ
diff --git a/public/img/blog/es/tutorial/1x/010.jpg b/public/img/blog/es/tutorial/1x/010.jpg
new file mode 100644
index 0000000..e764e8e
Binary files /dev/null and b/public/img/blog/es/tutorial/1x/010.jpg differ
diff --git a/public/img/blog/es/tutorial/1x/011.png b/public/img/blog/es/tutorial/1x/011.png
new file mode 100644
index 0000000..18011fd
Binary files /dev/null and b/public/img/blog/es/tutorial/1x/011.png differ
diff --git a/public/img/blog/es/tutorial/1x/012.jpg b/public/img/blog/es/tutorial/1x/012.jpg
new file mode 100644
index 0000000..a66224d
Binary files /dev/null and b/public/img/blog/es/tutorial/1x/012.jpg differ
diff --git a/public/img/blog/es/tutorial/1x/013.jpg b/public/img/blog/es/tutorial/1x/013.jpg
new file mode 100644
index 0000000..471b68f
Binary files /dev/null and b/public/img/blog/es/tutorial/1x/013.jpg differ
diff --git a/src/layouts/BlogLayout.astro b/src/layouts/BlogLayout.astro
index 0f07aa9..f39d0c2 100644
--- a/src/layouts/BlogLayout.astro
+++ b/src/layouts/BlogLayout.astro
@@ -6,7 +6,7 @@ lang = lang ?? "en";
---
-
+
@@ -68,8 +68,22 @@ lang = lang ?? "en";
+
+
Comments/Comentarios
+
+
+
+
+
+
+
diff --git a/src/layouts/BlogLayoutEs.astro b/src/layouts/BlogLayoutEs.astro
new file mode 100644
index 0000000..1669028
--- /dev/null
+++ b/src/layouts/BlogLayoutEs.astro
@@ -0,0 +1,9 @@
+---
+import BlogLayout from "./BlogLayout.astro";
+
+let { frontmatter } = Astro.props;
+---
+
+
+
+
\ No newline at end of file
diff --git a/src/pages/blog/es/lenguajes-01.md b/src/pages/blog/es/lenguajes-01.md
index 3669917..5762ea3 100644
--- a/src/pages/blog/es/lenguajes-01.md
+++ b/src/pages/blog/es/lenguajes-01.md
@@ -1,5 +1,5 @@
---
-layout: ../../../layouts/BlogLayout.astro
+layout: ../../../layouts/BlogLayoutEs.astro
title: "¿Con qué lenguaje de programación se crean los lenguajes de programación?"
description: |
Vista superior de cómo funciona un lenguaje de programación
diff --git a/src/pages/blog/es/programacion-01.md b/src/pages/blog/es/programacion-01.md
index 248e8cc..b39573d 100644
--- a/src/pages/blog/es/programacion-01.md
+++ b/src/pages/blog/es/programacion-01.md
@@ -1,5 +1,5 @@
---
-layout: ../../../layouts/BlogLayout.astro
+layout: ../../../layouts/BlogLayoutEs.astro
title: "01: Programación desde cero absoluto con Zig"
description: |
Aprendé a programar desde completamente cero, utilizando el lenguaje
diff --git a/src/pages/blog/es/programacion-02.md b/src/pages/blog/es/programacion-02.md
index 4922c51..6dee32e 100644
--- a/src/pages/blog/es/programacion-02.md
+++ b/src/pages/blog/es/programacion-02.md
@@ -1,5 +1,5 @@
---
-layout: ../../../layouts/BlogLayout.astro
+layout: ../../../layouts/BlogLayoutEs.astro
title: "02: Programación desde cero absoluto con Zig: Fundamentos"
description: |
Fundamentos de la computación, programas, componentes
diff --git a/src/pages/blog/es/programacion-03.md b/src/pages/blog/es/programacion-03.md
index b58ec94..a341aa3 100644
--- a/src/pages/blog/es/programacion-03.md
+++ b/src/pages/blog/es/programacion-03.md
@@ -1,5 +1,5 @@
---
-layout: ../../../layouts/BlogLayout.astro
+layout: ../../../layouts/BlogLayoutEs.astro
title: "03: Programación desde cero: Hola mundo"
description: |
Escribí el tradicional programa "Hola mundo" por tí mismo!
diff --git a/src/pages/blog/es/programacion-04.md b/src/pages/blog/es/programacion-04.md
index f8d3327..f426918 100644
--- a/src/pages/blog/es/programacion-04.md
+++ b/src/pages/blog/es/programacion-04.md
@@ -1,5 +1,5 @@
---
-layout: ../../../layouts/BlogLayout.astro
+layout: ../../../layouts/BlogLayoutEs.astro
title: "04: Programación desde cero: Modificando el hola mundo"
description: |
Impresión, strings/cadenas y stdout.
diff --git a/src/pages/blog/es/programacion-05.md b/src/pages/blog/es/programacion-05.md
index 2ad5258..f895a1a 100644
--- a/src/pages/blog/es/programacion-05.md
+++ b/src/pages/blog/es/programacion-05.md
@@ -1,5 +1,5 @@
---
-layout: ../../../layouts/BlogLayout.astro
+layout: ../../../layouts/BlogLayoutEs.astro
title: "05: Cero a Zig: Instalando VSCode y Zig"
description: |
Instalamos Zig y VSCode en nuestro computador
diff --git a/src/pages/blog/es/programacion-06.md b/src/pages/blog/es/programacion-06.md
index 29a0fb5..70ab310 100644
--- a/src/pages/blog/es/programacion-06.md
+++ b/src/pages/blog/es/programacion-06.md
@@ -1,5 +1,5 @@
---
-layout: ../../../layouts/BlogLayout.astro
+layout: ../../../layouts/BlogLayoutEs.astro
title: "06: Cero a Zig: Terminal y Proyecto Zig"
description: |
Veremos el terminal y cómo crear/ejecutar un proyecto de Zig
diff --git a/src/pages/blog/es/programacion-07.md b/src/pages/blog/es/programacion-07.md
index e238aec..c9f71ba 100644
--- a/src/pages/blog/es/programacion-07.md
+++ b/src/pages/blog/es/programacion-07.md
@@ -1,8 +1,8 @@
---
-layout: ../../../layouts/BlogLayout.astro
-title: "07: Cero a Zig - Variables"
+layout: ../../../layouts/BlogLayoutEs.astro
+title: "07: Cero a Zig - Impresión con formatos"
description: |
- Introducción a las variables
+ Imprimiendo información adicional.
pubDate: "2024-08-10"
tags: ["tech", "lenguajes", "intro", "tutorial", "zig", "VSCode"]
image:
@@ -11,214 +11,76 @@ image:
caption: ""
---
-Ahora veremos un concepto fundamental: Variables.
+En este artículo aprenderemos más acerca de la impresión,
+especialmente un aspecto importante para futúros artículos:
+formatos.
-Todo el código lo escribiremos en el proyecto que creamos
-en el artículo anterior.
+## Formato de impresión
-
-## Motivación
-
-Vamos a plantear un escenario: Queremos escribir un programa
-que salude a una persona, le diga cuanto cuesta su orden,
-y se despida.
-
-Digamos que la persona se llama `Juan`. El código es así:
+El código para imprimir texto tiene dos partes:
```zig
-const std = @import("std");
-
-pub fn main() !void {
- std.debug.print("Hola {s}\n", .{"Juan"});
- std.debug.print("Tu pedido cuesta {s} dolares\n", .{"20"});
- std.debug.print("Adios {s}\n", .{"Juan"});
-}
+// --- 1 --- -2-
+std.debug.print("formato", .{});
```
-Y al ejecutarlo se muestra:
+- 1: un formato (string)
+- 2: datos adicionales
-
+Hasta ahora utilizamos el primer string (1) para imprimir
+nuestro texto. Pero en (1) podemos poner unas secuencias
+especiales, que permiten colocar información adicional.
+Esta información adicional se coloca en (2).
-Como el código es sencillo, no hay ningún problema.
-¿Pero qué pasaría si tuvieramos que imprimir el nombre 10 veces?
-Entonces tendríamos que repetirlo 10 veces.
+Por ejemplo, podemos colocar `{s}` para imprimir un
+texto adicional:
+
+
+
+En este caso, `{s}` será reemplazado por `Hola`, e
+imprimirá `Hola`.
+
+Otro ejemplo:
+
+
+
+Aquí también, `{s}` será reemplazado por `Sara`.
+Al ejecutar obtendremos `Mi nombre es Sara, y el tuyo?`
+
+Podemos colocar más de un formato:
+
+
+
+En este caso la información adicional se reemplaza en orden,
+e imprime `Soy Raul y ella es Rosa`.
+
+Cuando se colocan datos adicionales, se separan con comas:
```zig
-const std = @import("std");
-
-pub fn main() !void {
- std.debug.print("Hola {s}\n", .{"Juan"});
- std.debug.print("Hola {s}\n", .{"Juan"});
- std.debug.print("Hola {s}\n", .{"Juan"});
- std.debug.print("Hola {s}\n", .{"Juan"});
- std.debug.print("Hola {s}\n", .{"Juan"});
- std.debug.print("Hola {s}\n", .{"Juan"});
- std.debug.print("Hola {s}\n", .{"Juan"});
- std.debug.print("Hola {s}\n", .{"Juan"});
- std.debug.print("Hola {s}\n", .{"Juan"});
- std.debug.print("Hola {s}\n", .{"Juan"});
-}
+ .{"Raul", "Rosa"}
+ // |
```
-
-
-Un poco tedioso, pero nada imposible.
-
-Ahora vamos a cambiar el programa: el nombre de la
-persona será `Maria`.
-
-Lo que tenemos que hacer es cambiar `Juan` por
-`Maria` en los 10 lugares, uno por uno.
-
-Esto es bastante común, y existe una solución para
-no cambiar 10 veces, sino solamente una.
-
-
-## Variables
-
-Una variable es como un almacén. Una variable
-almacena un valor bajo un nombre.
-
-Por ejemplo, podemos decir que `nombre = "Juan"`,
-y a partir de ese momento cada vez que usemos
-`nombre` se reemplazará por `Juan`.
-
-Por ejemplo:
+En el siguiente artículo veremos un concepto
+llamado variables. Por ahora, solo necesitas
+saber que se pueden utilizar.
```zig
-const std = @import("std");
+const std = @import("zig");
pub fn main() !void {
const nombre = "Juan";
- std.debug.print("Hola {s}\n", .{nombre});
+ const apellido = "Perez";
+ std.debug.print("{s} {s}", .{nombre, apellido});
+ // Imprime: `Juan Perez`
}
```
-En el código de arriba en la linea 4, hemos creado una
-variable `nombre`, y le hemos dado como valor `"Juan"`.
-Despues, en la linea 5 estamos utilizando la variable.
-En vez de escribir `.{"Juan"}` escribimos `.{nombre}`.
+## Otros formatos
-Al ejecutar el programa se imprimirá `Hola Juan`
-
-
-
-Podemos utilizar la variable las veces que queramos.
-Si imprimimos 10 veces se vería así:
-
-```zig
-const std = @import("std");
-
-pub fn main() !void {
- const nombre = "Juan";
- std.debug.print("Hola {s}\n", .{nombre});
- std.debug.print("Hola {s}\n", .{nombre});
- std.debug.print("Hola {s}\n", .{nombre});
- std.debug.print("Hola {s}\n", .{nombre});
- std.debug.print("Hola {s}\n", .{nombre});
- std.debug.print("Hola {s}\n", .{nombre});
- std.debug.print("Hola {s}\n", .{nombre});
- std.debug.print("Hola {s}\n", .{nombre});
- std.debug.print("Hola {s}\n", .{nombre});
- std.debug.print("Hola {s}\n", .{nombre});
-}
-```
-
-Y al ejecutar se imprime 10 veces.
-
-
-
-Ahora, si queremos cambiar `Juan` por `Maria`,
-solo tenemos que hacerlo en un lugar:
-
-```zig
-const std = @import("std");
-
-pub fn main() !void {
- const nombre = "Maria";
- std.debug.print("Hola {s}\n", .{nombre});
- std.debug.print("Hola {s}\n", .{nombre});
- std.debug.print("Hola {s}\n", .{nombre});
- std.debug.print("Hola {s}\n", .{nombre});
- std.debug.print("Hola {s}\n", .{nombre});
- std.debug.print("Hola {s}\n", .{nombre});
- std.debug.print("Hola {s}\n", .{nombre});
- std.debug.print("Hola {s}\n", .{nombre});
- std.debug.print("Hola {s}\n", .{nombre});
- std.debug.print("Hola {s}\n", .{nombre});
-}
-```
-
-
-
-## Creando una variable
-
-Para crear una variable se escribe:
-
-- `const`
-- El nombre de la variable
-- `=`
-- El valor de la variable
-- `;`
-
-El nombre de la variable solo puede tener letras,
-números y guiones bajos. No puede tener espacios.
-
-Puedes crear varias variables, cada una en una
-línea. Por ejemplo:
-
-```zig
-const nombre = "Pedro";
-const edad = "32";
-const helado_favorito = "Vainilla";
-```
-
-## Error de duplicado
-
-Otro dato importante es que solo se puede crear
-una variable con un nombre una vez. Por ejemplo:
-
-
-
-En el código de arriba hay un error. Cuando aparecen
-lineas punteadas rojas significa que hay un error.
-
-Si colocas tu mouse encima de la palabra subrayada
-aparecerá un mensaje:
-
-
-
-El error es `redeclaration of local constant 'nombre'`.
-Significa "redeclaración de constante local 'nombre'".
-
-Hay algunas palabras raras, pero quiere decir que
-estas volviendo a crear una variable con un nombre
-ya ocupado.
-
-Para solucionar el error, cambia el nombre de la variable.
-
-
-## Error con variables no utilizadas
-
-Si creas variables, y no las utilizas despues,
-tendrás este error:
-
-
-
-`unused local constant`: "constante local inutilizada".
-
-Zig no nos permite crear una variable y dejarla olvidada.
-Si creamos una variable, la tenemos que usar.
-
-Para solucionar el error, imprime la variable,
-o elimínala, si no la vas a utilizar aún.
-
-
-## Próximamente
-
-En el siguiente artículo aprenderemos los conceptos:
-comentarios, números y operaciones matemáticas.
+Hemos visto el formato `{s}`, pero existen muchos más,
+que aprenderemos a medida que los necesitemos.
diff --git a/src/pages/blog/es/programacion-08.md b/src/pages/blog/es/programacion-08.md
new file mode 100644
index 0000000..5b3a855
--- /dev/null
+++ b/src/pages/blog/es/programacion-08.md
@@ -0,0 +1,224 @@
+---
+layout: ../../../layouts/BlogLayoutEs.astro
+title: "08: Cero a Zig - Variables"
+description: |
+ Introducción a las variables
+pubDate: "2024-08-11"
+tags: ["tech", "lenguajes", "intro", "tutorial", "zig", "VSCode"]
+image:
+ url: ""
+ alt: ""
+ caption: ""
+---
+
+Ahora veremos un concepto fundamental: Variables.
+
+Todo el código lo escribiremos en el proyecto que creamos
+en el artículo anterior.
+
+
+## Motivación
+
+Vamos a plantear un escenario: Queremos escribir un programa
+que salude a una persona, le diga cuanto cuesta su orden,
+y se despida.
+
+Digamos que la persona se llama `Juan`. El código es así:
+
+```zig
+const std = @import("std");
+
+pub fn main() !void {
+ std.debug.print("Hola {s}\n", .{"Juan"});
+ std.debug.print("Tu pedido cuesta {s} dolares\n", .{"20"});
+ std.debug.print("Adios {s}\n", .{"Juan"});
+}
+```
+
+Y al ejecutarlo se muestra:
+
+
+
+Como el código es sencillo, no hay ningún problema.
+¿Pero qué pasaría si tuvieramos que imprimir el nombre 10 veces?
+Entonces tendríamos que repetirlo 10 veces.
+
+```zig
+const std = @import("std");
+
+pub fn main() !void {
+ std.debug.print("Hola {s}\n", .{"Juan"});
+ std.debug.print("Hola {s}\n", .{"Juan"});
+ std.debug.print("Hola {s}\n", .{"Juan"});
+ std.debug.print("Hola {s}\n", .{"Juan"});
+ std.debug.print("Hola {s}\n", .{"Juan"});
+ std.debug.print("Hola {s}\n", .{"Juan"});
+ std.debug.print("Hola {s}\n", .{"Juan"});
+ std.debug.print("Hola {s}\n", .{"Juan"});
+ std.debug.print("Hola {s}\n", .{"Juan"});
+ std.debug.print("Hola {s}\n", .{"Juan"});
+}
+```
+
+
+
+Un poco tedioso, pero nada imposible.
+
+Ahora vamos a cambiar el programa: el nombre de la
+persona será `Maria`.
+
+Lo que tenemos que hacer es cambiar `Juan` por
+`Maria` en los 10 lugares, uno por uno.
+
+Esto es bastante común, y existe una solución para
+no cambiar 10 veces, sino solamente una.
+
+
+## Variables
+
+Una variable es como un almacén. Una variable
+almacena un valor bajo un nombre.
+
+Por ejemplo, podemos decir que `nombre = "Juan"`,
+y a partir de ese momento cada vez que usemos
+`nombre` se reemplazará por `Juan`.
+
+Por ejemplo:
+
+```zig
+const std = @import("std");
+
+pub fn main() !void {
+ const nombre = "Juan";
+ std.debug.print("Hola {s}\n", .{nombre});
+}
+```
+
+En el código de arriba en la linea 4, hemos creado una
+variable `nombre`, y le hemos dado como valor `"Juan"`.
+
+Despues, en la linea 5 estamos utilizando la variable.
+En vez de escribir `.{"Juan"}` escribimos `.{nombre}`.
+
+Al ejecutar el programa se imprimirá `Hola Juan`
+
+
+
+Podemos utilizar la variable las veces que queramos.
+Si imprimimos 10 veces se vería así:
+
+```zig
+const std = @import("std");
+
+pub fn main() !void {
+ const nombre = "Juan";
+ std.debug.print("Hola {s}\n", .{nombre});
+ std.debug.print("Hola {s}\n", .{nombre});
+ std.debug.print("Hola {s}\n", .{nombre});
+ std.debug.print("Hola {s}\n", .{nombre});
+ std.debug.print("Hola {s}\n", .{nombre});
+ std.debug.print("Hola {s}\n", .{nombre});
+ std.debug.print("Hola {s}\n", .{nombre});
+ std.debug.print("Hola {s}\n", .{nombre});
+ std.debug.print("Hola {s}\n", .{nombre});
+ std.debug.print("Hola {s}\n", .{nombre});
+}
+```
+
+Y al ejecutar se imprime 10 veces.
+
+
+
+Ahora, si queremos cambiar `Juan` por `Maria`,
+solo tenemos que hacerlo en un lugar:
+
+```zig
+const std = @import("std");
+
+pub fn main() !void {
+ const nombre = "Maria";
+ std.debug.print("Hola {s}\n", .{nombre});
+ std.debug.print("Hola {s}\n", .{nombre});
+ std.debug.print("Hola {s}\n", .{nombre});
+ std.debug.print("Hola {s}\n", .{nombre});
+ std.debug.print("Hola {s}\n", .{nombre});
+ std.debug.print("Hola {s}\n", .{nombre});
+ std.debug.print("Hola {s}\n", .{nombre});
+ std.debug.print("Hola {s}\n", .{nombre});
+ std.debug.print("Hola {s}\n", .{nombre});
+ std.debug.print("Hola {s}\n", .{nombre});
+}
+```
+
+
+
+## Creando una variable
+
+Para crear una variable se escribe:
+
+- `const`
+- El nombre de la variable
+- `=`
+- El valor de la variable
+- `;`
+
+El nombre de la variable solo puede tener letras,
+números y guiones bajos. No puede tener espacios.
+
+Puedes crear varias variables, cada una en una
+línea. Por ejemplo:
+
+```zig
+const nombre = "Pedro";
+const edad = "32";
+const helado_favorito = "Vainilla";
+```
+
+## Error de duplicado
+
+Otro dato importante es que solo se puede crear
+una variable con un nombre una vez. Por ejemplo:
+
+
+
+En el código de arriba hay un error. Cuando aparecen
+lineas punteadas rojas significa que hay un error.
+
+Si colocas tu mouse encima de la palabra subrayada
+aparecerá un mensaje:
+
+
+
+El error es `redeclaration of local constant 'nombre'`.
+Significa "redeclaración de constante local 'nombre'".
+
+Hay algunas palabras raras, pero quiere decir que
+estas volviendo a crear una variable con un nombre
+ya ocupado.
+
+Para solucionar el error, cambia el nombre de la variable.
+
+
+## Error con variables no utilizadas
+
+Si creas variables, y no las utilizas despues,
+tendrás este error:
+
+
+
+`unused local constant`: "constante local inutilizada".
+
+Zig no nos permite crear una variable y dejarla olvidada.
+Si creamos una variable, la tenemos que usar.
+
+Para solucionar el error, imprime la variable,
+o elimínala, si no la vas a utilizar aún.
+
+
+## Próximamente
+
+En el siguiente artículo aprenderemos los conceptos:
+comentarios, números y operaciones matemáticas.
+
+
+
diff --git a/src/pages/blog/es/programacion-09.md b/src/pages/blog/es/programacion-09.md
new file mode 100644
index 0000000..fa6ff46
--- /dev/null
+++ b/src/pages/blog/es/programacion-09.md
@@ -0,0 +1,187 @@
+---
+layout: ../../../layouts/BlogLayoutEs.astro
+title: "09: Cero a Zig - Comentarios y Números"
+description: |
+ Comentarios, números y operaciones matemáticas
+pubDate: "2024-08-17"
+tags: ["tech", "lenguajes", "intro", "tutorial", "zig", "VSCode"]
+image:
+ url: "/img/blog/es/tutorial/1x/009-matematicas.jpg"
+ alt: "Imágen del meme 'Matemáticas hijo'"
+ caption: "¡Matemáticas hijo!"
+---
+
+En este artículo vemos 3 conceptos: Comentarios, números
+y operaciones matemáticas.
+
+
+## Comentarios
+
+Hasta el momento lo único que hemos escrito es código.
+Pero existen multitud de ocasiones donde queremos escribir
+apuntes, recordatorios, explicaciones, etc. Para esto sirven
+los comentarios.
+
+Un comentario es un texto que es ignorado por Zig. Dentro
+de un comentario podemos escribir cualquier cosa, sin importar
+las reglas de Zig.
+
+Los comentarios inician con doble slash `//`,
+y terminan cuando acaba la linea.
+
+
+```zig
+// Este es un comentario
+pub fn main() !void {
+ // Este también es un comentario
+ std.debug.print("Hola", .{});
+}
+```
+
+Una vez que iniciamos un comentario con doble slash,
+la única forma de terminarlo es con una linea nueva.
+
+Si quieres un comentario que abarque varias lineas,
+cada linea debe iniciar con doble slash:
+
+```zig
+pub fn main() !void {
+ // Este es un comentario
+ // que ocupa 3 lineas
+ // de texto :D
+ std.debug.print("Hola", .{});
+}
+```
+
+También puedes escribir un comentario en
+medio de una linea con código, pero no
+es recomendable.
+
+```zig
+pub fn main() !void { // Este es un comentario
+ std.debug.print("Hola", .{}); // Este también
+}
+```
+
+A partir de ahora, utilizaré comentarios en el código
+para explicar mejor los conceptos.
+
+
+## Números
+
+Hay un concepto importante que aprenderemos en un
+próximo artículo llamado "Tipos de datos". Pero por
+ahora, hablaremos solo de una parte pequeña: números.
+
+No necesito explicarte qué son los números. Lo que
+sí necesito es explicar cómo se utilizan en Zig,
+y como se diferencian de los strings.
+
+Primero, vamos a imprimir un número. El código
+es el siguiente:
+
+```zig
+const std = @import("std");
+
+pub fn main() !void {
+ std.debug.print("{d}", .{322});
+}
+```
+
+Nota que el número no tiene comillas. Es `322`,
+no `"322"`.
+
+Al ejecutarlo en el terminal con `zig build run`
+obtenemos:
+
+
+
+
+Nota en la línea 4 qué formato estamos utilizando:
+`{d}`. Este formato permite imprimir números.
+
+
+También podemos utilizar números en variables:
+
+```zig
+const std = @import("std");
+
+pub fn main() !void {
+ const edad = 32;
+ // Imprime: `Tengo 32 años`
+ std.debug.print("Tengo {d} años", .{edad});
+}
+```
+
+También podemos utilizar números negativos: `-20`;
+
+
+
+### Números, no strings
+
+Quiero recalcar este punto. Estamos escribiendo
+`123`, no `"123"`. No utilizamos comillas.
+
+Esto es importante porque estos dos son cosas
+diferentes. Una cosa es un número, y otra cosa
+es un texto (string).
+
+`123` es un número. Podemos realizar operaciones
+matemáticas con él. `"123"` no es un número,
+es un string. Solo que resulta que los caracteres
+son el 1, 2 y 3. Pero no podemos hacer matemática
+con un string.
+
+Este es un punto de confusión común cuando se
+aprende a programar.
+
+
+### Números enteros, técnicamente (`int`)
+
+Técnicamente, hay muchos tipos de números.
+Lo que estamos utilizando hasta ahora son números
+enteros, que en ingles se llaman "integer numbers".
+
+Ya que en programación todo es inglés y abreviaciones,
+en vez de decir "integer numbers", se les conoce como
+"int".
+
+A partir de ahora también diré `int` cuando me
+refiera a los números enteros.
+
+
+## Matemáticas
+
+Ahora que sabemos cómo crear números (int), podemos hacer
+operaciones con ellos.
+
+Zig soporta las operaciones que conoces: suma `+`,
+resta `-`, multiplicación `*` y división `/`.
+
+```zig
+const std = @import("std");
+
+pub fn main() !void {
+ const r1 = 9 + 3; // 12
+ const r2 = 9 - 3; // 6
+ const r1 = 9 * 3; // 27
+ const r1 = 9 / 3; // 3
+
+ // imprime: `12 6 27 3`
+ std.debug.print("{d} {d} {d} {d}", .{r1, r2, r3, r4});
+}
+```
+
+También puedes hacer varias operaciones a la vez, y
+agruparlas con paréntesis.
+
+```zig
+ const resultado = 80 + 20 / (5 - 3);
+```
+
+
+
+
+## Números racionales (float)
+
+