Merge pull request #246 from manuelver/feature/translateES-04

Feature/translate es 04

2022/es/Days/day03.md

@@ -44,7 +44,7 @@ Esta es la etapa en la que el código se despliega en los servidores de producci
 
 De estos atrevidos temas, entraremos en más detalle en las próximas semanas para tener un mejor conocimiento fundacional de lo que son y cuándo usarlos.
 
-### Monitoreo
+### Monitorizar
 
 Las cosas se mueven rápidamente aquí y tenemos nuestra aplicación que estamos actualizando continuamente con nuevas características y funcionalidades. Tenemos el testing asegurándose de que no se hay gremlins por ahí. Tenemos la aplicación funcionando en nuestro entorno de producción y puede estar continuamente mantenida la configuración y el rendimiento requeridos.
 

2022/es/Days/day05.md

@@ -38,7 +38,7 @@ Lo ideal es que cualquier despliegue previsible este dentro del proceso de autom
 
 ## Monitorización
 
-Todas las partes anteriores conducen a este paso final: la monitorización. Especialmente en torno a la resolución de problemas del autoescalado que hemos comentado. ¿Cómo si no sabrías
+Todas las partes anteriores conducen a este paso final: la monitorización. Especialmente en torno a la resolución de problemas del auto-escalado que hemos comentado. ¿Cómo si no sabrías
 que hay un problema si no tienes una monitorización que te lo diga?
 
 Así que algunas de las cosas que se pueden controlar a través de la monitorización son:

2022/es/Days/day06.md

@@ -8,7 +8,7 @@ El beneficio general aquí es que DevOps, si se hace correctamente, debería ayu
 
 Este día está dedicado a ver empresas de éxito que han adoptado una práctica DevOps y compartir algunos recursos en torno a esto. Esta será una gran oportunidad para que la comunidad se sumerja y ayude aquí. ¿Has adoptado una cultura DevOps en tu empresa? ¿Ha tenido éxito?
 
-Se mencionó Netflix anteriormente y ahora se comentará un poco más, ya que es un modelo muy bueno y bastante avanzado en comparación con lo que generalmente vemos en las grandes empresas, pero también cabe destacar otros grandes emporios que están teniendo éxito, y en gran medida por la metalidad DevOps en sus filas.
+Se mencionó Netflix anteriormente y ahora se comentará un poco más, ya que es un modelo muy bueno y bastante avanzado en comparación con lo que generalmente vemos en las grandes empresas, pero también cabe destacar otros grandes emporios que están teniendo éxito, y en gran medida por la mentalidad DevOps en sus filas.
 
 ## Amazon
 

2022/es/Days/day08.md

@@ -110,7 +110,7 @@ Es de entender que el anterior código puede no tener ningún sentido, pero vere
 
 De vuelta en la terminal y en nuestra carpeta `Hello` podemos comprobar que todo está funcionando. Usando el siguiente comando podemos comprobar si nuestro programa de aprendizaje genérico está funcionando.
 
-```go
+```shell
 go run main.go
 ```
 Nos dirá Hola.
@@ -119,7 +119,7 @@ Nos dirá Hola.
 
 Pero esto no termina aquí, ¿qué pasa si ahora queremos tomar nuestro programa y ejecutarlo en otras máquinas Windows? Podemos hacerlo construyendo nuestro binario con el siguiente comando
 
-```go
+```shell
 go build main.go
 ```
 
@@ -127,7 +127,7 @@ go build main.go
 
 Si ejecutamos esto, veríamos la misma salida:
 
-```bash
+```shell
 #input
 ./main.exe
 

2022/es/Days/day10.md

@@ -6,13 +6,13 @@ En el [Día 8](day08.md) hablamos brevemente del espacio de trabajo Go para pone
 
 Si ejecutas
 
-```
+```shell
 echo $GOPATH
 ```
 
 La salida debería ser similar a la mía (con tu nombre de usuario):
 
-```
+```shell
 /home/michael/projects/go
 ```
 > **En Linux tenemos que configurarlo.** 

2022/es/Days/day11.md

@@ -18,13 +18,13 @@ Para declarar esto en nuestro programa Go definimos un valor utilizando una **ke
 
 Recuerda asegurarte de que los nombres de tus variables sean descriptivos. Si declaras una variable debes usarla o recibirás un error, esto es para evitar posible dead code, código que nunca se usa. Lo mismo ocurre con los paquetes que no se utilizan.
 
