chore(03): updated examples

Author: crsanti

03-cd/00-groovy/00-grovy-console.md

@@ -1,15 +1,14 @@
 # The Groovy Console
 
-Lo primero que necesitamos para trabajar con cualquier tipo de lenhuajes es algo que valide y verificque que nuestro código se comporta de la manera que nsostros esperamos.
+Lo primero que necesitamos para trabajar con cualquier tipo de lenguajes es algo que valide y verifique que nuestro código se comporta de la manera que nsostros esperamos.
 
+Nuestro objetivo final será `Jenkins`. Como nota al respecto, `Jenkins` tiene internamente, una consola de `Groovy` para validar de los `scripts`. Pero para desarrollar nos puede convenir una solución más ligera.
 
-Nuestro objectivo final será `Jenkins`. Como nota al respecto, `Jenkins` tiene internamente, una consola de `Groovy` para validar de los `scripts`. Pero para desarrollar nos puede convenir una solución más ligera.
+`Apache`, tiene una herramienta como la que necesitamos [link](http://groovy-lang.org/download.html). Esta aplicación es una aplicación de `swing`.
 
-`Apache`, tiene una herramienta como la que necesiatamos [link](http://groovy-lang.org/download.html). Esta aplicación es una aplicación de `swing`.
-
-* Algo para verificar y validar nuestro código.
-* Nuestro objetivo es `Jenkins`.
-* Un sitio para experimentar.
+- Algo para verificar y validar nuestro código.
+- Nuestro objetivo es `Jenkins`.
+- Un sitio para experimentar.
 
 Una alternativa a instalar de manera local, es utilizar un [contenedor de Docker](https://hub.docker.com/_/groovy?tab=description)
 
@@ -33,18 +32,19 @@ System.getenv().each{
 println "------------------------------------------------------------------"
 ```
 
-Ahora desde el directorio raíz en el cual hemos creado el ficero anterior, podemos ejecutar:
+Ahora desde el directorio raíz en el cual hemos creado el fichero anterior, podemos ejecutar:
 
 ```bash
-docker run --rm -v "$PWD":/home/groovy/scripts -w /home/groovy/scripts groovy:latest groovy BasicDocker.groovy -a 
+docker run --rm -v "$PWD":/home/groovy/scripts -w /home/groovy/scripts groovy:latest groovy BasicDocker.groovy
 ```
 
-* `-a` es para volcar las variables de sistema.
-* `-w` establecemos el directorio de trabajo dentro del contenedor.
+- `--rm` elimina el contenedor cuando esté parado.
+- `-v` enlazamos el directorio en el que nos encontramos a `/home/groovy/scripts` dentro del contenedor.
+- `-w` establecemos el directorio de trabajo dentro del contenedor a `/home/groovy/scripts`.
 
 # Demo: La Consola de Groovy
 
-* Create `playground/00_groovy_console.groovy`
+- Create `playground/00_groovy_console.groovy`
 
 ```groovy
 def x = 5
@@ -92,4 +92,4 @@ Jaimes-MacBook-Pro:playground jaimesalaszancada$ docker run --rm -v $(pwd):/home
 Caught: java.lang.AssertionError: Value was not eleven. Expression: (x == 11). Values: x = 10
 java.lang.AssertionError: Value was not eleven. Expression: (x == 11). Values: x = 10
         at 00_groovy_console.run(00_groovy_console.groovy:7)
-```
+```

03-cd/00-groovy/01-tipos-de-datos.md

@@ -2,18 +2,18 @@
 
 **Groovy** es un lenguaje con tipado opcional, lo que significa que podemos trabajar con tipos `primitivos de Java`, o podemos dejar que el `runtime` los deduzca del contexto, lo cuál lo hace bastante bien.
 
-* `x` es claramente un número
-* Un lenguaje opcionalmente tipado
-* Sin ninguna definición de tipo
+- `x` es claramente un número
+- Un lenguaje opcionalmente tipado
+- Sin ninguna definición de tipo
 
 Veamos cuales son los tipo primitivos que vamos a utilizar:
 
 | Data Type | Groovy Keyword | Sample Data   |
-|:---------:|:--------------:|---------------|
-|  Strings  |     String     | "Jaime Salas" |
-|  Integers |       int      |   0, 1, 2, 3  |
-|   Floats  |      float     |    0.5, 3.8   |
-|  Boolean  |     Boolean    |  true, false  |
+| --------- | -------------- | ------------- |
+| Strings   | String         | "Jaime Salas" |
+| Integers  | int            | 0, 1, 2, 3    |
+| Floats    | float          | 0.5, 3.8      |
+| Boolean   | Boolean        | true, false   |
 
 # Demo: Tipos de Datos
 
@@ -30,12 +30,12 @@ println name + " is a programmer? " + isProgrammer // [1]
 println name + " wishes his salary was " + salary // [1]
 ```
 
-1. Groovy convierte los `booleans` y  `float` a `strings`
+1. Groovy convierte los `booleans` y `float` a `strings`
 
 Y lo podemos ejecutar de la siguiente manera:
 
 ```bash
-$ docker run --rm -v $(pwd):/home/groovy/scripts -w /home/groovy/scripts groovy:latest groovy 01_groovy_data_types.groovy 
+$ docker run --rm -v $(pwd):/home/groovy/scripts -w /home/groovy/scripts groovy:latest groovy 01_groovy_data_types.groovy
 Joe Doe has created 14 courses.
 Joe Doe is a programmer? true
 Joe Doe wishes his salary was 1000000.0
@@ -56,7 +56,7 @@ println name + " wishes his salary was " + salary
 ```
 
 ```bash
-$ docker run --rm -v $(pwd):/home/groovy/scripts -w /home/groovy/scripts groovy:latest groovy 01_groovy_data_types.groovy 
+$ docker run --rm -v $(pwd):/home/groovy/scripts -w /home/groovy/scripts groovy:latest groovy 01_groovy_data_types.groovy
 Joe Doe has created 14 courses.
 Joe Doe is a programmer? True
 Joe Doe wishes his salary was 1000000.0
@@ -77,7 +77,7 @@ println name + " is a programmer? " + isProgrammer.toString().capitalize()
 ```
 
 ```bash
-$ docker run --rm -v $(pwd):/home/groovy/scripts -w /home/groovy/scripts groovy:latest groovy 01_groovy_data_types.groovy 
+$ docker run --rm -v $(pwd):/home/groovy/scripts -w /home/groovy/scripts groovy:latest groovy 01_groovy_data_types.groovy
 Joe Doe has created 14 courses.
 Joe Doe is a programmer? True
 Joe Doe wishes his salary was $1000000.00
@@ -102,6 +102,6 @@ Simplemente como nota en `Java` tenemos `;` para terminar una línea, en `Groovy
 
 ### Tipos de Datos y Sintaxis
 
-* "def" opcional o tipo de dato explicito
-* ¿Perder el tipado? Nop
-* Ciando devolvemos un valor está perfectamente claro el tipo devuelto
+- "def" opcional o tipo de dato explicito
+- ¿Perder el tipado? Nop
+- Cuando devolvemos un valor está perfectamente claro el tipo devuelto

03-cd/00-groovy/02-estructuras-de-control.md

@@ -1,6 +1,6 @@
 # Estructuras de Control
 
-Para hacer algo medianamente importante en nuestros scripts, necesitamos estructuras de control. La más esencial de ellas es `if else`, que tiene la misma apariencia que en `Java` on en `C` 
+Para hacer algo medianamente importante en nuestros scripts, necesitamos estructuras de control. La más esencial de ellas es `if else`, que tiene la misma apariencia que en `Java` on en `C`
 
 ```groovy
 if (isProgrammer) {
@@ -10,7 +10,7 @@ else {
     println "Not a programmer, tho"
 }
 ```
- 
+
 Lo mismo para un `loop`
 
 ```groovy
@@ -30,7 +30,6 @@ while (i < courseCount) {
 }
 ```
 
-
 Podemos definir un `for in loop` de la siguiente manera:
 
 ```groovy
@@ -84,7 +83,7 @@ singers.each{println(it)}
 Y lo ejecutamos de la siguiente manera:
 
 ```bash
-$ docker run --rm -v $(pwd):/home/groovy/scripts -w /home/groovy/scripts groovy:latest groovy 02_control_structures.groovy 
+$ docker run --rm -v $(pwd):/home/groovy/scripts -w /home/groovy/scripts groovy:latest groovy 02_control_structures.groovy
 He's a programmer
 Chris made course 1!!!
 Chris made course 2!!!
@@ -110,4 +109,4 @@ George
 Jeff
 Roy
 Tom
-```
+```

03-cd/00-groovy/03-subrutinas.md

@@ -1,23 +1,21 @@
 # Subrutinas
 
-En `Groovy` existen dos tipos de subrutinas. Funciones y métodos. 
-
-Las funciones deveulven un valor, los métodos no. Algunos lenguajes hacen una fuerte defirenciación entre ambos tipos, pero `Groovy`, como `Java` y `C#`, simplemente define un método como una función devolviendo el tipo `void`. 
+En `Groovy` existen dos tipos de subrutinas. Funciones y métodos.
 
+Las funciones devuelven un valor, los métodos no. Algunos lenguajes hacen una fuerte diferenciación entre ambos tipos, pero `Groovy`, como `Java` y `C#`, simplemente define un método como una función devolviendo el tipo `void`.
 
 Imaginemos que en nuestros procesos de build, necesitamos generar credenciales para los usuarios. Queremos crear un nombre de usuario simple usando la primera letra del nombre más el apellido, de esta manera los usuarios tendrán un nombre de usuario único.
 
-
 Nuestra segunda función va a ser un función que imprima los nombres por consola.
 
-* Funciones
-* Métodos
-* Groovy, Java y C#: void return type
-* Una función para crear credenciales desde el nombre
+- Funciones
+- Métodos
+- Groovy, Java y C#: void return type
+- Una función para crear credenciales desde el nombre
 
-# Demo: Soubrutinas
+# Demo: Subrutinas
 
-Crear un nuevo fichero [03_groovy_soubroutines](playground/03_soubroutines.groovy)
+Crear un nuevo fichero [03_groovy_subroutines](playground/03_soubroutines.groovy)
 
 Vamos a comenzar una aseveración sencilla
 
@@ -35,9 +33,9 @@ String getUserName(String firstName, String lastName) {
 assert getUserName("Jaime", "Salas") == "jsalas" : "getUserName isn't working"
 ```
 
-Lo podemos ejecutar con `docker run --rm -v $(pwd):/home/groovy/scripts -w /home/groovy/scripts groovy:latest groovy 03_subroutines.groovy`, nos devuelve __null__ indicando que el resultado es correcto.
+Lo podemos ejecutar con `docker run --rm -v $(pwd):/home/groovy/scripts -w /home/groovy/scripts groovy:latest groovy 03_subroutines.groovy`, nos devuelve **null** indicando que el resultado es correcto.
 
-Imprimos el valor a la consola para hacerlo un poco más claro:
+Imprimimos el valor a la consola para hacerlo un poco más claro:
 
 ```diff
 String getUserName(String firstName, String lastName) {
@@ -69,10 +67,10 @@ printCredentials(getUserName("Jaime", "Salas"))
 /**/
 ```
 
-Después de ejecutar, teenmos
+Después de ejecutar, tenemos
 
 ```bash
-$ docker run --rm -v $(pwd):/home/groovy/scripts -w /home/groovy/scripts groovy:latest groovy 03_soubroutines.groovy 
+$ docker run --rm -v $(pwd):/home/groovy/scripts -w /home/groovy/scripts groovy:latest groovy 03_subroutines.groovy
 jsalas
 UserName is jsalas
 ```
@@ -107,10 +105,10 @@ void printCredentials(cred) {
 Después de ejecutar, tenemos
 
 ```bash
-$ docker run --rm -v $(pwd):/home/groovy/scripts -w /home/groovy/scripts groovy:latest groovy 03_soubroutines.groovy 
+$ docker run --rm -v $(pwd):/home/groovy/scripts -w /home/groovy/scripts groovy:latest groovy 03_subroutines.groovy
 UserName is fadriá
 UserName is dgarcía
 UserName is jcruz
 UserName is jroca
 UserName is mberasategi
-```
+```

03-cd/00-groovy/04-clases-objetos.md

@@ -4,10 +4,10 @@ Con las subrutinas ya tenemos una primera base para la encapsulación. Pero desd
 
 Para crear una clase simplemente usamos `class`.
 
-* Nivel base para la encapsulación
-* Envolvemos nuestro código en clases
-* Listas paralelas => objectos con dos propiedades 
-* Muy similar a `Java` o `C#`
+- Nivel base para la encapsulación
+- Envolvemos nuestro código en clases
+- Listas paralelas => objectos con dos propiedades
+- Muy similar a `Java` o `C#`
 
 ```groovy
 class User {
@@ -19,7 +19,7 @@ User user = new User();
 
 # Demo: Trabajando con Clases y Objetos
 
-Creamos el siguiente fichero [04_working_with_classe_and_objects.groovy](playground/04_working_with_classes_and_objects.groovy)
+Creamos el siguiente fichero [04_working_with_classes_and_objects.groovy](playground/04_working_with_classes_and_objects.groovy)
 
 > Nota: Comenzamos desde el código de la demo anterior.
 
@@ -72,10 +72,10 @@ for (int i = 0; i < firstNames.size(); i++) {
 }
 ```
 
-Podemos ejecutarlo paar verificar que el código es correcto.
+Podemos ejecutarlo para verificar que el código es correcto.
 
 ```bash
-$ docker run --rm -v $(pwd):/home/groovy/scripts -w /home/groovy/scripts groovy:latest groovy 04_working_with_classes_and_objects.groovy 
+$ docker run --rm -v $(pwd):/home/groovy/scripts -w /home/groovy/scripts groovy:latest groovy 04_working_with_classes_and_objects.groovy
 UserName is fadria
 UserName is dgarcia
 UserName is jcruz
@@ -159,4 +159,4 @@ class User {
 +for (int i = 0; i < users.size(); i++) {
 +   println("UserName is ${users[i].UserName()}")
 +}
-```
+```

03-cd/00-groovy/05-herencia.md

@@ -1,14 +1,13 @@
 # Herencia
 
-* Es posible qeu no la necesiatemos
-* `Groovy` soporta lass interfaces
-    - Las interfaces para el scripting no suele tener mucho sentido
-    - Tienen más cabida las clases abstractaas
-* Las clases abstractas no tienen implementación 
-* Nadie tiene _exactamente_ un coche
-* Tienen _instancias_ de un coche 
-* Copiar y pegar es maligno
-
+- Es posible qeu no la necesitaremos
+- `Groovy` soporta lass interfaces
+  - Las interfaces para el scripting no suele tener mucho sentido
+  - Tienen más cabida las clases abstractas
+- Las clases abstractas no tienen implementación
+- Nadie tiene _exactamente_ un coche
+- Tienen _instancias_ de un coche
+- Copiar y pegar es maligno
 
 # Demo: Herencia
 
@@ -45,7 +44,7 @@ users.each(user -> println("UserName is ${user.UserName()}"))
 Y lo podemos ejecutar de la siguiente manera
 
 ```bash
-$ docker run --rm -v $(pwd):/home/groovy/scripts -w /home/groovy/scripts groovy:latest groovy 05_inheritance.groovy 
+$ docker run --rm -v $(pwd):/home/groovy/scripts -w /home/groovy/scripts groovy:latest groovy 05_inheritance.groovy
 UserName is bdylan
 UserName is jlynne
 UserName is rorbison
@@ -176,4 +175,4 @@ users.each{
 }
 /*diff*/
 
-```
+```

03-cd/00-groovy/06-external-packages.md

@@ -2,15 +2,14 @@
 
 En este punto, ya deberíamos tener una base para crear scripts en `Groovy`. Pero nos falta una última pieza, el proceso de interactuar con paquetes externos.
 
-* Paquetes externos
-* Nos permiten acceder al trabajo de otros desarrolladores.
+- Paquetes externos
+- Nos permiten acceder al trabajo de otros desarrolladores.
 
 La realidad es que ya tenemos de forma automática ciertos paquetes con `Groovy`, la realidad es que no los podemos llamar realmente externos porque siempre van a estar incluidos. Todo script de `Groovy` importa los siguientes paquetes.
 
-| java.io.* | java.lang.* | java.math.BigDecimal | java.math.BigInteger |
-|:---------:|:-----------:|----------------------|----------------------|
-|  java.net |  java.util  |     groovy.lang.*    |     groovy.util.*    |
-
+| java.io.\* | java.lang.\* | java.math.BigDecimal | java.math.BigInteger |
+| ---------- | ------------ | -------------------- | -------------------- |
+| java.net   | java.util    | groovy.lang.\*       | groovy.util.\*       |
 
 Esto es equivalente a tener los siguientes imports en nuestro script
 
@@ -25,8 +24,7 @@ import java.math.BigInteger
 import java.math.BigDecimal
 ```
 
-Casi siempre que comenzamos a trabajar terminamos necesiatndo alguno de estos.
-
+Casi siempre que comenzamos a trabajar terminamos necesitando alguno de estos.
 
 # Demo: Trabajando con paquetes externos
 
@@ -41,7 +39,7 @@ ArrayList data = jsonSlurper.parse(new File(filePath));
 println(data.getClass())
 
 for (chef: data) {
-    
+
     println(chef.name);
     for (restaurant: chef.restaurants) {
         println('\t' + restaurant.name)
@@ -56,4 +54,4 @@ Si ejecutamos esto ahora obtenemos el siguiente mensaje: `3: unable to resolve c
 +
 String filePath = "/home/groovy/scripts/chef.json";
 ...
-```
+```