List dobleuber as translator

blog/content/edition-2/posts/01-freestanding-rust-binary/index.es.md

@@ -6,6 +6,9 @@ date = 2018-02-10
 
 [extra]
 chapter = "Bare Bones"
+
+# GitHub usernames of the people that translated this post
+translators = ["dobleuber"]
 +++
 
 El primer paso para crear nuestro propio kernel de sistema operativo es crear un ejecutable en Rust que no enlace con la biblioteca estándar. Esto hace posible ejecutar código Rust directamente en el [bare metal] sin un sistema operativo subyacente.

blog/content/edition-2/posts/01-freestanding-rust-binary/index.md

@@ -6,6 +6,9 @@ date = 2018-02-10
 
 [extra]
 chapter = "Bare Bones"
+
+# GitHub usernames of the people that translated this post
+translators = ["dobleuber"]
 +++
 
 The first step in creating our own operating system kernel is to create a Rust executable that does not link the standard library. This makes it possible to run Rust code on the [bare metal] without an underlying operating system.

blog/content/edition-2/posts/02-minimal-rust-kernel/index.es.md

@@ -6,6 +6,9 @@ date = 2018-02-10
 
 [extra]
 chapter = "Bare Bones"
+
+# GitHub usernames of the people that translated this post
+translators = ["dobleuber"]
 +++
 
 En esta publicación, crearemos un kernel mínimo de 64 bits en Rust para la arquitectura x86. Partiremos del [un binario Rust autónomo] de la publicación anterior para crear una imagen de disco arrancable que imprima algo en la pantalla.

blog/content/edition-2/posts/03-vga-text-buffer/index.es.md

@@ -6,6 +6,9 @@ date  = 2018-02-26
 
 [extra]
 chapter = "Fundamentos"
+
+# GitHub usernames of the people that translated this post
+translators = ["dobleuber"]
 +++
 
 El [modo de texto VGA] es una forma sencilla de imprimir texto en la pantalla. En esta publicación, creamos una interfaz que hace que su uso sea seguro y simple al encapsular toda la inseguridad en un módulo separado. También implementamos soporte para los [macros de formato] de Rust.

blog/content/edition-2/posts/04-testing/index.es.md

@@ -7,6 +7,9 @@ date = 2019-04-27
 [extra]
 chapter = "Fundamentos"
 comments_search_term = 1009
+
+# GitHub usernames of the people that translated this post
+translators = ["dobleuber"]
 +++
 
 Esta publicación explora las pruebas unitarias e integración en ejecutables `no_std`. Utilizaremos el soporte de Rust para marcos de prueba personalizados para ejecutar funciones de prueba dentro de nuestro núcleo. Para reportar los resultados fuera de QEMU, utilizaremos diferentes características de QEMU y la herramienta `bootimage`.

blog/content/edition-2/posts/05-cpu-exceptions/index.es.md

@@ -6,6 +6,9 @@ date  = 2018-06-17
 
 [extra]
 chapter = "Interrupciones"
+
+# GitHub usernames of the people that translated this post
+translators = ["dobleuber"]
 +++
 
 Las excepciones de CPU ocurren en diversas situaciones erróneas, por ejemplo, al acceder a una dirección de memoria inválida o al dividir por cero. Para reaccionar ante ellas, tenemos que configurar una _tabla de descriptores de interrupción_ (IDT, por sus siglas en inglés) que proporcione funciones manejadoras. Al final de esta publicación, nuestro núcleo será capaz de capturar [excepciones de punto de interrupción] y reanudar la ejecución normal después.

blog/content/edition-2/posts/06-double-faults/index.es.md

@@ -6,6 +6,9 @@ date  = 2018-06-18
 
 [extra]
 chapter = "Interrupciones"
+
+# GitHub usernames of the people that translated this post
+translators = ["dobleuber"]
 +++
 
 Esta publicación explora en detalle la excepción de doble fallo, que ocurre cuando la CPU no logra invocar un controlador de excepciones. Al manejar esta excepción, evitamos fallos _triples_ fatales que causan un reinicio del sistema. Para prevenir fallos triples en todos los casos, también configuramos una _Tabla de Pila de Interrupciones_ (IST) para capturar dobles fallos en una pila de núcleo separada.