-```
+```go
 var challenge = "#90DaysOfDevOps"
 ```
 
 Con lo anterior establecido vamos a utilizarlo en el siguiente fragmento de código. Se puede ver en la salida de abajo que hemos utilizado la variable.
 
-```
+```go
 package main
 
 import "fmt"
@@ -45,7 +45,7 @@ Sabemos que este reto en concreto es de 90 días, pero el próximo, quizás sea
 
 Añadiendo `const` a nuestro código y añadiendo otra línea de código para imprimir esto.
 
-```
+```go
 package main
 
 import "fmt"
@@ -69,7 +69,7 @@ Por último añadiremos otra variable para el número de días que hemos complet
 
 A continuación verás añadida la variable `dayscomplete` con el número de días completados.
 
-```
+```go
 package main
 
 import "fmt"
@@ -99,7 +99,7 @@ Se pone interesante la cosa, puedes ver el código de ejemplo [day11_example4.go
 
 Las variables también pueden ser definidas en un formato más simple aun. En vez de definir `var` y el "tipo" puedes codificarla de la siguiente manera para obtener la misma funcionalidad pero con un aspecto más limpio y sencillo. Esto sólo funcionará para las variables y no para las constantes.
 
-```
+```go
 func main() {
     challenge := "#90DaysOfDevOps"
     const daystotal = 90
@@ -134,14 +134,14 @@ Este recurso está súper detallado sobre los tipos de datos: [Golang by example
 
 Si necesitamos definir un tipo en nuestra variable podemos hacerlo así:
 
-```
+```go
 var TwitterHandle string
 var DaysCompleted uint
 ```
 
 Como Go implica variables donde se da un valor podemos imprimir esos valores con lo siguiente:
 
-```
+```go
 fmt.Printf("challenge is %T, daystotal is %T, dayscomplete is %T\n", conference, daystotal, dayscomplete)
 ```
 

2022/es/Days/day12.md

@@ -1,68 +1,72 @@
-## Getting user input with Pointers and a finished program
+## Obtención del input del usuario con Punteros y un programa terminado
 
-Yesterday ([Day 11](day11.md)), we created our first Go program that was self-contained and the parts we wanted to get user input for were created as variables within our code and given values, we now want to ask the user for their input to give the variable the value for the end message.
+Ayer, en el ([Día 11](day11.md)), creamos nuestro primer programa Go self-contained, creando el código para obtener el input del usuario como variables dentro de nuestro código y se les dio valores. Ahora pediremos al usuario su input para dar el valor a la variable del mensaje final.
 
-## Getting user input
+¡Qué emocionante!
 
-Before we do that let's take a look at our application again and walk through the variables we want as a test before getting that user input.
+## Obteniendo el input del usuario
 
-Yesterday we finished up with our code looking like this [day11_example4.go](Go/day11_example4.go) we have manually in code defined our `challenge, daystotal, dayscomplete` variables and constants.
+Antes de hacer esto vamos a echar un vistazo a nuestra aplicación para recorrer las variables que queremos como prueba antes de obtener la entrada del usuario.
 
-Let's now add a new variable called `TwitterName` you can find this new code at [day12_example1.go](Go/day12_example1.go) and if we run this code this is our output.
+Ayer terminamos con nuestro código con el aspecto de este fichero: [day11_example4.go](Go/day11_example4.go).
+
+Hemos definido manualmente nuestras variables y constantes `challenge, daystotal, dayscomplete`.
+
+Ahora vamos a añadir una nueva variable llamada `TwitterName`. Puedes ver como queda en el código en el fichero [day12_example1.go](Go/day12_example1.go) y si ejecutamos este código esta es nuestra salida.
 
 ![](Images/Day12_Go1.png)
 
-We are on day 12 and we would need to change that `dayscomplete` every day and compile our code each day if this was hardcoded which doesn't sound so great.
+Estamos en el día 12 y tendríamos que cambiar ese `dayscomplete` cada día y compilar nuestro código cada día si esto fuera hardcodeado, lo cual no suena muy atractivo.
 
-Getting user input, we want to get the value of maybe a name and the number of days completed. For us to do this we can use another function from within the `fmt` package.
+Con lo cual, queremos que el usuario escriba los valores de su nombre en Twitter y del número de días completados para obtenerlos en nuestro programa. Para ello podemos utilizar otra función input del paquete `fmt`.
 
-Recap on the `fmt` package, different functions for formatted input and output (I/O)
+Recapitulando sobre el paquete `fmt`, diferentes funciones para la entrada y salida formateada (I/O)
 
-- Print Messages
+- Imprimir mensajes
-- Collect User Input
+- Recoger el input del usuario
-- Write into a file
+- Escribir en un archivo
 
-This is instead of assigning the value of a variable we want to ask the user for their input.
+En lugar de asignar en el programa el valor de una variable, queremos pedírsela al usuario en un input.
 
-```
+```go
 fmt.Scan(&TwitterName)
 ```
 
