README.ES.md -> 00_before_we_start (#149)

* README.ES.md

I added a spanish translation for the README.md file, and modified the README.md to add my github profile and to add the link to README.ES.md file

* Slightly reorganize translation overview

* README.ES.md These changes are in response to PR comments

* Update README.ES.md

* README.ES.md -> 00_before_we_start

* Updating README.ES.md

I corrected a few mistakes in both README.ES.md files.

* README.ES.md for 00 These changes are in response to PR comments

Co-authored-by: zanez <[email protected]>
Co-authored-by: Andre Richter <[email protected]>

Author: 3 people

00_before_we_start/README.ES.md

@@ -0,0 +1,103 @@
+# Antes de comenzar
+
+El texto a continuación es una copia 1:1 de la documentación que 
+puede ser encontrada al principio del archivo del código fuente 
+del núcleo (kernel) en cada tutorial. Esta describe la estructura 
+general del código fuente, e intenta transmitir la filosofía detrás
+de cada enfoque. Por favor leélo para familiarizarte
+con lo que te vas a encontrar durante los tutoriales. Te ayudará a navegar el código de una mejor manera y a entender las diferencias y agregados entre los diferentes tutoriales.
+
+Por favor, nota también que el siguiente texto va a referenciar
+los archivos del código fuente (p. e.j. `**/memory.rs`) o funciones que
+no van a existir aún en los primeros tutoriales. Estos archivos serán agregados 
+a medida que el tutorial avance.
+
+¡Diviértanse!
+
+# La estructura del código y la arquitectura
+
+El código está dividido en diferentes módulos donde cada uno representa un
+subsistema típico del `kernel (núcleo)`. Los módulos de más alto nivel de los subsistemas se encuentran directamente en la carpeta `src`.
+Por ejemplo, `src/memory.rs` contiene el código que está relacionado
+con el manejo de memoria.
+
+## Visibilidad del código de arquitectura del procesador
+
+Algunos de los subsistemas del `núcleo (kernel)` dependen del código de bajo nivel (low-level) dedicado a la arquitectura del procesador.
+Por cada arquitectura de procesador que está soportada, existe una subcarpeta en `src/_arch`, por ejemplo, `src/_arch/aarch64`.
+
+La carpeta de arquitecturas refleja los módulos del subsistema establecidos en `src`. Por ejemplo, el código de arquitectura que pertenece al subsistema MMU del `núcleo(kernel)` (`src/memory/mmu.rs`) irá dentro de (`src/_arch/aarch64/memory/mmu.rs`).
+Este archivo puede ser cargado como un módulo en `src/memory/mmu.rs` usando el `path attribute` (atributo de ruta). Usualmente, el nombre del módulo elegido es el nombre del módulo genérico con el prefijo de `arch_`
+
+Por ejemplo, esta es la parte superior de `src/memory/mmu.rs`:
+
+```
+#[cfg(target_arch = "aarch64")]
+#[path = "../_arch/aarch64/memory/mmu.rs"]
+mod arch_mmu;
+```
+
+En muchas ocasiones, los elementos de `arch_module` serán reexportados públicamente por el módulo principal.
+De esta manera, cada módulo específico de la arquitectura puede proporcionar su implementación de un elemento, mientras que el *invocante* no debe de preocuparse por la arquitectura que se ha compilado condicionalmente.
+
+## Código BSP
+
+`BSP` significa Board Support Package (Paquete de Soporte de la Placa).
+El código `BSP` está dentro de `src/bsp.rs` y contiene las definiciones y funciones de la placa base específica elegida. 
+Entre estas cosas se encuentran diferentes elementos como el mapa de memoria de la placa o instancias de controladores para dispositivos que se presentan en la placa elegida.
+
+Justo como el código de la arquitectura del procesador, la estructura del módulo del código `BSP` trata de reflejar los módulos del subsistema del `núcleo (kernel)`, pero no ocurre una reexportación esta vez. Eso significa que lo que sea que se esté proporcionando debe ser llamado empezando por el *namespace* (espacio de nombres) de `bsp`, p. ej. `bsp::driver::driver_manager()`.
+
+## La interfaz del núcleo (kernel)
+
+El `arch` y el `bsp` contienen código que se compilará condicionalmente dependiendo del procesador y placa actual para la que se compila el núcleo (kernel).
+Por ejemplo, el hardware de control de interrupciones de la `Raspberry Pi 3` y la  `Raspberry Pi 4` es diferente, pero nosotros queremos que el resto del código del kernel funcione correctamente con cualquiera de los dos sin mucha complicación.
+
+Para poder dar una limpia abstracción entre `arch`, `bsp` y código genérico del núcleo, los rasgos de `interface` se proporcionan *siempre y cuando tenga sentido*. Son definidos en su módulo de subsistema correspondiente y ayuda a reforzar el patrón de programar con respecto a una interfaz, sin importar la implementación concreta.
+
+Por ejemplo, habrá una *IRQ handling interface* (interfaz de manejo de interrupciones) común, el cual los dos diferentes controladores de ambas `Raspberry` implementarán, y solo exportarán la interfaz común al resto del `núcleo (kernel)`.
+
+```
+        +-------------------+
+        | Interface (Trait) |
+        |                   |
+        +--+-------------+--+
+           ^             ^
+           |             |
+           |             |
++----------+--+       +--+----------+
+| kernel code |       |  bsp code   |
+|             |       |  arch code  |
++-------------+       +-------------+
+```
+
+# Resumen
+
+Para un subsistema lógico del `núcleo (kernel)`, el código correspondiente puede ser distribuido sobre diferentes localizaciones físicas. Aquí un ejemplo para el subsistema de memoria:
+
+- `src/memory.rs` y `src/memory/**/*`
+  
+  - Código común que es independiente de la arquitectura del procesador de destino y las características de la placa (`BSP`).
+    - Ejemplo: Una función para poner a cero un trozo de memoria.
+  - Las interfaces para el subsistema de la memoria que son implementados por código de `arch` o `BSP`.
+    - Ejemplo: Una interfaz `MMU` que define prototipos de función de `MMU`.
+
+- `src/bsp/__board_name__/memory.rs` y `src/bsp/__board_name__/memory/**/*`
+  
+  - Código específico de `BSP`.
+  - Ejemplo: El mapa de memoria de la placa (direcciones físicas de DRAM y dispositivos MMIO).
+
+- `src/_arch/__arch_name__/memory.rs` y `src/_arch/__arch_name__/memory/**/*`
+  
+  - El código específico de la arquitectura del procesador.
+  - Ejemplo: Implementación de la interfaz `MMU` para la arquitectura `__arch_name__`.
+
+Desde una perspectiva de *namespace*, el código del subsistema de **memoria** vive en:
+
+- `crate::memory::*`
+- `crate::bsp::memory::*`
+
+# Flujo de Boot / Boot flow
+
+1. El punto de entrada del núcleo (kernel) es la función `cpu::boot::arch_boot::_start()`.
+   - Está implementado en `src/_arch/__arch_name__/cpu/boot.s`.

README.ES.md

@@ -32,9 +32,9 @@ P.S.: Para otros lenguajes, por favor busquen los diferentes archivos README. Po
 - Cada tutorial contiene un solo binario arrancable correspondiente al núcleo.
 - Cada tutorial nuevo extiende el tutorial anterior.
 - Cada tutorial tendrá un `README` y cada `README` tendrá un pequeña sección de [`tl;dr`](https://es.wikipedia.org/wiki/TL;DR) en donde se dará una pequeña perspectiva general de los cambios y se mostrará el código fuente `diff` del tutorial anterior para que se puedan inspeccionar los cambios/adiciones que han ocurrido.
-    - Algunos tutoriales además de tener un `tl;dr` también tendrán una sección en la que se dará una explicación con todo lujo de detalle.
-       El plan a largo plazo es que cada tutorial tenga una buena explicación además del `tl;dr` y el `diff`; pero por el momento los únicos tutoriales
-      que gozan de una son los tutoriales en los que creo que el `tl;dr` y el `diff` no son suficientes para comprender lo que está pasando.
+  - Algunos tutoriales además de tener un `tl;dr` también tendrán una sección en la que se dará una explicación con todo lujo de detalle.
+     El plan a largo plazo es que cada tutorial tenga una buena explicación además del `tl;dr` y el `diff`; pero por el momento los únicos tutoriales
+    que gozan de una son los tutoriales en los que creo que el `tl;dr` y el `diff` no son suficientes para comprender lo que está pasando.
 - El código que se escribió en este tutorial soporta y corre en la **Raspberry Pi 3** y en la **Raspberry 4**
   - Del tutorial 1 hasta el 5 son tutoriales "preparatorios", por lo que este código solo tendrá sentido ejecutarlo en [`QEMU`](https://www.qemu.org/).
   - Cuando llegues al [tutorial 5](05_drivers_gpio_uart) podrás comenzar a cargar y a ejecutar el núcleo en una
@@ -61,28 +61,33 @@ Muchas de las cosas vistas aquí también funcionan en **macOS**, pero esto solo
 ### 🚀 La versión tl;dr
 
 1. [Instala Docker Desktop][install_docker].
+
 2. (**Solo para Linux**) Asegúrate de que la cuenta de tu usuario está en el [grupo `docker`][docker group].
+
 3. Prepara la `Rust` toolchain. La mayor parte se hará automáticamente durante el primer uso del archivo [rust-toolchain](rust-toolchain). 
    Todo lo que nos queda hacer a nosotros es: 
-
+   
    i. Si ya tienes una versión de Rust instalada:
-      ```bash
-      cargo install cargo-binutils rustfilt
-      ```
-
+   
+   ```bash
+   cargo install cargo-binutils rustfilt
+   ```
+   
    ii. Si necesitas instalar Rust desde cero:
-      ```bash
-      curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
-
-      source $HOME/.cargo/env
-      cargo install cargo-binutils rustfilt
-      ```
+   
+   ```bash
+   curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+   
+   source $HOME/.cargo/env
+   cargo install cargo-binutils rustfilt
+   ```
 
 4. En caso de que uses `Visual Studio Code`, recomiendo que instales la extensión [Rust Analyzer extension].
-5. (**Solo para macOS**) Instala algunas `Ruby` gems.
 
+5. (**Solo para macOS**) Instala algunas `Ruby` gems.
+   
    Ejecuta esto en la carpeta root del repositorio:
-
+   
    ```bash
    bundle install --path .vendor/bundle --without development
    ```
@@ -92,7 +97,7 @@ Muchas de las cosas vistas aquí también funcionan en **macOS**, pero esto solo
 
 ### 🧰 Más detalles: Eliminando Lios con Toolchains
 
-Esta serie trata de enfocarse lo máximo posible en tener una experiencia agradable para el usario.
+Esta serie trata de enfocarse lo máximo posible en tener una experiencia agradable para el usuario.
 Por lo tanto, se han dirigido muchos esfuerzos a eliminar la parte más difícil del desarrollo de
 los sistemas incorporados (embedded) tanto como se pudo.
 
@@ -102,7 +107,7 @@ con arquitectura `AArch64` será automáticamente instalado por `rustup`. Sin em
 el compilador de Rust, también usaremos algunas otras herramientas, entre las cuales están:
 
 - `QEMU` para emular nuestro núcleo en nuestra máquina principal.
--  Una herramienta llamada `Minipush` para cargar el núcleo en una Raspberry Pi cuando queramos usando `UART`.
+- Una herramienta llamada `Minipush` para cargar el núcleo en una Raspberry Pi cuando queramos usando `UART`.
 - `OpenOCD` y `GDB` para hacer depuración ("debugging") en la máquina a instalar.
 
 Hay muchas cosas que pueden salir mal mientras instalamos y/o compilamos las versiones correctas de cada
@@ -143,12 +148,12 @@ de [Zoltan Baldaszti](https://github.com/bztsrc). ¡Gracias por darme un punto d
 
 ### Traducciones de este repositorio
 
- - **Chino:**
-   - [@colachg] y [@readlnh].
-   - Necesitan actualizaciones.
- - **Español:**
-   -  [@zanezhub].
-   -  En el futuro habrán tutoriales traducidos al español. 
+- **Chino:**
+  - [@colachg] y [@readlnh].
+  - Necesitan actualizaciones.
+- **Español:**
+  - [@zanezhub].
+  - En el futuro habrán tutoriales traducidos al español. 
 
 [@colachg]: https://github.com/colachg
 [@readlnh]: https://github.com/readlnh
@@ -158,14 +163,11 @@ de [Zoltan Baldaszti](https://github.com/bztsrc). ¡Gracias por darme un punto d
 
 Este proyecto está licenciado por cualquiera de las siguientes licencias como alguna de tus dos opciones
 
-- Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
-- MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
-
+- Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) o http://www.apache.org/licenses/LICENSE-2.0)
+- MIT license ([LICENSE-MIT](LICENSE-MIT) o http://opensource.org/licenses/MIT)
 
 ### Contribución
 
 A menos de que lo menciones, cualquier contribución enviada por ti para su inclusión en este trabajo,
 tal como se define en la licencia Apache-2.0, deberá tener doble licencia como se muestra en la parte superior, sin ningún
 cambio de términos o condiciones.
-
-