blog/content/edition-2/posts/07-hardware-interrupts/index.es.md

@@ -6,6 +6,9 @@ date = 2018-10-22
 
 [extra]
 chapter = "Interrupciones"
+
+# GitHub usernames of the people that translated this post
+translators = ["dobleuber"]
 +++
 
 En esta publicación, configuramos el controlador de interrupciones programable para redirigir correctamente las interrupciones de hardware a la CPU. Para manejar estas interrupciones, agregamos nuevas entradas a nuestra tabla de descriptores de interrupciones, tal como lo hicimos con nuestros manejadores de excepciones. Aprenderemos cómo obtener interrupciones de temporizador periódicas y cómo recibir entrada del teclado.

blog/content/edition-2/posts/08-paging-introduction/index.es.md

@@ -6,6 +6,9 @@ date = 2019-01-14
 
 [extra]
 chapter = "Gestión de Memoria"
+
+# GitHub usernames of the people that translated this post
+translators = ["dobleuber"]
 +++
 
 Esta publicación introduce la _paginación_ (paging), un esquema de gestión de memoria muy común que también utilizaremos para nuestro sistema operativo. Explica por qué se necesita la aislamiento de memoria, cómo funciona la _segmentación_ (segmentation), qué es la _memoria virtual_ (virtual memory) y cómo la paginación soluciona los problemas de fragmentación de memoria. También explora el diseño de las tablas de páginas multinivel en la arquitectura x86_64.

blog/content/edition-2/posts/09-paging-implementation/index.es.md

@@ -6,6 +6,9 @@ date = 2019-03-14
 
 [extra]
 chapter = "Gestión de la Memoria"
+
+# GitHub usernames of the people that translated this post
+translators = ["dobleuber"]
 +++
 
 Esta publicación muestra cómo implementar soporte para paginación en nuestro núcleo. Primero explora diferentes técnicas para hacer accesibles los marcos de la tabla de páginas físicas al núcleo y discute sus respectivas ventajas y desventajas. Luego implementa una función de traducción de direcciones y una función para crear un nuevo mapeo.

blog/content/edition-2/posts/10-heap-allocation/index.es.md

@@ -6,6 +6,9 @@ date = 2019-06-26
 
 [extra]
 chapter = "Gestión de Memoria"
+
+# GitHub usernames of the people that translated this post
+translators = ["dobleuber"]
 +++
 
 Este post añade soporte para la asignación en el heap a nuestro núcleo. Primero, proporciona una introducción a la memoria dinámica y muestra cómo el borrow checker (verificador de préstamos) previene errores comunes de asignación. Luego, implementa la interfaz básica de asignación de Rust, crea una región de memoria en el heap y configura una crate de asignador. Al final de este post, todos los tipos de asignación y recolección de la crate `alloc` integrada estarán disponibles para nuestro núcleo.

blog/content/edition-2/posts/11-allocator-designs/index.es.md

@@ -6,6 +6,9 @@ date = 2020-01-20
 
 [extra]
 chapter = "Gestión de Memoria"
+
+# GitHub usernames of the people that translated this post
+translators = ["dobleuber"]
 +++
 
 Este post explica cómo implementar allocadores de heap desde cero. Presenta y discute diferentes diseños de allocadores, incluyendo asignación de bump, asignación de lista enlazada y asignación de bloques de tamaño fijo. Para cada uno de los tres diseños, crearemos una implementación básica que se puede utilizar para nuestro kernel.

blog/content/edition-2/posts/12-async-await/index.es.md

@@ -6,6 +6,9 @@ date = 2020-03-27
 
 [extra]
 chapter = "Multitasking"
+
+# GitHub usernames of the people that translated this post
+translators = ["dobleuber"]
 +++
 
 En esta publicación, exploramos el _multitasking cooperativo_ y la característica _async/await_ de Rust. Observamos en detalle cómo funciona async/await en Rust, incluyendo el diseño del trait `Future`, la transformación de máquina de estado y el _pinning_. Luego añadimos soporte básico para async/await a nuestro núcleo creando una tarea de teclado asíncrona y un ejecutor básico.