-Notice that we also use `&` before the variable. This is known as a pointer which we will cover in the next section.
+Fíjate que también usamos `&` antes de la variable. Esto se conoce como puntero y lo veremos en la siguiente sección.
 
-In our code [day12_example2.go](Go/day12_example2.go) you can see that we are asking the user to input two variables, `TwitterName` and `DaysCompleted`
+En el código del fichero [day12_example2.go](Go/day12_example2.go) puedes ver que estamos pidiendo al usuario que introduzca la información mencionada en las variables `TwitterName` y `DaysCompleted`.
 
-Let's now run our program and you see we have input for both of the above.
+Ahora vamos a ejecutar nuestro programa y verás que tenemos la entrada de ambas variables.
 
 ![](Images/Day12_Go2.png)
 
-Ok, that's great we got some user input and we printed a message but what about getting our program to tell us how many days we have left in our challenge.
+Vale, está muy bien, hemos conseguido un input del usuario y hemos imprimido un mensaje con los valores obtenidos. pero ¿qué pasa si conseguimos que nuestro programa nos diga cuántos días nos quedan en nuestro reto?
 
-For us to do that we have created a variable called `remainingDays` and we have hard valued this in our code as `90` we then need to change the value of this value to print out the remaining days when we get our user input of `DaysCompleted` we can do this with this simple variable change.
+Para ello, vamos a crear una variable llamada `remainingDays` y le daremos el valor integer "90". A continuación, tenemos que cambiar este valor para imprimir los días restantes cuando recibamos la entrada del usuario de "días completados", es decir, hacer una resta.
 
-```
+```go
 remainingDays = remainingDays - DaysCompleted
 ```
 
-You can see how our finished program looks here [day12_example2.go](Go/day12_example3.go).
+Puedes ver el aspecto de nuestro programa terminado en el fichero [day12_example2.go](Go/day12_example3.go).
 
-If we now run this program you can see that simple calculation is made based on the user input and the value of the `remainingDays`
+Si ahora ejecutamos este programa puedes ver que se hace un simple cálculo basado en la entrada del usuario y el valor de la variable `remainingDays`.
 
 ![](Images/Day12_Go3.png)
 
-## What is a pointer? (Special Variables)
+## ¿Qué es un puntero? (Variables especiales)
 
-A pointer is a (special) variable that points to the memory address of another variable.
+Un puntero es una variable (especial) que apunta a la dirección de memoria de otra variable.
 
-A great explanation of this can be found here at [geeksforgeeks](https://www.geeksforgeeks.org/pointers-in-golang/)
+Puedes ver una explicación más detallada en [geeksforgeeks](https://www.geeksforgeeks.org/pointers-in-golang/).
 
-Let's simplify our code now and show with and without the `&` in front of one of our print commands, this gives us the memory address of the pointer. I have added this code example here. [day12_example4.go](Go/day12_example4.go)
+Ahora, simplifiquemos nuestro código y mostremos con y sin el `&` delante de uno de nuestros comandos de impresión, esto nos da la dirección de memoria del puntero. El ejemplo del código lo puedes encontrar en el fichero [day12_example4.go](Go/day12_example4.go).
 
-Below is running this code.
+A continuación ejecuta este código y observa.
 
 ![](Images/Day12_Go4.png)
 
-## Resources
+## Recursos
 
 - [StackOverflow 2021 Developer Survey](https://insights.stackoverflow.com/survey/2021)
 - [Why we are choosing Golang to learn](https://www.youtube.com/watch?v=7pLqIIAqZD4&t=9s)
@@ -72,4 +76,4 @@ Below is running this code.
 - [FreeCodeCamp - Learn Go Programming - Golang Tutorial for Beginners](https://www.youtube.com/watch?v=YS4e4q9oBaU&t=1025s)
 - [Hitesh Choudhary - Complete playlist](https://www.youtube.com/playlist?list=PLRAV69dS1uWSR89FRQGZ6q9BR2b44Tr9N)
 
-See you on [Day 13](day13.md).
+Nos vemos en el [Día 13](day13.md).

2022/es/Days/day13.md

@@ -1,76 +1,76 @@
-## Tweet your progress with our new App
+## Tuitea tu progreso con nuestra nueva App
 
-On the final day of looking into this programming language, we have only just touched the surface here of the language but it is at that start that I think we need to get interested and excited and want to dive more into it.
+Hoy es el último día viendo este lenguaje de programación. Apenas hemos tocado la superficie de Go pero es un inicio. Ahora debemos interesarnos, entusiasmarnos y sumergirnos más en él por nuestra cuenta.
 
-Over the last few days, we have taken a small idea for an application and we have added functionality to it, in this session I want to take advantage of those packages we mentioned and create the functionality for our app to not only give you the update of your progress on screen but also send a tweet with the details of the challenge and your status.
+Pero vamos a aprovechar el último día para agregar una funcionalidad a nuestra app. Aprovecharemos los paquetes creados y haremos que nuestra app, no solo te de la actualización de tu progreso en pantalla, sino que también envíe un tweet con los detalles del reto y tu estado. 😊
 
-## Adding the ability to tweet your progress
+##  Añadir la capacidad de tuitear
 
-The first thing we need to do is set up our developer API access with Twitter for this to work.
+Para que esto funcione, lo primero que tenemos que hacer es configurar nuestro acceso a la API para desarrolladores de Twitter.
 
-Head to the [Twitter Developer Platform](https://developer.twitter.com) and sign in with your Twitter handle and details. Once in you should see something like the below without the app that I already have created.
+Dirígete a la [Plataforma de Desarrolladores de Twitter](https://developer.twitter.com) e inicia sesión con tu nombre y datos de Twitter. Una vez dentro deberías ver algo como lo que se muestra a continuación sin la aplicación que ya he creado.
 
 ![](Images/Day13_Go1.png)
 
-From here you may also want to request elevated access, this might take some time but it was very fast for me.
+Desde aquí también se puede solicitar acceso más elevado, esto puede llevar algo de tiempo.
 
-Next, we should select Projects & Apps and create our App. Limits are depending on the account access you have, with essential you only have one app and one project and with elevated you can have 3 apps.
+A continuación debemos seleccionar Projects & Apps y crear nuestra App. Los límites dependen del acceso de la cuenta que tengas, con essential solo tienes una app y un proyecto y con elevated puedes tener 3 apps.
 
 ![](Images/Day13_Go2.png)
 
-Give your application a name
+Dale un nombre a tu aplicación
 
 ![](Images/Day13_Go3.png)
 
-You will be then given these API tokens, you must save these somewhere secure. (I have since deleted this app) We will need these later with our Go Application.
+A continuación, se le dará estos tokens de la API. Debes guardarlos en algún lugar seguro, los necesitaremos más tarde con nuestra aplicación Go.(No te molestes en intentar usar los que se ven en la captura, esta aplicación ya se ha borrado).
 
 ![](Images/Day13_Go4.png)
 
-Now we have our app created,(I did have to change my app name as the one in the screenshot above was already taken, these names need to be unique)
+Ahora tenemos nuestra aplicación creada, (se cambio el nombre de la aplicación (A cade90) ya que el de la captura anterior (test90) ya estaba tomado, estos nombres deben ser únicos).
 
 ![](Images/Day13_Go5.png)
 
-The keys that we gathered before are known as our consumer keys and we will also need our access token and secrets. We can gather this information using the "Keys & Tokens" tab.
+Las claves que guardamos antes se conocen como nuestras consumer keys y también necesitaremos nuestro token de acceso y secrets. Podemos reunir esta información usando la pestaña "Keys & Tokens".
 
 ![](Images/Day13_Go6.png)
 
-Ok, we are done in the Twitter developer portal for now. Make sure you keep your keys safe because we will need them later.
+Bien, por ahora hemos terminado en el portal de desarrolladores de Twitter. Asegúrate de mantener tus claves a salvo porque las necesitaremos más adelante.
 
 ## Go Twitter Bot
 
-Remember the code we are starting within our application as well [day13_example1](Go/day13_example1.go) but first, we need to check we have the correct code to make something tweet
+Recuerda que el código que vamos a iniciar dentro de nuestra aplicación es el del fichero [day13_example1](Go/day13_example1.go) pero antes, tenemos que comprobar que tenemos el código correcto para hacer el tweet.
 
-We now need to think about the code to get our output or message to Twitter in the form of a tweet. We are going to be using [go-twitter](https://github.com/dghubble/go-twitter) This is a Go client library for the Twitter API.
+Ahora tenemos que pensar en el código para hacer llegar nuestra salida o mensaje a Twitter en forma de tweet. Vamos a utilizar la librería [go-twitter](https://github.com/dghubble/go-twitter) (Librería cliente de Go para la API de Twitter).
 
-To test this before putting this into our main application, I created a new directory in our `src` folder called go-twitter-bot, issued the `go mod init github.com/michaelcade/go-Twitter-bot` on the folder which then created a `go.mod` file and then we can start writing our new main.go and test this out.
+Para probar antes de ponerlo en nuestra aplicación principal, crea un nuevo directorio en la carpeta `src` llamado go-twitter-bot, emite el `go mod init github.com/michaelcade/go-Twitter-bot` en la carpeta que luego creará un archivo `go.mod`. Ahora podemos empezar a escribir el nuevo main.go y probarlo.
 
-We now need those keys, tokens and secrets we gathered from the Twitter developer portal. We are going to set these in our environment variables. This will depend on the OS you are running:
+Necesitamos las claves, los tokens y los secrets que recogimos del portal de desarrolladores de Twitter. Vamos a establecerlos en nuestras variables de entorno. Esto dependerá del sistema operativo que estés ejecutando:
 
-Windows
+**Windows**
 
-```
+```cmd
 set CONSUMER_KEY
 set CONSUMER_SECRET
 set ACCESS_TOKEN
 set ACCESS_TOKEN_SECRET
 ```
 
-Linux / macOS
+**Linux / macOS**
 
-```
+```shell
 export CONSUMER_KEY
 export CONSUMER_SECRET
 export ACCESS_TOKEN
 export ACCESS_TOKEN_SECRET
 ```
 
-At this stage, you can take a look at [day13_example2](Go/day13_example2.go) at the code but you will see here that we are using a struct to define our keys, secrets and tokens.
+En este punto, echa un vistazo al código del fichero [day13_example2](Go/day13_example2.go), verás que aquí se está usando una estructura para definir las claves, secretos y tokens.
 
-We then have a `func` to parse those credentials and make that connection to the Twitter API
+Luego tenemos un `func` para analizar esas credenciales y hacer la conexión con la API de Twitter
 
-Then based on the success we will then send a tweet.
+Ahora sí, vamos a enviar un tweet. 🐦
 
-```
+```go
 package main
 
 import (
@@ -148,15 +148,15 @@ func main() {
 
 ```
 
-The above will either give you an error based on what is happening or it will succeed and you will have a tweet sent with the message outlined in the code.
+Lo anterior puede que imprima en pantall un error basado explicando lo que sucedido, espero que no. O tendrá éxito, sin mensaje alguno, tendrás un tweet enviado con el mensaje señalado en el código.
 
-## Pairing the two together - Go-Twitter-Bot + Our App
+## Emparejando los dos juntos. Go-Twitter-Bot + Nuestra App
 
-Now we need to merge these two in our `main.go` I am sure someone out there is screaming that there is a better way of doing this and please comment on this as you can have more than one `.go` file in a project it might make sense but this works.
+Ahora tenemos que fusionarlo en el fichero `main.go`. Estoy seguro de que alguien por ahí está gritando que hay una mejor manera de hacer esto. Tan solo comentar que podría haber más de un archivo `.go` en un proyecto, podría tener sentido. Pero esto también funciona.
 
-You can see the merged codebase [day13_example3](Go/day13_example3.go) but I will also show it below.
+Puedes ver el código base fusionado en el fichero [day13_example3](Go/day13_example3.go) pero también se muestra a continuación.
 
-```
+```go
 package main
 
 import (
@@ -258,29 +258,31 @@ func main() {
 }
 ```
 
-The outcome of this should be a tweet but if you did not supply your environment variables then you should get an error like the one below.
+El resultado de esto debería ser un tweet, pero si no suministraste las variables de entorno tendrás el siguiente error.
 
 ![](Images/Day13_Go7.png)
 
-Once you have fixed that or if you choose not to authenticate with Twitter then you can use the code we finished with yesterday. The terminal output on success will look similar to this:
+Una vez que hayas arreglado esto la salida del terminal en caso de éxito será similar a esta:
 
 ![](Images/Day13_Go8.png)
 
-The resulting tweet should look something like this:
+El tweet resultante debería tener un aspecto similar al siguiente
 
 ![](Images/Day13_Go9.png)
 
-## How to compile for multiple OSs
+## ¿Cómo compilar para múltiples sistemas operativos?
 
-I next want to cover the question, "How do you compile for multiple Operating Systems?" The great thing about Go is that it can easily compile for many different Operating Systems. You can get a full list by running the following command:
+Lo comentamos cuando describimos el lenguaje go en días anteriores: "¿Cómo compilar para múltiples Sistemas Operativos?" 
+
+Lo bueno de Go es que puede compilar fácilmente para muchos sistemas operativos diferentes. Puedes obtener una lista completa ejecutando el siguiente comando:
 
 ```
 go tool dist list
 ```
 
-Using our `go build` commands so far is great and it will use the `GOOS` and `GOARCH` environment variables to determine the host machine and what the build should be built for. But we can also create other binaries by using the code below as an example.
+El uso de nuestros comandos `go build` hasta ahora es genial y utilizará las variables de entorno `GOOS` y `GOARCH` para determinar la máquina anfitriona y construirá el ejecutable en base a esto. Pero también podemos crear otros binarios para otros SO usando el código de abajo como ejemplo.
 
-```
+```go
 GOARCH=amd64 GOOS=darwin go build -o ${BINARY_NAME}_0.1_darwin main.go
 GOARCH=amd64 GOOS=linux go build -o ${BINARY_NAME}_0.1_linux main.go
 GOARCH=amd64 GOOS=windows go build -o ${BINARY_NAME}_0.1_windows main.go
@@ -288,11 +290,13 @@ GOARCH=arm64 GOOS=linux go build -o ${BINARY_NAME}_0.1_linux_arm64 main.go
 GOARCH=arm64 GOOS=darwin go build -o ${BINARY_NAME}_0.1_darwin_arm64 main.go
 ```
 
-This will then give you binaries in your directory for all of the above platforms. You can then take this and create a makefile to build these binaries whenever you add new features and functionality to your code. I have included the [makefile](Go/makefile)
+Esto dará los binarios solicitados en el directorio para todas las plataformas configuradas.
 
-This is what I have used to create the releases you can now see on the [repository](https://github.com/MichaelCade/90DaysOfDevOps/releases)
+A continuación, puede coger este código y crear un makefile para construir los binarios cada vez que agregues nuevas características y funcionalidades al código. Echa un ojo al fichero [makefile](Go/makefile).
 
-## Resources
+Esto es lo que se ha utilizado para crear las versiones que puedes ver en el [repositorio](https://github.com/MichaelCade/90DaysOfDevOps/releases)
+
+## Recursos
 
 - [StackOverflow 2021 Developer Survey](https://insights.stackoverflow.com/survey/2021)
 - [Why we are choosing Golang to learn](https://www.youtube.com/watch?v=7pLqIIAqZD4&t=9s)
@@ -306,8 +310,8 @@ This is what I have used to create the releases you can now see on the [reposito
 - [go.dev/tour/list](https://go.dev/tour/list)
 - [go.dev/learn](https://go.dev/learn/)
 
-This wraps up the Programming language for 7 days! So much more that can be covered and I hope you have been able to continue through the content above and be able to understand some of the other aspects of the Go programming language.
+Con esto terminamos el lenguaje de programación, han pasado rápido los 7 días, no ha habido presión alguna y hemos aprendido conceptos para nuestro futuro profesional. Hay mucho más por aprender, muchísimo más, espero que continues dándole duro a los lenguajes de programación, sea go, python o el que elijas, ya que todo lo que aprendas lo podrás usar en un futuro si sigues tecleando. 
 
-Next, we take our focus into Linux and some of the fundamentals that we should all know there.
+A continuación, nos centramos en Linux y en algunos de los fundamentos que todos deberíamos conocer allí. 🐧
 
-See you on [Day 14](day14.md).
+Nos vemos en el [Día 14](day14.md).

2022/es/README.md

@@ -55,7 +55,7 @@ Empecemos con lo que vas a poder ver en estos 90 días.
 - [✔️] ⌨️ 9 > [Vamos a explicar el código de Hello World](Days/day09.md)
 - [✔️] ⌨️ 10 > [The Go Workspace & Compiling & running code](Days/day10.md)
 - [✔️] ⌨️ 11 > [Variables, Constants & Data Types](Days/day11.md)
-- [✔️] ⌨️ 12 > [Obtención del input user con Punteros y un programa terminado](Days/day12.md)
+- [✔️] ⌨️ 12 > [Obtención del input del usuario con Punteros y un programa terminado](Days/day12.md)
 - [✔️] ⌨️ 13 > [Tuitear tus progresos con nuestra nueva App](Days/day13.md)
 
 ### Conociendo lo básico de Linux