diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000000..49e0fc6b4d
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+/node_modules
+/package-lock.json
\ No newline at end of file
diff --git "a/01 - Instalaci\303\263n de Herramientas/homework.md" "b/01 - Instalaci\303\263n de Herramientas/homework.md"
new file mode 100644
index 0000000000..96ed119884
--- /dev/null
+++ "b/01 - Instalaci\303\263n de Herramientas/homework.md"	
@@ -0,0 +1,45 @@
+![HenryLogo](../Assets//logoBannerHenry.png)
+
+# **HOMEWORK 01 | INSTALACIÓN DE HERRAMIENTAS**
+
+## **📌 LINKS IMPORTANTES**
+
+---
+
+</br >
+
+### **📍 NODE**
+
+Recuerda que debes descargar la versión **LTS** de Node.JS, ya que la versión más actual puede tener incompatibilidades.
+
+[**LINK DE DESACRGA**](https://nodejs.org/es/)
+
+---
+
+</br >
+
+### **📍 GIT**
+
+Recuerda que si tu sistema operativo en **Linux** ya tienes GIT instalado por default. Si tu sistema operativo es **Windows** puedens descargarlo en el siguiente link:
+
+[**LINK DE DESACRGA**](https://gitforwindows.org/)
+
+---
+
+</br >
+
+### **📍 SLACK**
+
+No es obligatorio que desacargues este aplicación en tu computadora, pero te será más sencillo poder comunicarte con la comunidad.
+
+[**LINK DE DESACRGA**](https://slack.com/intl/es-ar/downloads/windows)
+
+---
+
+</br >
+
+### **📍 GITHUB DESKTOP**
+
+No es necesario que descargues esta aplicación para utilizar GitHub. Simplemente puedes utilizar la versión web. Pero si quieres acelerar los procesos te dejamos el link de desacarga!
+
+[**LINK DE DESACRGA**](https://desktop.github.com/)
diff --git a/02 - Terminal, Git y GitHub/homework.md b/02 - Terminal, Git y GitHub/homework.md
new file mode 100644
index 0000000000..22959924bc
--- /dev/null
+++ b/02 - Terminal, Git y GitHub/homework.md	
@@ -0,0 +1,92 @@
+![HenryLogo](../Assets//logoBannerHenry.png)
+
+# **HOMEWORK 02 | COMANDOS - GIT - GITHUB**
+
+## **📋 PRE-REQUISITOS**
+
+1. Crear una cuenta en [**GITHUB**](https://www.github.com/).
+2. Si usas una computadora con Windows, puedes instalar la terminal de comandos [**GIT-BASH**](https://git-for-windows.github.io/).
+3. Si usas Mac, `git` viene pre-instalado y puedes acceder desde la terminal pulsando `⌘+Espacio` y escribiendo "_terminal_". Puedes asegurarte de que git está instalado escribiendo "_which git_" en la terminal y pulsando "**Enter**". Si aparece la ruta de un archivo significa que todo está correcto. En algunas ocasiones, podrías ser redireccionado a la descarga de la línea de comandos de Xcode, sigue las instrucciones.
+   -  Si usas Linux, tal vez necesites instalar git accediendo a tu terminal e ingresado `apt-get install git`
+   -  Si tienes problemas instalando Git, este [**recurso**](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git) puede servir de ayuda.
+
+---
+
+</br >
+
+## **📌 INSTRUCCIONES**
+
+### **📍 COMANDOS PARA LA TERMINAL**
+
+Utilicemos los principales comandos de nuestra terminal para realizar algunas acciones básicas.
+
+"**List**" o "**Directory**": nos permite ver el contenido del directorio en el que nos encontramos.
+
+```bash
+LINUX   $ ls
+WINDOWS $ dir
+```
+
+"**Change Directory**": nos permite movernos a un directorio a otro.
+
+```bash
+        $ cd [nombreDeLaCarpeta]  -----> PARA INGRESAR A UN DIRECTORIO
+        $ cd ..                   -----> PARA VOLVER AL DIRECTORIO ANTERIOR
+```
+
+"**Make Directory**": crea una nueva carpeta en el directorio donde nos encontramos actualmente.
+
+```bash
+        $ mkdir [nombreDeLaCarpeta]
+```
+
+"**Touch**" o "**TYPE NUL**": creará un nuevo archivo.
+
+```bash
+LINUX   $ touch [nombreDelArchivo]
+WINDOWS $ type nul > [nombreDelArchivo]
+```
+
+"**Remove**": elimina permanentemente un archivo.
+
+> **⚠️ [NOTA]:** ¡CUIDADO! Esto traspasa cualquier "papelera de reciclaje" que exista en el sistema y elimina los archivos PERMANENTEMENTE. Esto no eliminará carpetas. Necesitamos un comando especial para eso.
+
+```bash
+        $ rm [nombreDelArchivo]
+```
+
+---
+
+</br >
+
+### **📍 EJERCICIO 01**
+
+En este ejercicio debes crear una nueva carpeta con el nombre "_CarpetaHenry_". Utiliza los comandos de más arriba.
+
+---
+
+</br >
+
+### **📍 EJERCICIO 02**
+
+Ingresa a la carpeta que acabas de crear utilizando los comandos ya aprendidos.
+
+---
+
+</br >
+
+### **📍 EJERCICIO 03**
+
+Ahora debes crear un archivo llamado "**_README.md_**". Revisa el comando correspondiente a partir del sistema operativo que utilices (Linux o Windows).
+
+---
+
+</br >
+
+### **📍 EJERCICIO 04**
+
+A partir de la carpeta y archivo que acabas de crear debes generar un repositorio en GitHub. Para esto ingresa a [**GITHUB**](https://github.com/) y logueate con tu usuario y contraseña.
+
+El objetivo de este ejercicio es que crees un repositorio y puedas sincronizar la carpeta "_**CarpetaHenry**_" con ese nuevo repositorio. Para lograr esto te recomendamos que sigas el siguiente video:
+
+[![Alt text](../Assets//M1Video.png)](https://www.youtube.com/watch?v=QNydgNRgGS4)
diff --git a/03 - JavaScript I/Ejercicio 01.js b/03 - JavaScript I/Ejercicio 01.js
new file mode 100644
index 0000000000..c702be19cc
--- /dev/null
+++ b/03 - JavaScript I/Ejercicio 01.js	
@@ -0,0 +1,30 @@
+/*⚠️ NO MODIFIQUES EL NOMBRE DE LAS DECLARACIONES ⚠️*/
+/*1️⃣ EJERCICIO 01 1️⃣*/
+
+// Crea una variable de tipo string.
+const nuevoString = null;
+
+// Crea una variable de tipo number.
+const nuevoNumero = null;
+
+// Crea una variable de tipo boolean.
+const nuevoBoolean = null;
+
+// Resuelve el siguiente problema matemático.
+const nuevaResta = 10 - null === 3;
+
+// Resuelve el siguiente problema matemático.
+const nuevaMultiplicacion = 10 * null === 40;
+
+// Resuelve el siguiente problema matemático.
+const nuevoModulo = 21 % 5 === null;
+
+/*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
+module.exports = {
+   nuevoString,
+   nuevoNumero,
+   nuevoBoolean,
+   nuevaResta,
+   nuevaMultiplicacion,
+   nuevoModulo,
+};
diff --git a/03 - JavaScript I/Ejercicio 02.js b/03 - JavaScript I/Ejercicio 02.js
new file mode 100644
index 0000000000..01d1475b45
--- /dev/null
+++ b/03 - JavaScript I/Ejercicio 02.js	
@@ -0,0 +1,45 @@
+/*⚠️ NO MODIFIQUES EL NOMBRE DE LAS DECLARACIONES ⚠️*/
+/*2️⃣ EJERCICIO 02 2️⃣*/
+
+function devolverString(string) {
+   // Debe retornar un string.
+   // Tu código:
+   return string;
+}
+
+// ⛔️ "X" e "Y" son números.
+
+function suma(x, y) {
+   // Retorna el resultado de su suma.
+   // Tu código:
+}
+
+function resta(x, y) {
+   // Retorna el resultado de la resta.
+   // Tu código:
+}
+
+function divide(x, y) {
+   // Retorna el resultado de su división.
+   // Tu código:
+}
+
+function multiplica(x, y) {
+   // Retorna el resultado de su multiplicación.
+   // Tu código:
+}
+
+function obtenerResto(x, y) {
+   // Obten el resto de la división de "x" entre "y".
+   // Tu código:
+}
+
+/*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
+module.exports = {
+   devolverString,
+   suma,
+   resta,
+   divide,
+   multiplica,
+   obtenerResto,
+};
diff --git a/03 - JavaScript I/Ejercicio 03.js b/03 - JavaScript I/Ejercicio 03.js
new file mode 100644
index 0000000000..9c531dfec8
--- /dev/null
+++ b/03 - JavaScript I/Ejercicio 03.js	
@@ -0,0 +1,49 @@
+/*⚠️ NO MODIFIQUES EL NOMBRE DE LAS DECLARACIONES ⚠️*/
+/*3️⃣ EJERCICIO 03 3️⃣*/
+
+function sonIguales(x, y) {
+   // Retorna True si "x" e "y" son iguales.
+   // De lo contrario, retorna False.
+   // Tu código:
+   return x === y;
+}
+
+function tienenMismaLongitud(str1, str2) {
+   // Retorna True si los dos strings tienen la misma longitud.
+   // De lo contrario, retorna False.
+   // Tu código:
+}
+
+function menosQueNoventa(num) {
+   // Retorna True si el argumento "num" es menor que noventa.
+   // De lo contrario, retorna False.
+   // Tu código:
+}
+
+function mayorQueCincuenta(num) {
+   // Retorna True si el argumento "num" es mayor que cincuenta.
+   // De lo contrario, retorna False.
+   // Tu código:
+}
+
+function esPar(num) {
+   // Retorna True si "num" es par.
+   // De lo contrario, retorna False.
+   // Tu código:
+}
+
+function esImpar(num) {
+   // Retorna True si "num" es impar.
+   // De lo contrario, retorna False.
+   // Tu código:
+}
+
+/*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
+module.exports = {
+   tienenMismaLongitud,
+   sonIguales,
+   menosQueNoventa,
+   mayorQueCincuenta,
+   esPar,
+   esImpar,
+};
diff --git a/03 - JavaScript I/Ejercicio 04.js b/03 - JavaScript I/Ejercicio 04.js
new file mode 100644
index 0000000000..ff7dbe2dcc
--- /dev/null
+++ b/03 - JavaScript I/Ejercicio 04.js	
@@ -0,0 +1,44 @@
+/*⚠️ NO MODIFIQUES EL NOMBRE DE LAS DECLARACIONES ⚠️*/
+/*4️⃣ EJERCICIO 04 4️⃣*/
+
+// ⛔️ Recuerda que debes utilizar el objeto global "Math".
+
+function elevarAlCuadrado(num) {
+   // Retorna el valor de "num" elevado al cuadrado.
+   // Tu código:
+}
+
+function elevarAlCubo(num) {
+   // Retorna el valor de "num" elevado al cubo.
+   // Tu código:
+}
+
+function elevar(num, exponent) {
+   // Retorna el valor de "num" elevado al exponente "exponent".
+   // Tu código:
+}
+
+function redondearNumero(num) {
+   // Redondea "num" al entero más próximo y retórnalo.
+   // Tu código:
+}
+
+function redondearHaciaArriba(num) {
+   // Redondea "num" hacia arriba y retórnalo.
+   // Tu código:
+}
+
+function numeroRandom() {
+   // Genera un número al azar entre 0 y 1 y retórnalo.
+   // Tu código:
+}
+
+/*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
+module.exports = {
+   elevarAlCuadrado,
+   elevarAlCubo,
+   elevar,
+   redondearNumero,
+   redondearHaciaArriba,
+   numeroRandom,
+};
diff --git a/03 - JavaScript I/Ejercicio 05.js b/03 - JavaScript I/Ejercicio 05.js
new file mode 100644
index 0000000000..4af6d588e8
--- /dev/null
+++ b/03 - JavaScript I/Ejercicio 05.js	
@@ -0,0 +1,71 @@
+/*⚠️ NO MODIFIQUES EL NOMBRE DE LAS DECLARACIONES ⚠️*/
+/*5️⃣ EJERCICIO 05 5️⃣*/
+
+function esPositivo(num) {
+   // La función recibe un entero. Devuelve como resultado un string que indica si el número
+   // es positivo o negativo.
+   // Si el número es positivo ---> "Es positivo".
+   // Si el número es negativo ---> "Es negativo".
+   // Si el número es 0, devuelve False.
+   // Tu código:
+}
+
+function agregarSimboloExclamacion(str) {
+   // Agrega un símbolo de exclamación al final del string "str" y retórnalo
+   // Ejemplo: "hello world" ---> "hello world!"
+   // Tu código:
+}
+
+function combinarNombres(nombre, apellido) {
+   // Retorna "nombre" y "apellido" combinados en un mismo string pero separados por un espacio.
+   // Ejemplo: ("Soy", "Henry") ---> "Soy Henry"
+   // Tu código:
+}
+
+function obtenerSaludo(nombre) {
+   // Toma el string "nombre" y concatena otra string en la cadena para que tome la siguiente forma:
+   // Ejemplo: "Martin" ---> "Hola Martin!"
+   // Tu código:
+}
+
+function obtenerAreaRectangulo(alto, ancho) {
+   // Retornar el área de un rectángulo teniendo su altura y ancho.
+   // Tu código:
+}
+
+function retornarPerimetro(lado) {
+   // La función recibe como argumento la medida de un lado de un rectángulo.
+   // Debes retornar su perímetro.
+   // Tu código:
+}
+
+function areaDelTriangulo(base, altura) {
+   // Calcula el área de un triángulo y retorna el resultado.
+   // Tu código:
+}
+
+function deEuroAdolar(euro) {
+   // Supongamos que 1 euro equivale a 1.20 dólares.
+   // Debes calcular el valor recibido como argumento pasándolo a dolares.
+   // Tu código:
+}
+
+function esVocal(letra) {
+   // Escribe una función que reciba una letra y, si es una vocal, muestre el mensaje “Es vocal”.
+   // Si el usuario ingresa un string de más de un caracter debes retornar el mensaje: "Dato incorrecto".
+   // Si no es vocal, tambien debe retornar "Dato incorrecto".
+   // Tu código:
+}
+
+/*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
+module.exports = {
+   esPositivo,
+   agregarSimboloExclamacion,
+   combinarNombres,
+   obtenerSaludo,
+   obtenerAreaRectangulo,
+   retornarPerimetro,
+   areaDelTriangulo,
+   deEuroAdolar,
+   esVocal,
+};
diff --git a/03 - JavaScript I/README.md b/03 - JavaScript I/README.md
new file mode 100644
index 0000000000..c4ee6db6d3
--- /dev/null
+++ b/03 - JavaScript I/README.md	
@@ -0,0 +1,88 @@
+![HenryLogo](../Assets//logoBannerHenry.png)
+
+# **HOMEWORK 03 | JAVASCRIPT I**
+
+## **✅ TESTING**
+
+Para ejecutar los tests de las homeworks debes:
+
+1. Desde tu terminal, dirígete a la carpeta raíz de todas las homeworks y ejecuta el comando:
+
+```bash
+    npm install
+```
+
+2. Luego de que se hayan instalado las dependencias pueden comenzar a correr los tests.
+
+-  Para ejecutarlos globalmente (es decir, el de todas las homeworks), ejecuta el comando:
+
+```bash
+    npm test
+```
+
+-  Si quieres ejecutar los tests de esta homework en específico ejecuta el comando:
+
+```bash
+    npm test 03
+```
+
+---
+
+</br >
+
+## **📋 INTRODUCCIÓN**
+
+En esta Homework podrás poner en práctica:
+
+-  Tipos de datos
+-  Variables
+-  Funciones
+-  Operadores
+
+---
+
+</br >
+
+## **📌 INSTRUCCIONES**
+
+Ingresa al archivo `homework.js` y resuelve los ejercicios.
+
+### **📍 EJERCICIO 01**
+
+En los primeros 6 ejercicios deberás corregir las declaraciones para que los resultados sean los correctos.
+
+---
+
+</br >
+
+### **📍 EJERCICIO 02**
+
+En los siguientes 6 ejercicios deberás desarrollar funciones para que cada una retorne el valor que corresponde.
+
+---
+
+</br >
+
+### **📍 EJERCICIO 03**
+
+En los siguientes 6 ejercicios deberás desarrollar funciones para que cada una realice una comparación y retorne el valor correspondiente.
+
+---
+
+</br >
+
+### **📍 EJERCICIO 04**
+
+En los siguientes 6 ejercicios deberás desarrollar funciones que utilizarán el objeto global `Math` para realizar ejercicios matemáticos. Finalmente reotrnarás el resultado.
+
+---
+
+</br >
+
+### **📍 EJERCICIO 05**
+
+En los siguientes 9 ejercicios deberás desarrollar funciones que incluyen lógica y retornar los resultados correspondientes.
+
+---
+
+</br >
diff --git a/03 - JavaScript I/test/JSI.test.js b/03 - JavaScript I/test/JSI.test.js
new file mode 100644
index 0000000000..a977687839
--- /dev/null
+++ b/03 - JavaScript I/test/JSI.test.js	
@@ -0,0 +1,345 @@
+/* eslint-disable no-undef */
+const {
+   nuevoString,
+   nuevoNumero,
+   nuevoBoolean,
+   nuevaResta,
+   nuevaMultiplicacion,
+   nuevoModulo,
+} = require('../Ejercicio 01');
+
+const {
+   devolverString,
+   suma,
+   resta,
+   divide,
+   multiplica,
+   obtenerResto,
+} = require('../Ejercicio 02');
+
+const {
+   tienenMismaLongitud,
+   sonIguales,
+   menosQueNoventa,
+   mayorQueCincuenta,
+   esPar,
+   esImpar,
+} = require('../Ejercicio 03');
+
+const {
+   elevarAlCuadrado,
+   elevarAlCubo,
+   elevar,
+   redondearNumero,
+   redondearHaciaArriba,
+   numeroRandom,
+} = require('../Ejercicio 04');
+
+const {
+   esPositivo,
+   agregarSimboloExclamacion,
+   combinarNombres,
+   obtenerSaludo,
+   obtenerAreaRectangulo,
+   retornarPerimetro,
+   areaDelTriangulo,
+   deEuroAdolar,
+   esVocal,
+} = require('../Ejercicio 05');
+
+describe('JAVASCRIPT I', function () {
+   describe('EJERCICIO 01', function () {
+      describe('nuevoString', function () {
+         it('Debe ser un string', function () {
+            expect(typeof nuevoString).toBe('string');
+         });
+      });
+
+      describe('nuevoNumero', function () {
+         it('Debe ser un número', function () {
+            expect(typeof nuevoNumero).toBe('number');
+         });
+      });
+
+      describe('nuevoBoolean', function () {
+         it('Debe ser un booleano', function () {
+            expect(typeof nuevoBoolean).toBe('boolean');
+         });
+      });
+
+      describe('nuevaResta', function () {
+         it('Debe ser la resta correcta', function () {
+            expect(nuevaResta).toBe(true);
+         });
+      });
+
+      describe('nuevaMultiplicación', function () {
+         it('Debe ser la multiplicación correcta', function () {
+            expect(nuevaMultiplicacion).toBe(true);
+         });
+      });
+
+      describe('nuevoModulo', function () {
+         it('Debe ser el resultado correcto del módulo', function () {
+            expect(nuevoModulo).toBe(true);
+         });
+      });
+   });
+
+   describe('EJERCICIO 02', function () {
+      describe('devolverString(str)', function () {
+         it('Debe retornar el string provisto', function () {
+            expect(devolverString('Henry')).toBe('Henry');
+         });
+      });
+
+      describe('suma(x, y)', function () {
+         it('Debe retornar la suma de los dos argumentos', function () {
+            expect(suma(5, 5)).toBe(10);
+            expect(suma(-1, 5)).toBe(4);
+         });
+      });
+
+      describe('resta(x, y)', function () {
+         it('Debe retornar la resta de los dos argumentos', function () {
+            expect(resta(5, 5)).toBe(0);
+            expect(resta(-1, 5)).toBe(-6);
+            expect(resta(5, -5)).toBe(10);
+            expect(resta(0, 0)).toBe(0);
+         });
+      });
+
+      describe('divide(x, y)', function () {
+         it('Debe retornar la division de los dos argumentos', function () {
+            expect(divide(5, 5)).toBe(1);
+            expect(divide(10, 5)).toBe(2);
+            expect(divide(11, 2)).toBe(5.5);
+         });
+      });
+
+      describe('multiplica(x, y)', function () {
+         it('Debe retornar el producto de los dos argumentos', function () {
+            expect(multiplica(5, 5)).toBe(25);
+            expect(multiplica(10, -5)).toBe(-50);
+            expect(multiplica(11, 0)).toBe(0);
+         });
+      });
+
+      describe('obtenerResto(x, y)', function () {
+         it('Debe retornar el resto de dividir x sobre y', function () {
+            expect(obtenerResto(15, 5)).toBe(0);
+            expect(obtenerResto(21, 5)).toBe(1);
+            expect(obtenerResto(22, 5)).toBe(2);
+         });
+      });
+   });
+
+   describe('EJERCICIO 03', function () {
+      describe('sonIguales(x, y)', function () {
+         it('Debe devolver True si los argumentos son iguales', function () {
+            expect(sonIguales(15, 15)).toBe(true);
+            expect(sonIguales('test', 'test')).toBe(true);
+         });
+         it('Debe devolver False si los argumentos no son iguales', function () {
+            expect(sonIguales(90, 50)).toBe(false);
+         });
+      });
+
+      describe('tienenMismaLongitud(str1, str2)', function () {
+         it('Debe devolver True si los strings tienen la misma longitud', function () {
+            expect(tienenMismaLongitud('javascript', 'bumfuzzled')).toBe(true);
+         });
+         it('Debe devolver False si los strings tienen la distinta longitud', function () {
+            expect(tienenMismaLongitud('hi', 'there')).toBe(false);
+         });
+      });
+
+      describe('menosQueNoventa(num)', function () {
+         it('Debe devolver True si el número es menor a noventa', function () {
+            expect(menosQueNoventa(15)).toBe(true);
+         });
+         it('Debe devolver False si el número no es menor a noventa', function () {
+            expect(menosQueNoventa(90)).toBe(false);
+            expect(menosQueNoventa(100)).toBe(false);
+         });
+      });
+
+      describe('mayorQueCincuenta(num)', function () {
+         it('Debe devolver True si el número es mayor a cincuenta', function () {
+            expect(mayorQueCincuenta(15)).toBe(false);
+            expect(mayorQueCincuenta(50)).toBe(false);
+            expect(mayorQueCincuenta(60)).toBe(true);
+         });
+         it('Debe devolver False si el número no es mayor a cincuenta', function () {
+            expect(mayorQueCincuenta(15)).toBe(false);
+            expect(mayorQueCincuenta(50)).toBe(false);
+            expect(mayorQueCincuenta(60)).toBe(true);
+         });
+      });
+
+      describe('esPar(num)', function () {
+         it('Debe devolver True si el número es par', function () {
+            expect(esPar(6)).toBe(true);
+            expect(esPar(0)).toBe(true);
+         });
+         it('Debe devolver False si el número no es par', function () {
+            expect(esPar(7)).toBe(false);
+         });
+      });
+
+      describe('esImpar(num)', function () {
+         it('Debe devolver True si el número es impar', function () {
+            expect(esImpar(6)).toBe(false);
+            expect(esImpar(7)).toBe(true);
+            expect(esImpar(0)).toBe(false);
+         });
+         it('Debe devolver False si el número no es impar', function () {
+            expect(esImpar(6)).toBe(false);
+            expect(esImpar(7)).toBe(true);
+            expect(esImpar(0)).toBe(false);
+         });
+      });
+   });
+
+   describe('EJERCICIO 04', function () {
+      describe('elevarAlCuadrado(num)', function () {
+         it('Debe devolver el número elevado al cuadrado', function () {
+            expect(elevarAlCuadrado(6)).toBe(36);
+            expect(elevarAlCuadrado(7)).toBe(49);
+            expect(elevarAlCuadrado(0)).toBe(0);
+            expect(elevarAlCuadrado(-5)).toBe(25);
+         });
+      });
+
+      describe('elevarAlCubo(num)', function () {
+         it('Debe devolver el número elevado al cubo', function () {
+            expect(elevarAlCubo(3)).toBe(27);
+            expect(elevarAlCubo(0)).toBe(0);
+            expect(elevarAlCubo(-5)).toBe(-125);
+         });
+      });
+
+      describe('elevar(num, exponent)', function () {
+         it('Debe devolver el número elevado al exponente indicado', function () {
+            expect(elevar(2, 2)).toBe(4);
+            expect(elevar(2, 3)).toBe(8);
+            expect(elevar(0, 5)).toBe(0);
+            expect(elevar(10, 1)).toBe(10);
+         });
+      });
+
+      describe('redondearNumero(num)', function () {
+         it('Debe devolver el número redondeado', function () {
+            expect(redondearNumero(1.5)).toBe(2);
+            expect(redondearNumero(2)).toBe(2);
+            expect(redondearNumero(0.1)).toBe(0);
+         });
+      });
+
+      describe('redondearHaciaArriba(num)', function () {
+         it('Debe devolver el número redondeado para arriba', function () {
+            expect(redondearHaciaArriba(1.5)).toBe(2);
+            expect(redondearHaciaArriba(2)).toBe(2);
+            expect(redondearHaciaArriba(0.1)).toBe(1);
+         });
+      });
+
+      describe('numeroRandom()', function () {
+         it('Debe devolver un número entre 0 y 1', function () {
+            expect(typeof numeroRandom()).toBe('number');
+            expect(numeroRandom()).toBeGreaterThanOrEqual(0);
+            expect(numeroRandom()).toBeLessThan(1);
+         });
+         it('Debe devolver un número random', function () {
+            expect(numeroRandom()).not.toBe(numeroRandom());
+         });
+      });
+   });
+
+   describe('EJERCICIO 05', function () {
+      describe('esPositivo(num)', function () {
+         it('Debe devolver el string "Es positivo" si el número es mayor a cero', function () {
+            expect(esPositivo(23)).toBe('Es positivo');
+         });
+         it('Debe devolver el string "Es negativo" si el número es menor a cero', function () {
+            expect(esPositivo(-2)).toBe('Es negativo');
+         });
+         it('Debe devolver False si el número es cero', function () {
+            expect(esPositivo(0)).toBe(false);
+         });
+      });
+
+      describe('agregarSimboloExclamacion(str)', function () {
+         it('Debe agregar un signo de exclamacion al final del string', function () {
+            expect(agregarSimboloExclamacion('hello world')).toBe(
+               'hello world!'
+            );
+            expect(agregarSimboloExclamacion('Soy Henry')).toBe('Soy Henry!');
+         });
+      });
+
+      describe('combinarNombres(nombre, apellido)', function () {
+         it('Debe devolver los strings combinados con un espacio en el medio', function () {
+            expect(combinarNombres('hello', 'world')).toBe('hello world');
+            expect(combinarNombres('Soy', 'Henry')).toBe('Soy Henry');
+         });
+      });
+
+      describe('obtenerSaludo(nombre)', function () {
+         it("Debe devolver el string 'Hola {name}!'", function () {
+            expect(obtenerSaludo('Martin')).toBe('Hola Martin!');
+            expect(obtenerSaludo('Antonio')).toBe('Hola Antonio!');
+         });
+      });
+
+      describe('obtenerAreaRectangulo(alto, ancho)', function () {
+         it('Debe retornar el área correcta del rectángulo', function () {
+            expect(obtenerAreaRectangulo(2, 2)).toBe(4);
+            expect(obtenerAreaRectangulo(3, 6)).toBe(18);
+            expect(obtenerAreaRectangulo(0, 2)).toBe(0);
+         });
+      });
+
+      describe('retornarPerimetro(lado)', function () {
+         it('Debe retornar el perímetro correcto del cuadrado', function () {
+            expect(retornarPerimetro(2)).toBe(8);
+            expect(retornarPerimetro(8)).toBe(32);
+            expect(retornarPerimetro(0)).toBe(0);
+         });
+      });
+
+      describe('areaDelTriangulo(base, altura)', function () {
+         it('Debe retornar el área correcta del triángulo', function () {
+            expect(areaDelTriangulo(10, 5)).toBe(25);
+            expect(areaDelTriangulo(20, 10)).toBe(100);
+            expect(areaDelTriangulo(0, 10)).toBe(0);
+         });
+      });
+
+      describe('deEuroAdolar(euro)', function () {
+         it('Debe retornar el valor correcto de euro a dolar', function () {
+            expect(deEuroAdolar(100)).toBe(120);
+            expect(deEuroAdolar(200)).toBe(240);
+            expect(deEuroAdolar(50)).toBe(60);
+         });
+      });
+
+      describe('esVocal(letra)', function () {
+         it('Debe devolver el string "Dato incorrecto", si el valor ingresado tiene más de una letra', function () {
+            expect(esVocal('la')).toBe('Dato incorrecto');
+            expect(esVocal('pero')).toBe('Dato incorrecto');
+         });
+         it('Debe devolver el string "Dato incorrecto", si el valor ingresado no es vocal', function () {
+            expect(esVocal('l')).toBe('Dato incorrecto');
+            expect(esVocal('p')).toBe('Dato incorrecto');
+         });
+         it('Debe devolver el string "Es vocal", si el valor ingresado lo es', function () {
+            expect(esVocal('a')).toBe('Es vocal');
+            expect(esVocal('e')).toBe('Es vocal');
+            expect(esVocal('i')).toBe('Es vocal');
+            expect(esVocal('o')).toBe('Es vocal');
+            expect(esVocal('u')).toBe('Es vocal');
+         });
+      });
+   });
+});
diff --git a/04 - JavaScript II/README.md b/04 - JavaScript II/README.md
new file mode 100644
index 0000000000..2fd7aadc59
--- /dev/null
+++ b/04 - JavaScript II/README.md	
@@ -0,0 +1,50 @@
+![HenryLogo](../Assets//logoBannerHenry.png)
+
+# **HOMEWORK 04 | JAVASCRIPT II**
+
+## **✅ TESTING**
+
+Para ejecutar los tests de las homeworks debes:
+
+1. Desde tu terminal, dirígete a la carpeta raíz de todas las homeworks y ejecuta el comando:
+
+```bash
+    npm install
+```
+
+2. Luego de que se hayan instalado las dependencias pueden comenzar a correr los tests.
+
+-  Para ejecutarlos globalmente (es decir, el de todas las homeworks), ejecuta el comando:
+
+```bash
+    npm test
+```
+
+-  Si quieres ejecutar los tests de esta homework en específico ejecuta el comando:
+
+```bash
+    npm test 04
+```
+
+---
+
+</br >
+
+## **📋 INTRODUCCIÓN**
+
+En esta Homework podrás poner en práctica:
+
+-  Condicionales
+-  Operadores de Comparación
+-  Operadores Lógicos
+-  Bucles
+
+---
+
+</br >
+
+## **📌 INSTRUCCIONES**
+
+### **📍 HOMEWORK**
+
+En esta homework recibirás una serie de funciones que deben cumplir con las espeficicaciones. Dependiendo la función deberás utilizar condicionales, operadores de comparación, operadores lógicos y/o bucles.
diff --git a/04 - JavaScript II/homework.js b/04 - JavaScript II/homework.js
new file mode 100644
index 0000000000..acce4296e9
--- /dev/null
+++ b/04 - JavaScript II/homework.js	
@@ -0,0 +1,129 @@
+/*⚠️ NO MODIFIQUES EL NOMBRE DE LAS DECLARACIONES ⚠️*/
+
+function obtenerMayor(x, y) {
+   // "x" e "y" son números enteros.
+   // Retornar el número más grande.
+   // Si son iguales, retornar cualquiera de los dos.
+   // Tu código:
+}
+
+function mayoriaDeEdad(edad) {
+   // Determinar si la persona puede ingresar al evento según su edad.
+   // Si tiene 18 años ó más debe retornar el string: "Allowed".
+   // Caso contrario: "Not allowed".
+   // Tu código:
+}
+
+function conection(status) {
+   // El argumento "status" representa el estado de conexión de un usuario.
+   // Si el estado es igual a 1, el usuario está "Online".
+   // Si el estado es igual a 2, el usuario está "Away".
+   // De lo contrario, presumimos que el usuario está "Offline".
+   // Retornar el estado de conexión del usuario.
+   // Tu código:
+}
+
+function saludo(idioma) {
+   // Retornar un saludo en tres diferentes lenguajes:
+   // Si "idioma" es "aleman", devuelve "Guten Tag!".
+   // Si "idioma" es "mandarin", devuelve "Ni Hao!".
+   // Si "idioma" es "ingles", devuelve "Hello!".
+   // Si "idioma" no es ninguno de los anteriores o es `undefined` devuelve "Hola!".
+   // Tu código:
+}
+
+function colors(color) {
+   // La función recibe un color. Retornar el string correspondiente:
+   // En caso que el color recibido sea "blue"   --> "This is blue".
+   // En caso que el color recibido sea "red"    --> "This is red".
+   // En caso que el color recibido sea "green"  --> "This is green".
+   // En caso que el color recibido sea "orange" --> "This is orange".
+   // Si no es ninguno de esos colores           --> "Color not found".
+   // IMPORTANTE: utilizar el statement SWITCH.
+   // Tu código:
+}
+
+function esDiezOCinco(num) {
+   // Retornar "true" si "num" es 10 o 5.
+   // De lo contrario, retornar "false".
+   // Tu código:
+}
+
+function estaEnRango(num) {
+   // Retornar "true" si "num" es menor que 50 y mayor que 20.
+   // De lo contrario, retornar "false".
+   // Tu código:
+}
+
+function esEntero(num) {
+   // Retornar "true" si "num" es un entero, ya sea positivo, negativo o cero.
+   // Ejemplo: 0.8   ---> false
+   // Ejemplo: 1     ---> true
+   // Ejemplo: (-10) ---> true
+   // De lo contrario, retorna "false".
+   // Tu código:
+}
+
+function fizzBuzz(num) {
+   // Si "num" es divisible entre 3 y 5 (ambos), retorna "fizzbuzz".
+   // Si "num" es divisible entre 3, retorna "fizz".
+   // Si "num" es divisible entre 5, retorna "buzz".
+   // De lo contrario, retorna el número.
+   // Tu código:
+}
+
+function operadoresLogicos(num1, num2, num3) {
+   // La función recibe tres números distintos.
+   // Si num1 es mayor a num2 y a num3, y además es positivo, retornar ---> "Numero 1 es mayor y positivo".
+   // Si alguno de los tres números es negativo, retornar ---> "Hay negativos".
+   // Si num3 es más grande que num1 y num2, aumentar su valor en 1 y retornar el nuevo valor.
+   // Si alguno de los argumentos es cero, retornar ---> "Error".
+   // Si no se cumple ninguna de las condiciones anteriores, retornar false.
+   // Tu código:
+}
+
+function esPrimo(num) {
+   // Retornar True si "num" es primo.
+   // De lo contrario retorna False.
+   // [Pista 1]: un número primo sólo es divisible por sí mismo y por 1.
+   // [Pista 2]: puedes resolverlo utilizando un `bucle for`.
+   // [Nota]: los números negativos, 0 y 1 NO son números primos.
+   // Tu código:
+}
+
+function esVerdadero(valor) {
+   // Si "valor" es verdadero retornar "Soy verdadero".
+   // Caso contrario, retornar "Soy falso".
+   // Tu código:
+}
+
+function tieneTresDigitos(num) {
+   // Si el número recibido tiene tres dígitos retornar True.
+   // Caso contrario, retornar False.
+   // Tu código:
+}
+
+function doWhile(num) {
+   // Implementar una función que aumente el valor recibido en 5 hasta un límite de 8 veces.
+   // Retornar el valor final.
+   // Utilizar el bucle Do-While.
+   // Tu código:
+}
+
+/*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
+module.exports = {
+   obtenerMayor,
+   mayoriaDeEdad,
+   conection,
+   saludo,
+   colors,
+   esDiezOCinco,
+   estaEnRango,
+   esEntero,
+   fizzBuzz,
+   operadoresLogicos,
+   esPrimo,
+   esVerdadero,
+   tieneTresDigitos,
+   doWhile,
+};
diff --git a/04 - JavaScript II/test/JSII.test.js b/04 - JavaScript II/test/JSII.test.js
new file mode 100644
index 0000000000..2b97652f4b
--- /dev/null
+++ b/04 - JavaScript II/test/JSII.test.js	
@@ -0,0 +1,205 @@
+/* eslint-disable no-undef */
+const {
+   obtenerMayor,
+   mayoriaDeEdad,
+   conection,
+   saludo,
+   colors,
+   esDiezOCinco,
+   estaEnRango,
+   esEntero,
+   fizzBuzz,
+   operadoresLogicos,
+   esPrimo,
+   esVerdadero,
+   tieneTresDigitos,
+   doWhile,
+} = require('../homework');
+
+describe('JAVASCRIPT II', function () {
+   describe('obtenerMayor(x, y)', function () {
+      it('Debe retornar X si es mayor que Y', function () {
+         expect(obtenerMayor(10, 5)).toBe(10);
+      });
+      it('Debe retornar Y si es mayor que X', function () {
+         expect(obtenerMayor(50, 100)).toBe(100);
+      });
+      it('Si son iguales debe retornar cualquiera', function () {
+         expect(obtenerMayor(1000, 1000)).toBe(1000);
+      });
+   });
+
+   describe('mayoriaDeEdad(edad)', function () {
+      it("Debe retornar 'Allowed' si la edad es igual o mayor a 18", function () {
+         expect(mayoriaDeEdad(18)).toBe('Allowed');
+         expect(mayoriaDeEdad(35)).toBe('Allowed');
+      });
+      it("Debe retornar 'Not allowed' si la edad es menor a 18", function () {
+         expect(mayoriaDeEdad(7)).toBe('Not allowed');
+      });
+   });
+
+   describe('conection(status)', function () {
+      it('Debe retornar "Online" si el status es 1', function () {
+         expect(conection(1)).toBe('Online');
+      });
+      it('Debe retornar "Away" si el status es 2', function () {
+         expect(conection(2)).toBe('Away');
+      });
+      it('Debe retornar "Offline" si el status es cualquier otro valor', function () {
+         expect(conection(3)).toBe('Offline');
+      });
+   });
+
+   describe('saludo(idioma)', function () {
+      it("Debe retornar 'Guten Tag!' por 'aleman'", function () {
+         expect(saludo('aleman')).toBe('Guten Tag!');
+      });
+      it("Debe retornar 'Hello!' por 'ingles'", function () {
+         expect(saludo('ingles')).toBe('Hello!');
+      });
+      it("Debe retornar 'Ni Hao!' por 'mandarin'", function () {
+         expect(saludo('mandarin')).toBe('Ni Hao!');
+      });
+      it("Debe retornar 'Hola!' si el argumento no se especificó", function () {
+         expect(saludo('frances')).toBe('Hola!');
+         expect(saludo()).toBe('Hola!');
+      });
+   });
+
+   describe('colors(color)', function () {
+      it("Debe retornar 'This is {color}'", function () {
+         expect(colors('blue')).toBe('This is blue');
+         expect(colors('red')).toBe('This is red');
+         expect(colors('green')).toBe('This is green');
+         expect(colors('orange')).toBe('This is orange');
+      });
+      it("Debe retornar 'Color not found' si el argumento no es el esperado", function () {
+         expect(colors()).toBe('Color not found');
+         expect(colors('pink')).toBe('Color not found');
+      });
+   });
+
+   describe('esDiezOCinco(num)', function () {
+      it('Debe retornar True si num es 10 o 5', function () {
+         expect(esDiezOCinco(10)).toBe(true);
+         expect(esDiezOCinco(5)).toBe(true);
+      });
+      it('Debe retornar False si num no es 10 o 5', function () {
+         expect(esDiezOCinco(11)).toBe(false);
+         expect(esDiezOCinco(6)).toBe(false);
+         expect(esDiezOCinco(0)).toBe(false);
+         expect(esDiezOCinco(5.01)).toBe(false);
+      });
+   });
+
+   describe('estaEnRango(num)', function () {
+      it('Debe retornar True si num está en el rango', function () {
+         expect(estaEnRango(35.5)).toBe(true);
+         expect(estaEnRango(40)).toBe(true);
+         expect(estaEnRango(49)).toBe(true);
+         expect(estaEnRango(21)).toBe(true);
+      });
+      it('Debe retornar False si num está fuera de rango', function () {
+         expect(estaEnRango(10)).toBe(false);
+         expect(estaEnRango(20)).toBe(false);
+         expect(estaEnRango(50)).toBe(false);
+         expect(estaEnRango(100)).toBe(false);
+      });
+   });
+
+   describe('esEntero(num)', function () {
+      it('Debe retornar False si num no es entero', function () {
+         expect(esEntero(0.5)).toBe(false);
+      });
+      it('Debe retornar True si num es un entero positivo', function () {
+         expect(esEntero(5)).toBe(true);
+      });
+      it('Debe retornar True si num es un entero negativo', function () {
+         expect(esEntero(-20)).toBe(true);
+      });
+      it('Debe retornar True si el argumento es cero', function () {
+         expect(esEntero(0)).toBe(true);
+      });
+   });
+
+   describe('fizzBuzz(num)', function () {
+      it('Debe retornar "fizzbuzz" si num es divisible por 3 y 5', function () {
+         expect(fizzBuzz(15)).toBe('fizzbuzz');
+      });
+      it('Debe retornar "fizz" si num es divisible por 3', function () {
+         expect(fizzBuzz(9)).toBe('fizz');
+      });
+      it('Debe retornar "buzz" si num es divisible por 5', function () {
+         expect(fizzBuzz(10)).toBe('buzz');
+      });
+      it('Debe retornar false si num NO es divisible por 5 ni 3', function () {
+         expect(fizzBuzz(4)).toBe(4);
+      });
+   });
+
+   describe('operadoresLogicos(num1, num2, num3)', function () {
+      it("Debe retornar 'Numero 1 es mayor y positivo' si num1 es positivo y mayor que num2 y num3", function () {
+         expect(operadoresLogicos(50, 2, 15)).toBe(
+            'Numero 1 es mayor y positivo'
+         );
+      });
+      it("Debe retornar 'Hay negativos' si alguno de los argumentos es negativo", function () {
+         expect(operadoresLogicos(-1, 50, 2)).toBe('Hay negativos');
+      });
+      it('Debe retornar (num3 + 1) si num3 es mayor que num1 y num2', function () {
+         expect(operadoresLogicos(1, 3, 10)).toBe(11);
+      });
+      it("Debe retornar 'Error' si alguno de los argumentos es igual a cero", function () {
+         expect(operadoresLogicos(0, 5, 2)).toBe('Error');
+      });
+      it('Debe retornar false si no se coincide con alguna de las opciones mencionadas', function () {
+         expect(operadoresLogicos(10, 30, 6)).toBe(false);
+      });
+   });
+
+   describe('esPrimo(num)', function () {
+      it('Debe retornar True si num es primo', function () {
+         expect(esPrimo(7)).toBe(true);
+         expect(esPrimo(97)).toBe(true);
+         expect(esPrimo(11)).toBe(true);
+      });
+      it('Debe retornar False si num NO es primo', function () {
+         expect(esPrimo(-9)).toBe(false);
+         expect(esPrimo(0)).toBe(false);
+         expect(esPrimo(1)).toBe(false);
+         expect(esPrimo(100)).toBe(false);
+         expect(esPrimo(4)).toBe(false);
+         expect(esPrimo(57)).toBe(false);
+      });
+   });
+
+   describe('esVerdadero(valor)', function () {
+      it('Debe retornar "Soy verdadero" si valor es True', function () {
+         expect(esVerdadero(true)).toBe('Soy verdadero');
+      });
+      it('Debe retornar "Soy falso" si valor es False', function () {
+         expect(esVerdadero(false)).toBe('Soy falso');
+      });
+   });
+
+   describe('tieneTresDigitos(num)', function () {
+      it('Debe retornar True si num tiene tres dígitos', function () {
+         expect(tieneTresDigitos(100)).toBe(true);
+         expect(tieneTresDigitos(820)).toBe(true);
+         expect(tieneTresDigitos(900)).toBe(true);
+      });
+      it('Debe retornar False si num no tiene tres dígitos', function () {
+         expect(tieneTresDigitos(10)).toBe(false);
+         expect(tieneTresDigitos(20000)).toBe(false);
+      });
+   });
+
+   describe('doWhile(num)', function () {
+      it('Debe agregar 5 al número recibido un total de 8 veces y retornar el resultado', function () {
+         expect(doWhile(5)).toBe(45);
+         expect(doWhile(100)).toBe(140);
+         expect(doWhile(-1)).toBe(39);
+      });
+   });
+});
diff --git a/05 - JavaScript III/README.md b/05 - JavaScript III/README.md
new file mode 100644
index 0000000000..e5eda41dd7
--- /dev/null
+++ b/05 - JavaScript III/README.md	
@@ -0,0 +1,49 @@
+![HenryLogo](../Assets//logoBannerHenry.png)
+
+# **HOMEWORK 05 | JAVASCRIPT III**
+
+## **✅ TESTING**
+
+Para ejecutar los tests de las homeworks debes:
+
+1. Desde tu terminal, dirígete a la carpeta raíz de todas las homeworks y ejecuta el comando:
+
+```bash
+    npm install
+```
+
+2. Luego de que se hayan instalado las dependencias pueden comenzar a correr los tests.
+
+-  Para ejecutarlos globalmente (es decir, el de todas las homeworks), ejecuta el comando:
+
+```bash
+    npm test
+```
+
+-  Si quieres ejecutar los tests de esta homework en específico ejecuta el comando:
+
+```bash
+    npm test 05
+```
+
+---
+
+</br >
+
+## **📋 INTRODUCCIÓN**
+
+En esta Homework podrás poner en práctica:
+
+-  Arreglos
+-  Métodos
+-  Bucles
+
+---
+
+</br >
+
+## **📌 INSTRUCCIONES**
+
+### **📍 HOMEWORK**
+
+En esta homework recibirás una serie de funciones que deben cumplir con las espeficicaciones. Dependiendo la función deberás utilizar métodos de arreglos y bucles.
diff --git a/05 - JavaScript III/homework.js b/05 - JavaScript III/homework.js
new file mode 100644
index 0000000000..67a7273d84
--- /dev/null
+++ b/05 - JavaScript III/homework.js	
@@ -0,0 +1,159 @@
+/*⚠️ NO MODIFIQUES EL NOMBRE DE LAS DECLARACIONES ⚠️*/
+
+function devolverPrimerElemento(array) {
+   // Retornar el primer elemento del arreglo recibido por parámetro.
+   // Tu código:
+}
+
+function devolverUltimoElemento(array) {
+   // Retornar el último elemento del arreglo recibido por parámetro.
+   // Tu código:
+}
+
+function obtenerLargoDelArray(array) {
+   // Retornar la longitud del arreglo recibido por parámetro.
+   // Tu código:
+}
+
+function incrementarPorUno(array) {
+   // El arreglo recibido por parámetro contiene números.
+   // Retornar un arreglo con los elementos incrementados en +1.
+   // Tu código:
+}
+
+function agregarItemAlFinalDelArray(array, elemento) {
+   // Agrega el "elemento" al final del arreglo recibido.
+   // Retorna el arreglo.
+   // Tu código:
+}
+
+function agregarItemAlComienzoDelArray(array, elemento) {
+   // Agrega el "elemento" al comienzo del arreglo recibido.
+   // Retorna el arreglo.
+   // Tu código:
+}
+
+function dePalabrasAFrase(palabras) {
+   // El argumento "palabras" es un arreglo de strings.
+   // Retornar un string donde todas las palabras estén concatenadas
+   // con un espacio entre cada palabra.
+   // Ejemplo: ['Hello', 'world!'] -> 'Hello world!'.
+   // Tu código:
+}
+
+function arrayContiene(array, elemento) {
+   // Verifica si el elemento existe dentro del arreglo recibido.
+   // Retornar True si está, o False si no está.
+   // Tu código:
+}
+
+function agregarNumeros(arrayOfNums) {
+   // El parámetro "arrayOfNums" debe ser un arreglo de números.
+   // Suma todos los elementos y retorna el resultado.
+   // Tu código:
+}
+
+function promedioResultadosTest(resultadosTest) {
+   // El parámetro "resultadosTest" es un arreglo de números.
+   // Itera (en un bucle) los elementos del arreglo y devuelve el promedio de las notas.
+   // Tu código:
+}
+
+function numeroMasGrande(arrayOfNums) {
+   // El parámetro "arrayOfNums" es un arreglo de números.
+   // Retornar el número más grande.
+   // Tu código:
+}
+
+function multiplicarArgumentos() {
+   // Usa la palabra clave `arguments` para multiplicar todos los argumentos y devolver el producto.
+   // Si no se pasan argumentos retorna 0. Si se pasa un argumento, simplemente retórnalo.
+   // [PISTA]: "arguments" es un arreglo.
+   // Tu código:
+}
+
+function cuentoElementos(array) {
+   // Desarrolla una función que retorne la cantidad de elementos del arreglo cuyo valor sea mayor que 18.
+   // Tu código:
+}
+
+function diaDeLaSemana(numeroDeDia) {
+   // Supongamos que los días de la semana se codifican como 1 = Domingo, 2 = Lunes y así sucesivamente.
+   // Realiza una función que, dado el número del día de la semana, retorne: "Es fin de semana"
+   // si el día corresponde a "Sábado" o "Domingo", y "Es dia laboral" en caso contrario.
+   // Tu código:
+}
+
+function empiezaConNueve(num) {
+   // Esta función recibe por parámetro un número.
+   // Debe retornar True si el entero inicia con 9 y False en otro caso.
+   // Tu código:
+}
+
+function todosIguales(array) {
+   // Si todos los elementos del arreglo son iguales, retornar True.
+   // Caso contrario retornar False.
+   // Tu código:
+}
+
+function mesesDelAño(array) {
+   // El arreglo contiene algunos meses del año desordenados. Debes recorrerlo, buscar los meses "Enero",
+   // "Marzo" y "Noviembre", guardarlos en un nuevo arreglo y retornarlo.
+   // Si alguno de los meses no está, retornar el string: "No se encontraron los meses pedidos".
+   // Tu código:
+}
+
+function tablaDelSeis() {
+   // Escribe una función que muestre la tabla de multiplicar del 6 (del 0 al 60).
+   // La función devuelve un arreglo con los resultados de la tabla de multiplicar del 6 en orden creciente.
+   // Tu código:
+}
+
+function mayorACien(array) {
+   // La función recibe un arreglo con enteros entre 0 y 200.
+   // Recorrerlo y retornar un arreglo con todos los valores mayores a 100 (no incluye el 100).
+   // Tu código:
+}
+
+function breakStatement(num) {
+   // Iterar en un bucle aumentando en 2 el número recibido hasta un límite de 10 veces.
+   // Guardar cada nuevo valor en un arreglo y retornarlo.
+   // Si en algún momento el valor de la suma y la cantidad de iteraciones coinciden, debe interrumpirse
+   // la ejecución y retornar el string: "Se interrumpió la ejecución".
+   // [PISTA]: utiliza el statement 'break'.
+   // Tu código:
+}
+
+function continueStatement(num) {
+   // Iterar en un bucle aumentando en 2 el número recibido hasta un límite de 10 veces.
+   // Guardar cada nuevo valor en un array y retornarlo.
+   // Cuando el número de iteraciones alcance el valor 5, no se suma ese caso y
+   // se continua con la siguiente iteración.
+   // [PISTA]: utiliza el statement 'continue'.
+   // Tu código:
+}
+
+/*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
+module.exports = {
+   devolverPrimerElemento,
+   devolverUltimoElemento,
+   obtenerLargoDelArray,
+   incrementarPorUno,
+   agregarItemAlFinalDelArray,
+   agregarItemAlComienzoDelArray,
+   dePalabrasAFrase,
+   arrayContiene,
+   agregarNumeros,
+   promedioResultadosTest,
+   numeroMasGrande,
+   multiplicarArgumentos,
+   cuentoElementos,
+   diaDeLaSemana,
+   empiezaConNueve,
+   todosIguales,
+   mesesDelAño,
+   tablaDelSeis,
+   mayorACien,
+   breakStatement,
+   continueStatement,
+};
diff --git a/05 - JavaScript III/test/JSIII.test.js b/05 - JavaScript III/test/JSIII.test.js
new file mode 100644
index 0000000000..174218e9fe
--- /dev/null
+++ b/05 - JavaScript III/test/JSIII.test.js	
@@ -0,0 +1,250 @@
+/* eslint-disable no-undef */
+const {
+   devolverPrimerElemento,
+   devolverUltimoElemento,
+   obtenerLargoDelArray,
+   incrementarPorUno,
+   agregarItemAlFinalDelArray,
+   agregarItemAlComienzoDelArray,
+   dePalabrasAFrase,
+   arrayContiene,
+   agregarNumeros,
+   promedioResultadosTest,
+   numeroMasGrande,
+   multiplicarArgumentos,
+   cuentoElementos,
+   diaDeLaSemana,
+   empiezaConNueve,
+   todosIguales,
+   mesesDelAño,
+   tablaDelSeis,
+   mayorACien,
+   breakStatement,
+   continueStatement,
+} = require('../homework');
+
+describe('JAVASCRIPT III', function () {
+   describe('devolverPrimerElemento(array)', function () {
+      it('Debe retornar el primer elemento del arreglo', function () {
+         expect(devolverPrimerElemento([10, 10, 16, 12])).toBe(10);
+         expect(devolverPrimerElemento([97, 100, 80, 55, 72, 94])).toBe(97);
+      });
+   });
+
+   describe('devolverUltimoElemento(array)', function () {
+      it('Debe retornar el último elemento del arreglo', function () {
+         expect(devolverUltimoElemento([10, 10, 16, 12])).toBe(12);
+         expect(devolverUltimoElemento([97, 100, 80, 55, 72, 94])).toBe(94);
+         expect(
+            devolverUltimoElemento([
+               'hi',
+               'there',
+               'how',
+               'are',
+               'you',
+               'doing?',
+            ])
+         ).toBe('doing?');
+      });
+   });
+
+   describe('obtenerLargoDelArray(array)', function () {
+      it('Debe retornar la longitud del arreglo', function () {
+         expect(obtenerLargoDelArray([10, 10, 16, 12])).toBe(4);
+         expect(obtenerLargoDelArray([97, 100, 80, 55, 72, 94])).toBe(6);
+         expect(
+            obtenerLargoDelArray(['hi', 'there', 'how', 'are', 'you', 'doing?'])
+         ).toBe(6);
+      });
+   });
+
+   describe('incrementarPorUno(array)', function () {
+      it('Debe retornar el arreglo con cada elemento aumentado en +1', function () {
+         expect(incrementarPorUno([10, 10, 16, 12])).toEqual([11, 11, 17, 13]);
+         expect(incrementarPorUno([97, 100, 80, 55, 72, 94])).toEqual([
+            98, 101, 81, 56, 73, 95,
+         ]);
+         expect(incrementarPorUno([])).toEqual([]);
+      });
+   });
+
+   describe('agregarItemAlFinalDelArray(array, elemento)', function () {
+      it('Debe retornar el arreglo con el elemento agregado al final', function () {
+         expect(agregarItemAlFinalDelArray([10, 10, 16, 12], 10)).toEqual([
+            10, 10, 16, 12, 10,
+         ]);
+         expect(
+            agregarItemAlFinalDelArray([97, 100, 80, 55, 72, 94], 'Hola')
+         ).toEqual([97, 100, 80, 55, 72, 94, 'Hola']);
+         expect(agregarItemAlFinalDelArray([], true)).toEqual([true]);
+      });
+   });
+
+   describe('agregarItemAlComienzoDelArray(array, elemento)', function () {
+      it('Debe retornar el arreglo con el elemento agregado al comienzo', function () {
+         expect(agregarItemAlComienzoDelArray([10, 10, 16, 12], 10)).toEqual([
+            10, 10, 10, 16, 12,
+         ]);
+         expect(
+            agregarItemAlComienzoDelArray([97, 100, 80, 55, 72, 94], 'Hola')
+         ).toEqual(['Hola', 97, 100, 80, 55, 72, 94]);
+         expect(agregarItemAlComienzoDelArray([], true)).toEqual([true]);
+      });
+   });
+
+   describe('dePalabrasAFrase(palabras)', function () {
+      it('Debe retornar un string con las palabras separadas por un espacio', function () {
+         expect(dePalabrasAFrase(['Henry', 'JavaScript', 'Class'])).toBe(
+            'Henry JavaScript Class'
+         );
+         expect(dePalabrasAFrase(['Henry'])).toBe('Henry');
+      });
+   });
+
+   describe('arrayContiene(array, elemento)', function () {
+      it('Debe retornar True si el arreglo contiene el elemento', function () {
+         expect(arrayContiene([10, 10, 16, 12], 10)).toBe(true);
+      });
+      it('Debe retornar False si el arreglo NO contiene el elemento', function () {
+         expect(arrayContiene([97, 100, 80, 55, 72, 94], 'Hola')).toBe(false);
+         expect(arrayContiene([], true)).toBe(false);
+      });
+   });
+
+   describe('agregarNumeros(arrayOfNums)', function () {
+      it('Debe retornar la suma de todos los números del arreglo', function () {
+         expect(agregarNumeros([10, 10, 16])).toBe(36);
+         expect(agregarNumeros([97, 100])).toBe(197);
+         expect(agregarNumeros([0, 0, 0])).toBe(0);
+      });
+   });
+
+   describe('promedioResultadosTest(resultadosTest)', function () {
+      it('Debe retornar el promedio de todas las notas', function () {
+         expect(promedioResultadosTest([10, 10, 16, 12])).toBe(12);
+         expect(promedioResultadosTest([97, 100, 80, 55, 72, 94])).toBe(83);
+      });
+   });
+
+   describe('numeroMasGrande(arrayOfNums)', function () {
+      it('Debe retornar el número más grande del arreglo', function () {
+         expect(numeroMasGrande([10, 10, 16, 12])).toBe(16);
+         expect(numeroMasGrande([97, 100, 80, 55, 72, 94])).toBe(100);
+         expect(numeroMasGrande([97, 10000, 80, 55, 7.2, -94])).toBe(10000);
+      });
+   });
+
+   describe('multiplicarArgumentos()', function () {
+      it('Debe retornar el producto de los argumentos', function () {
+         const product = multiplicarArgumentos(5, 5);
+         const product2 = multiplicarArgumentos();
+         const product3 = multiplicarArgumentos(3, 3, 3, 3);
+         const product4 = multiplicarArgumentos(1);
+         const product5 = multiplicarArgumentos(10, 0, 10);
+         expect(product).toBe(25);
+         expect(product2).toBe(0);
+         expect(product3).toBe(81);
+         expect(product4).toBe(1);
+         expect(product5).toBe(0);
+      });
+   });
+
+   describe('cuentoElementos(array)', function () {
+      it('Debe retornar la cantidad de elementos mayores a a 18', function () {
+         expect(cuentoElementos([10, 10, 18, 21])).toBe(1);
+         expect(cuentoElementos([97, 100, 190, 5, 7, 9])).toBe(3);
+         expect(cuentoElementos([97, 20, 90, 50, 7, 709])).toBe(5);
+      });
+   });
+
+   describe('diaDeLaSemana(numeroDeDia)', function () {
+      it('Debe retornar "Es dia laboral" dependiendo del número del día', function () {
+         expect(diaDeLaSemana(3)).toBe('Es dia laboral');
+         expect(diaDeLaSemana(2)).toBe('Es dia laboral');
+      });
+      it('Debe retornar "Es fin de semana" dependiendo del número del día', function () {
+         expect(diaDeLaSemana(1)).toBe('Es fin de semana');
+         expect(diaDeLaSemana(7)).toBe('Es fin de semana');
+      });
+   });
+
+   describe('empiezaConNueve(num))', function () {
+      it('Debe retornar True si recibe un número que comienza con 9', function () {
+         expect(empiezaConNueve(98)).toBe(true);
+         expect(empiezaConNueve(9)).toBe(true);
+      });
+      it('Debe retornar False si recibe un número que NO comienza con 9', function () {
+         expect(empiezaConNueve(2)).toBe(false);
+         expect(empiezaConNueve(7)).toBe(false);
+         expect(empiezaConNueve(-5)).toBe(false);
+      });
+   });
+
+   describe('todosIguales(array)', function () {
+      it('Debe retornar True si todos los números del arreglo son iguales', function () {
+         expect(todosIguales([20, 20, 20, 20])).toBe(true);
+         expect(todosIguales([230, 230, 230, 230])).toBe(true);
+      });
+      it('Debe retornar False si NO todos los números del arreglo son iguales', function () {
+         expect(todosIguales([97, 100, 190, 9])).toBe(false);
+      });
+   });
+
+   describe('mesesDelAño(array)', function () {
+      var ok = [
+         'Marzo',
+         'Diciembre',
+         'Abril',
+         'Junio',
+         'Julio',
+         'Noviembre',
+         'Enero',
+         'Mayo',
+         'Febrero',
+      ];
+      var notOk = ['Marzo', 'Diciembre', 'Julio', 'Noviembre'];
+      it('Debe retornar un arreglo con los meses requeridos', function () {
+         expect(mesesDelAño(ok)).toEqual(['Marzo', 'Noviembre', 'Enero']);
+      });
+      it('Debe retornar el mensaje si alguno de los meses no se encuentra en el arreglo', function () {
+         expect(mesesDelAño(notOk)).toEqual(
+            'No se encontraron los meses pedidos'
+         );
+      });
+   });
+
+   describe('tablaDelSeis()', function () {
+      it('Debe retornar la tabla de multiplicar del 6 en un arreglo', function () {
+         expect(tablaDelSeis()).toEqual([
+            0, 6, 12, 18, 24, 30, 36, 42, 48, 54, 60,
+         ]);
+      });
+   });
+
+   describe('mayorACien(array)', function () {
+      it('Debe retornar un arreglo con todos los número mayores a 100', function () {
+         var integers = [100, 4, 56, 78, 200, 120, 7, 160, 148, 22];
+         expect(mayorACien(integers)).toEqual([200, 120, 160, 148]);
+      });
+   });
+
+   describe('breakStatement(num)', function () {
+      it('Debe retornar un arreglo con los elementos incrementados en dos', function () {
+         expect(breakStatement(50)).toEqual([
+            52, 54, 56, 58, 60, 62, 64, 66, 68, 70,
+         ]);
+      });
+      it('La ejecución se debe interrumpir en el caso pedido', function () {
+         expect(breakStatement(-4)).toEqual('Se interrumpió la ejecución');
+      });
+   });
+
+   describe('continueStatement(num)', function () {
+      it('Debe retornar un arreglo con los valores resultantes de incrementarlos en 2 siempre que el número y la iteración seas diferentes a 5', function () {
+         expect(continueStatement(50)).toEqual([
+            52, 54, 56, 58, 60, 62, 64, 66, 68,
+         ]);
+         expect(continueStatement(-4)).toEqual([-2, 0, 2, 4, 6, 8, 10, 12, 14]);
+      });
+   });
+});
diff --git a/06 - JavaScript IV/README.md b/06 - JavaScript IV/README.md
new file mode 100644
index 0000000000..f8bfe13198
--- /dev/null
+++ b/06 - JavaScript IV/README.md	
@@ -0,0 +1,51 @@
+![HenryLogo](../Assets//logoBannerHenry.png)
+
+# **HOMEWORK 06 | JAVASCRIPT IV**
+
+## **✅ TESTING**
+
+Para ejecutar los tests de las homeworks debes:
+
+1. Desde tu terminal, dirígete a la carpeta raíz de todas las homeworks y ejecuta el comando:
+
+```bash
+    npm install
+```
+
+2. Luego de que se hayan instalado las dependencias pueden comenzar a correr los tests.
+
+-  Para ejecutarlos globalmente (es decir, el de todas las homeworks), ejecuta el comando:
+
+```bash
+    npm test
+```
+
+-  Si quieres ejecutar los tests de esta homework en específico ejecuta el comando:
+
+```bash
+    npm test 06
+```
+
+---
+
+</br >
+
+## **📋 INTRODUCCIÓN**
+
+En esta Homework podrás poner en práctica:
+
+-  Objetos
+-  Propiedades
+-  Métodos
+-  Bucle For-In
+-  This
+
+---
+
+</br >
+
+## **📌 INSTRUCCIONES**
+
+### **📍 HOMEWORK**
+
+En esta Homework tendrás una serie de funciones en las que se te pedirá trabajar con funciones. Crearás y eliminarás propiedades. También utilizarás métodos varios y el bucle For-In.
diff --git a/06 - JavaScript IV/homework.js b/06 - JavaScript IV/homework.js
new file mode 100644
index 0000000000..dd2828368e
--- /dev/null
+++ b/06 - JavaScript IV/homework.js	
@@ -0,0 +1,123 @@
+/*⚠️ NO MODIFIQUES EL NOMBRE DE LAS DECLARACIONES ⚠️*/
+
+function crearGato(nombre, edad) {
+   // Debes crear un nuevo objeto con las propiedades "nombre" y "edad".
+   // Ambas propiedades deben tener el valor correspondiente recibido por parámetro.
+   // Además, agregar una propiedad con el nombre "meow".
+   // La propiedad "meow" será una función que retorne el string: "Meow!".
+   // Retornar el objeto.
+   // Tu código:
+}
+
+function nuevoUsuario(nombre, email, password) {
+   // Debes crear un nuevo objeto.
+   // Este debe tener las propiedades: "nombre", "email" y "password" con sus respectivos valores.
+   // Retornar el objeto.
+   // Tu código:
+}
+
+function agregarPropiedad(objeto, propiedad) {
+   // Recibirás un objeto por parámetro.
+   // Debes agregarle una propiedad con el nombre recibido por parámetro.
+   // Esta propiedad será igual al valor `null`.
+   // Retornar el objeto.
+   // Tu código:
+}
+
+function invocarMetodo(objeto, metodo) {
+   // El parámetro "metodo" es un string que coincide con el nombre de una propiedad del objeto recibido.
+   // Esta propiedad contiene una función en su interior. Debes invocarla/ejecutarla.
+   // [NOTA]: no necesitar retornar nada.
+   // Tu código:
+}
+
+function multiplicarNumeroDesconocidoPorCinco(objetoMisterioso) {
+   // El parámetro "objetoMisterioso" posee una propiedad con el nombre "numeroMisterioso".
+   // Debes multiplicar este número por 5 y retornar el resultado.
+   // Tu código:
+}
+
+function eliminarPropiedad(objeto, propiedad) {
+   // El parámetro "propiedad" es una propiedad del objeto que recibes.
+   // Debes eliminarla del objeto y retornarlo finalmente.
+   // Tu código:
+}
+
+function tieneEmail(objetoUsuario) {
+   // Verifica si el "objetoUsuario", en su propiedad "email", posee un valor definido.
+   // En ese caso retornar True. Caso contrario, False.
+   // Tu código:
+}
+
+function tienePropiedad(objeto, propiedad) {
+   // Verifica si el objeto recibido posee una propiedad con el mismo nombre que el parámetro "propiedad".
+   // En ese caso retornar True. Caso contrario, False.
+   // Tu código:
+}
+
+function verificarPassword(objetoUsuario, password) {
+   // Verifica si la propiedad "password" del "objetoUsuario" coincide con el parámetro "password".
+   // En ese caso retornar True. Caso contrario, False.
+   // Tu código:
+}
+
+function actualizarPassword(objetoUsuario, nuevaPassword) {
+   // Reemplaza la contrseña guardada en la propiedad "password" del "objetoUsuario".
+   // La nueva contraseña la recibes por parámetro.
+   // Retornar el objeto.
+   // Tu código:
+}
+
+function agregarAmigo(objetoUsuario, nuevoAmigo) {
+   // El parámetro "objetoUsuario" tiene una propiedad llamada "amigos" igual a un arreglo.
+   // Debes agregar el "nuevoAmigo" al final de este arreglo.
+   // Retornar el objeto.
+   // Tu código:
+}
+
+function pasarUsuarioAPremium(objetoMuchosUsuarios) {
+   // El parámetro "objetoMuchosUsuarios" es un arreglo de objetos (usuarios).
+   // Cada usuario tiene una propiedad llamada "esPremium".
+   // Define esta propiedad de todos los usuarios como True.
+   // Retornar el arreglo.
+   // Tu código:
+}
+
+function sumarLikesDeUsuario(objetoUsuario) {
+   // El parámetro "objetoUsuario" tiene una propiedad llamada "posts" que es un arreglo.
+   // Este arreglo contiene objetos (post).
+   // Cada post posee una propiedad llamada "likes". Esta propiedad es un número.
+   // Debes sumar los likes de todos los post y retornar el resultado.
+   // Tu código:
+}
+
+function agregarMetodoCalculoDescuento(objetoProducto) {
+   // Agrega una propiedad al "objetoProducto" con el nombre "calcularPrecioDescuento".
+   // Esta propiedad debe ser una función que multiplique el precio del producto por el porcentajeDeDescuento.
+   // El "objetoProducto" posee una propiedad "precio" y una propiedad "porcentajeDeDescuento".
+   // Luego debes restar del precio total del producto ese valor de descuento.
+   // Retornar el precio final.
+   // Ejemplo:
+   // Precio ---> 10
+   // PorcentajeDeDescuento ---> 0.2
+   // Precio final ---> 8
+   // Tu código:
+}
+
+/*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
+module.exports = {
+   crearGato,
+   nuevoUsuario,
+   agregarPropiedad,
+   invocarMetodo,
+   multiplicarNumeroDesconocidoPorCinco,
+   eliminarPropiedad,
+   tieneEmail,
+   tienePropiedad,
+   verificarPassword,
+   actualizarPassword,
+   agregarAmigo,
+   pasarUsuarioAPremium,
+   sumarLikesDeUsuario,
+   agregarMetodoCalculoDescuento,
+};
diff --git a/06 - JavaScript IV/test/JSIV.test.js b/06 - JavaScript IV/test/JSIV.test.js
new file mode 100644
index 0000000000..af1a5a136c
--- /dev/null
+++ b/06 - JavaScript IV/test/JSIV.test.js	
@@ -0,0 +1,255 @@
+/* eslint-disable no-undef */
+const {
+   crearGato,
+   agregarPropiedad,
+   invocarMetodo,
+   multiplicarNumeroDesconocidoPorCinco,
+   eliminarPropiedad,
+   nuevoUsuario,
+   tieneEmail,
+   tienePropiedad,
+   verificarPassword,
+   actualizarPassword,
+   agregarAmigo,
+   pasarUsuarioAPremium,
+   sumarLikesDeUsuario,
+   agregarMetodoCalculoDescuento,
+} = require('../homework');
+
+describe('JAVASCRIPT IV', function () {
+   describe('crearGato(nombre, edad)', function () {
+      it('Debe crear un nuevo objeto con las propiedades "nombre", y "edad"', function () {
+         expect(crearGato('Snowball', 1).nombre).toBe('Snowball');
+         expect(crearGato('Snowball', 1).edad).toBe(1);
+         expect(crearGato('Snowball II', 5).nombre).toBe('Snowball II');
+         expect(crearGato('Snowball II', 5).edad).toBe(5);
+      });
+      it('Debe crear una propiedad "meow" que retorna el string "Meow!"', function () {
+         expect(crearGato('Snowball III', 2).meow()).toBe('Meow!');
+      });
+   });
+
+   describe('nuevoUsuario(nombre, email, password)', function () {
+      it('Debe devolver un nuevo objeto con las propiedades "nombre", "email" y "password"', function () {
+         const user = {
+            nombre: 'Jhon',
+            email: 'jhon@email.com',
+            password: 'correcthorsebatterystaple',
+         };
+         expect(nuevoUsuario(user.nombre, user.email, user.password)).toEqual(
+            user
+         );
+         const user2 = {
+            nombre: 'Samuel',
+            email: 'samuel@email.com',
+            password: 'password',
+         };
+         expect(
+            nuevoUsuario(user2.nombre, user2.email, user2.password)
+         ).toEqual(user2);
+      });
+   });
+
+   describe('agregarPropiedad(objeto, propiedad)', function () {
+      it('Debe agregar la propiedad al objeto con valor null', function () {
+         const object = {
+            x: 1,
+            y: 2,
+         };
+         const updatedObject = {
+            x: 1,
+            y: 2,
+            z: null,
+         };
+         expect(agregarPropiedad(object, 'z')).toEqual(updatedObject);
+      });
+   });
+
+   describe('invocarMetodo(objeto, metodo)', function () {
+      it('Debe invocar el método del objeto', function () {
+         const object = {
+            x: 0,
+            incrementX: function () {
+               this.x++;
+            },
+         };
+         invocarMetodo(object, 'incrementX');
+         expect(object.x).toBe(1);
+      });
+   });
+
+   describe('multiplicarNumeroDesconocidoPorCinco(objetoMisterioso)', function () {
+      it('Debe retornar el numeroMisterioso multiplicado por 5', function () {
+         const mysteryBox = {
+            numeroMisterioso: 999,
+         };
+         expect(multiplicarNumeroDesconocidoPorCinco(mysteryBox)).toBe(4995);
+         mysteryBox.numeroMisterioso = -5;
+         expect(multiplicarNumeroDesconocidoPorCinco(mysteryBox)).toBe(-25);
+      });
+   });
+
+   describe('eliminarPropiedad(objeto, propiedad)', function () {
+      it('Debe eliminar la propiedad del objeto', function () {
+         const updatedObject = {
+            x: 1,
+            y: 2,
+         };
+         const object = {
+            x: 1,
+            y: 2,
+            z: null,
+         };
+         expect(eliminarPropiedad(object, 'z')).toEqual(updatedObject);
+      });
+   });
+
+   describe('tieneEmail(objetoUsuario)', function () {
+      it('Debe retornar True si el objetoUsuario posee un valor definido en la propiedad "email"', function () {
+         expect(
+            tieneEmail({ usernombre: 'Samuel', email: 'samuel@email.com' })
+         ).toEqual(true);
+      });
+      it('Debe retornar False si el objetoUsuario NO posee un valor definido en la propiedad "email"', function () {
+         expect(tieneEmail({ usernombre: 'Jhon', email: null })).toEqual(false);
+         expect(tieneEmail({ usernombre: 'Antonio' })).toEqual(false);
+      });
+   });
+
+   describe('tienePropiedad(objeto, propiedad)', function () {
+      it('Debe retornar True si el objeto posee una propiedad con el nombre del parámetro', function () {
+         const obj = {
+            x: true,
+         };
+         expect(tienePropiedad(obj, 'x')).toEqual(true);
+      });
+      it('Debe retornar False si el objeto NO posee una propiedad con el nombre del parámetro', function () {
+         const obj = {
+            x: true,
+         };
+         expect(tienePropiedad(obj, 'y')).toEqual(false);
+      });
+   });
+
+   describe('verificarPassword(user, password)', function () {
+      it('Debe retornar True si la contraseña es correcta', function () {
+         const user = {
+            password: 'Me encanta JS!',
+         };
+         const password = 'Me encanta JS!';
+         expect(verificarPassword(user, password)).toBe(true);
+      });
+      it('Debe retornar False si la contraseña es incorrecta', function () {
+         const user = {
+            password: 'Me encanta JS!',
+         };
+         const password = 'Hacker time!';
+         expect(verificarPassword(user, password)).toBe(false);
+      });
+   });
+
+   describe('actualizarPassword(objetoUsuario, password)', function () {
+      it('Debe devolver al usuario con la contraseña actualizada', function () {
+         const user = {
+            password: 'Me encanta JS!',
+         };
+         const password = 'Me encanta JS mucho más!';
+         expect(actualizarPassword(user, password).password).toBe(password);
+      });
+   });
+
+   describe('agregarAmigo(objetoUsuario, nuevoAmigo)', function () {
+      it('Debe agregar el nuevo amigo al final del arreglo de una propiedad', function () {
+         const user = {
+            amigos: ['Ben', 'Austen', 'Ryan', 'Mike', 'Young'],
+         };
+         const newFriend = 'Shay';
+         expect(agregarAmigo(user, 'Shay').amigos.pop()).toBe('Shay');
+      });
+   });
+
+   describe('pasarUsuarioAPremium(objetoMuchosUsuarios)', function () {
+      it("Debe retornar un arreglo donde todos los usuarios tengan el valor True en su propiedad 'esPremium'", function () {
+         const users = [
+            { esPremium: false },
+            { esPremium: false },
+            { esPremium: false },
+            { esPremium: false },
+            { esPremium: false },
+         ];
+         const updatedUsers = [
+            { esPremium: true },
+            { esPremium: true },
+            { esPremium: true },
+            { esPremium: true },
+            { esPremium: true },
+         ];
+         expect(pasarUsuarioAPremium(users)).toEqual(updatedUsers);
+      });
+   });
+
+   describe('sumarLikesDeUsuario(objetoUsuario)', function () {
+      it('Debe retornar la suma de los likes de todos los post', function () {
+         const user = {
+            usernombre: 'Jhon Doe',
+            password: 'JavaScript es genial!',
+            posts: [
+               {
+                  id: '1',
+                  title: 'Aventuras en JS!',
+                  likes: 10,
+               },
+               {
+                  id: '2',
+                  title: 'Soy Henry!',
+                  likes: 100,
+               },
+               {
+                  id: '3',
+                  title: 'Qué es un JavaScript?',
+                  likes: 35,
+               },
+               {
+                  id: '4',
+                  title: 'JS Objects for Dummies',
+                  likes: 42,
+               },
+               {
+                  id: '5',
+                  title: 'Educación online',
+                  likes: 99,
+               },
+            ],
+         };
+         expect(sumarLikesDeUsuario(user)).toBe(286);
+      });
+   });
+
+   describe('agregarMetodoCalculoDescuento(objetoProducto)', function () {
+      const storeItem = {
+         precio: 80,
+         porcentajeDeDescuento: 0.1,
+      };
+      const storeItem2 = {
+         precio: 5,
+         porcentajeDeDescuento: 0.5,
+      };
+
+      it("Debe agregar la propiedad 'calcularPrecioDescuento' al objetoProducto", function () {
+         expect(
+            agregarMetodoCalculoDescuento(storeItem).calcularPrecioDescuento
+         ).toBeDefined();
+         expect(
+            agregarMetodoCalculoDescuento(storeItem2).calcularPrecioDescuento
+         ).toBeDefined();
+      });
+      it('Debe devolver el precio con descuento del producto', function () {
+         expect(
+            agregarMetodoCalculoDescuento(storeItem).calcularPrecioDescuento()
+         ).toBe(72);
+         expect(
+            agregarMetodoCalculoDescuento(storeItem2).calcularPrecioDescuento()
+         ).toBe(2.5);
+      });
+   });
+});
diff --git a/07 - JavaScript V/Ejercicio 01.js b/07 - JavaScript V/Ejercicio 01.js
new file mode 100644
index 0000000000..23586970d5
--- /dev/null
+++ b/07 - JavaScript V/Ejercicio 01.js	
@@ -0,0 +1,32 @@
+/*⚠️ NO MODIFIQUES EL NOMBRE DE LAS DECLARACIONES ⚠️*/
+/*1️⃣ EJERCICIO 01 1️⃣*/
+
+function crearUsuario() {
+   // Crea una Clase de ES6 o una función constructora llamada "Usuario".
+   // El constructor de esta clase debe tener las propiedades: "usuario", "nombre", "email" y "password".
+   // El valor de cada propiedad la recibirá por parámetro.
+   // Además, esta clase debe tener un método llamado "saludar".
+   // Este método debe retornar el string: 'Hola, mi nombre es {{nombre}}'.
+   // El valor {{nombre}} debe ser el nombre definido para la instancia de la clase.
+   // Retornar la clase.
+   // Tu código:
+}
+
+function agregarMetodoPrototype(Usuario) {
+   // Agrega un método al prototipo de "Usuario".
+   // El método debe llamarse "saludar" y debe devolver el string "Hello World!".
+   // Tu código:
+}
+
+function agregarStringInvertida() {
+   // Agrega un método al prototipo de "String" que devuelva la misma cadena de caracteres, pero invertida.
+   // El método debe llamarse "reverse".
+   // [PISTA]: necesitarás utilizar el objeto "this".
+}
+
+/*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
+module.exports = {
+   crearUsuario,
+   agregarMetodoPrototype,
+   agregarStringInvertida,
+};
diff --git a/07 - JavaScript V/Ejercicio 02.js b/07 - JavaScript V/Ejercicio 02.js
new file mode 100644
index 0000000000..ed07493e66
--- /dev/null
+++ b/07 - JavaScript V/Ejercicio 02.js	
@@ -0,0 +1,30 @@
+/*⚠️ NO MODIFIQUES EL NOMBRE DE LAS DECLARACIONES ⚠️*/
+/*2️⃣ EJERCICIO 02 2️⃣*/
+
+class Persona {
+   // Crea el constructor de la clase "Persona".
+   // Debe tener las propiedades: "nombre", "apellido", "edad" y "domicilio".
+   // Debe tener un método llamado "detalle" que nos devuelva un objeto con las propiedades de la persona y
+   // sus valores.
+}
+
+function crearInstanciaPersona(nombre, apellido, edad, domicilio) {
+   // En este ejercicio debes crear una instancia de la clase construida en el ejercicio anterior.
+   // Recibirás las propiedades por parámetro.
+   // Retornar la instancia creada.
+   // Tu código:
+}
+
+function agregarMetodo() {
+   // La función agrega un método "datos" a la clase "Persona".
+   // Este método toma la propiedad "nombre" y "edad", y devuelve el string:
+   // Ejemplo: "Juan, 22 años".
+   // Tu código:
+}
+
+/*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
+module.exports = {
+   crearInstanciaPersona,
+   agregarMetodo,
+   Persona,
+};
diff --git a/07 - JavaScript V/README.md b/07 - JavaScript V/README.md
new file mode 100644
index 0000000000..7de55e9bc5
--- /dev/null
+++ b/07 - JavaScript V/README.md	
@@ -0,0 +1,61 @@
+![HenryLogo](../Assets//logoBannerHenry.png)
+
+# **HOMEWORK 07 | JAVASCRIPT V**
+
+## **✅ TESTING**
+
+Para ejecutar los tests de las homeworks debes:
+
+1. Desde tu terminal, dirígete a la carpeta raíz de todas las homeworks y ejecuta el comando:
+
+```bash
+    npm install
+```
+
+2. Luego de que se hayan instalado las dependencias pueden comenzar a correr los tests.
+
+-  Para ejecutarlos globalmente (es decir, el de todas las homeworks), ejecuta el comando:
+
+```bash
+    npm test
+```
+
+-  Si quieres ejecutar los tests de esta homework en específico ejecuta el comando:
+
+```bash
+    npm test 07
+```
+
+---
+
+</br >
+
+## **📋 INTRODUCCIÓN**
+
+En esta Homework podrás poner en práctica:
+
+-  Clases
+-  Prototipos
+-  Objeto This
+
+---
+
+</br >
+
+## **📌 INSTRUCCIONES**
+
+### **📍 EJERCICIO 01**
+
+En este ejercicio tendrás que resolver algunas funciones en las que debes acceder al prototipo de distintos objetos y realizar modificaciones.
+
+---
+
+</br >
+
+### **📍 EJERCICIO 02**
+
+En este ejercicio deberás crear una clase, y a partir de ella desarrollar algunas funciones que la utilicen.
+
+---
+
+</br >
diff --git a/07 - JavaScript V/test/JSV.test.js b/07 - JavaScript V/test/JSV.test.js
new file mode 100644
index 0000000000..c132152e56
--- /dev/null
+++ b/07 - JavaScript V/test/JSV.test.js	
@@ -0,0 +1,111 @@
+/* eslint-disable no-undef */
+const {
+   crearUsuario,
+   agregarMetodoPrototype,
+   agregarStringInvertida,
+} = require('../Ejercicio 01');
+
+const {
+   crearInstanciaPersona,
+   agregarMetodo,
+   Persona,
+} = require('../Ejercicio 02');
+
+describe('JAVASCRIPT V', function () {
+   describe('EJERCICIO 01', function () {
+      describe('crearUsuario()', function () {
+         it('Debe retornar una clase con las propiedades "usuario", "nombre", "email" y "password" definidas', function () {
+            const Usuario = crearUsuario();
+            const user = new Usuario(
+               'jssamuel',
+               'Samuel',
+               'samuel@email.com',
+               'LoveJS'
+            );
+            expect(user.usuario).toBe('jssamuel');
+            expect(user.nombre).toBe('Samuel');
+            expect(user.email).toBe('samuel@email.com');
+            expect(user.password).toBe('LoveJS');
+         });
+         it('Debe retornar una clase con un método saludar que retorne el string correspondiente', function () {
+            const Usuario = crearUsuario();
+            const user = new Usuario(
+               'jssamuel',
+               'Samuel',
+               'samuel@email.com',
+               'LoveJS'
+            );
+            expect(user.saludar()).toBe('Hola, mi nombre es Samuel');
+         });
+      });
+
+      describe('agregarMetodoPrototype(Constructor)', function () {
+         it('Debe agregar un método "saludar" al contructor de Usuario', function () {
+            function Test() {
+               this.test = true;
+            }
+            agregarMetodoPrototype(Test);
+            const test = new Test();
+            expect(test.saludar()).toBe('Hello World!');
+         });
+      });
+
+      describe('agregarStringInvertida(StringPrototype)', function () {
+         it('Debe agregar un método al objeto global "String", invirtiendo la cadena de texto', function () {
+            agregarStringInvertida();
+            const str = 'Hello';
+            expect(str.reverse()).toBe('olleH');
+         });
+      });
+   });
+
+   describe('EJERCICIO 02', function () {
+      describe('Clase Persona', function () {
+         it('Debe crear una instancia "Persona" con las propiedades "nombre", "apellido", "edad" y "domicilio"', function () {
+            const nuevaPersona = new Persona(
+               'Juan',
+               'Pérez',
+               22,
+               'Saavedra 123'
+            );
+            expect(nuevaPersona).toBeInstanceOf(Persona);
+            expect(nuevaPersona.nombre).toBe('Juan');
+            expect(nuevaPersona.apellido).toBe('Pérez');
+            expect(nuevaPersona.edad).toBe(22);
+            expect(nuevaPersona.domicilio).toBe('Saavedra 123');
+         });
+         it('"Persona" debe tener un método "detalle" que devuelva la información de la persona en forma de objeto', function () {
+            const nuevaPersona = new Persona(
+               'Juan',
+               'Pérez',
+               22,
+               'Saavedra 123'
+            );
+            expect(nuevaPersona.detalle()).toStrictEqual({
+               nombre: 'Juan',
+               apellido: 'Pérez',
+               edad: 22,
+               domicilio: 'Saavedra 123',
+            });
+         });
+      });
+
+      describe('crearInstanciaPersona()', function () {
+         it('Debe retornar una nueva instancia de "Persona"', function () {
+            expect(
+               crearInstanciaPersona('Juan', 'Pérez', 22, 'Saavedra 123')
+            ).toBeInstanceOf(Persona);
+         });
+      });
+
+      describe('agregarMetodo(Persona)', function () {
+         it('"Persona" debe tener un método "datos" que retorne la información correspondiente', function () {
+            agregarMetodo();
+            const persona = new Persona('Juan', 'Pérez', 22, 'Saavedra 123');
+            persona.nombre === 'Juan' && persona.edad === 22
+               ? expect(persona.datos()).toBe('Juan, 22 años')
+               : expect(persona.datos()).toBe('undefined, undefined años');
+         });
+      });
+   });
+});
diff --git a/08 - JavaScript VI/README.md b/08 - JavaScript VI/README.md
new file mode 100644
index 0000000000..de3256ab57
--- /dev/null
+++ b/08 - JavaScript VI/README.md	
@@ -0,0 +1,47 @@
+![HenryLogo](../Assets//logoBannerHenry.png)
+
+# **HOMEWORK 08 | JAVASCRIPT VI**
+
+## **✅ TESTING**
+
+Para ejecutar los tests de las homeworks debes:
+
+1. Desde tu terminal, dirígete a la carpeta raíz de todas las homeworks y ejecuta el comando:
+
+```bash
+    npm install
+```
+
+2. Luego de que se hayan instalado las dependencias pueden comenzar a correr los tests.
+
+-  Para ejecutarlos globalmente (es decir, el de todas las homeworks), ejecuta el comando:
+
+```bash
+    npm test
+```
+
+-  Si quieres ejecutar los tests de esta homework en específico ejecuta el comando:
+
+```bash
+    npm test 08
+```
+
+---
+
+</br >
+
+## **📋 INTRODUCCIÓN**
+
+En esta Homework podrás poner en práctica:
+
+-  Callbacks
+
+---
+
+</br >
+
+## **📌 INSTRUCCIONES**
+
+### **📍 HOMEWORK**
+
+En esta homework trabajarás con funciones que utilizan callbacks. Sigue las instrucciones del archivo.
diff --git a/08 - JavaScript VI/homework.js b/08 - JavaScript VI/homework.js
new file mode 100644
index 0000000000..b14ff4b6f6
--- /dev/null
+++ b/08 - JavaScript VI/homework.js	
@@ -0,0 +1,60 @@
+/*⚠️ NO MODIFIQUES EL NOMBRE DE LAS DECLARACIONES ⚠️*/
+
+function mayuscula(nombre) {
+   // Esta función recibe un nombre (string).
+   // Debe devolver el mismo nombre, pero con la primera letra en mayúscula.
+   // [Ejemplo]: "mario" ----> "Mario".
+   // Tu código:
+}
+
+function invocarCallback(cb) {
+   // Invoca/ejecuta el callback `cb`.
+   // [NOTA]: no debes reotrnar nada.
+   // Tu código:
+}
+
+function operacionMatematica(num1, num2, cb) {
+   // En este ejercicio recibirás dos números y un callback.
+   // El callback realiza una operación matemática, por lo que necesita de los dos números.
+   // Retorna el resultado del callback pasándole como parámetros los números.
+   // Tu código:
+}
+
+function sumarArray(arrayOfNumbers, cb) {
+   // Recibes un arreglo de números y un callback.
+   // Suma todos los números del arreglo.
+   // Este resultado debes pasárselo como argumento al callback recibido.
+   // [NOTA]: no debes reotrnar nada.
+   // Tu código:
+}
+
+function forEach(array, cb) {
+   // Recibes un arreglo y un callback.
+   // Debes iterar sobre el arreglo, y por cada elemento ejecutar el callback.
+   // Debes pasarle el elemento como argumento al callback.
+   // Tu código:
+}
+
+function map(array, cb) {
+   // Debes iterar sobre el arreglo, y cada elemento pasárselo como arguemento al callback.
+   // Tiene que guardar el resultado devuelto por el callback en cada elemento dentro de un nuevo arreglo.
+   // Retorna el nuevo arreglo.
+   // Tu código:
+}
+
+function filter(arrayOfStrings) {
+   // Debes identificar todos los elementos el arreglo que comiencen con la letra "a".
+   // Luego retorna un nuevo arreglo con estos elementos.
+   // Tu código:
+}
+
+/*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
+module.exports = {
+   mayuscula,
+   invocarCallback,
+   operacionMatematica,
+   sumarArray,
+   forEach,
+   map,
+   filter,
+};
diff --git a/08 - JavaScript VI/test/JSVI.test.js b/08 - JavaScript VI/test/JSVI.test.js
new file mode 100644
index 0000000000..0e203bbe27
--- /dev/null
+++ b/08 - JavaScript VI/test/JSVI.test.js	
@@ -0,0 +1,79 @@
+/* eslint-disable no-undef */
+const {
+   mayuscula,
+   invocarCallback,
+   operacionMatematica,
+   sumarArray,
+   forEach,
+   map,
+   filter,
+} = require('../homework');
+
+describe('JAVASCRIPT VI', function () {
+   describe('mayuscula(nombre)', function () {
+      it('Debe retornar el mismo nombre, pero con la primera letra en mayúscula', function () {
+         expect(mayuscula('mario')).toBe('Mario');
+         expect(mayuscula('ana')).toBe('Ana');
+      });
+   });
+
+   describe('invocarCallback(cb)', function () {
+      it('Debe invocar/ejecutar el callback', function () {
+         const cb = jest.fn();
+         invocarCallback(cb);
+         expect(cb).toHaveBeenCalled();
+      });
+   });
+
+   describe('operacionMatematica(n1, n2, cb)', function () {
+      it('Debe retornar el resultado del callback habiéndole pasado como arguemnto los números recibidos.', function () {
+         const cb = jest.fn();
+         operacionMatematica(100, 20, cb);
+         expect(cb).toHaveBeenCalled();
+      });
+   });
+
+   describe('sumarArray(arrayOfNumbers, cb)', function () {
+      it('Debe sumar todos los números del arreglo y pasarle el resultado como argumento al callback.', function (done) {
+         sumarArray([1, 2, 3, 4, 5], function (sum) {
+            expect(sum).toBe(15);
+            done();
+         });
+      });
+   });
+
+   describe('forEach(array, cb)', function () {
+      it('Debe pasarle como argumento cada elemento del arreglo al callback', function () {
+         const nums = [];
+         forEach([1, 2, 3, 4, 5], function (num) {
+            nums.push(num);
+         });
+         expect(nums).toEqual([1, 2, 3, 4, 5]);
+      });
+   });
+
+   describe('map(array, cb)', function () {
+      it('Debe retornar un arreglo con el resultado de todos los elementos del arreglo pasados por el callback', function () {
+         const squares = map([1, 2, 3, 4, 5], function (num) {
+            return num * num;
+         });
+         expect(squares).toEqual([1, 4, 9, 16, 25]);
+      });
+   });
+
+   describe('filter(arrayOfStrings)', function () {
+      it('Debe retornar un arreglo con todos los elementos que comiencen con la letra "a"', function () {
+         var array = [
+            'abajo',
+            'pera',
+            'escalera',
+            'alerta',
+            'indice',
+            'azteca',
+            'arbol',
+            'buzo',
+         ];
+         expect(filter(array)).toEqual(['abajo', 'alerta', 'azteca', 'arbol']);
+      });
+   });
+});
diff --git a/09 - Ejercicios Extra/Ejercicios Extra.js b/09 - Ejercicios Extra/Ejercicios Extra.js
new file mode 100644
index 0000000000..84c1863d6f
--- /dev/null
+++ b/09 - Ejercicios Extra/Ejercicios Extra.js	
@@ -0,0 +1,73 @@
+/*⚠️ NO MODIFIQUES EL NOMBRE DE LAS DECLARACIONES ⚠️*/
+
+function deObjetoAarray(objeto) {
+   // Recibes un objeto. Tendrás que crear un arreglo de arreglos.
+   // Cada elemento del arreglo padre será un nuevo arreglo que contendrá dos elementos.
+   // Estos elementos debe ser cada par clave:valor del objeto recibido.
+   // [EJEMPLO]: {D: 1, B: 2, C: 3} ---> [['D', 1], ['B', 2], ['C', 3]].
+   // Tu código:
+}
+
+function numberOfCharacters(string) {
+   // La función recibe un string. Debes recorrerlo y retornar un objeto donde cada propiedad es una de las
+   // letras del string, y su valor es la cantidad de veces que se repite en el string.
+   // Las letras deben estar en orden alfabético.
+   // [EJEMPLO]: "adsjfdsfsfjsdjfhacabcsbajda" ---> { a: 5, b: 2, c: 2, d: 4, f: 4, h:1, j: 4, s: 5 }
+   // Tu código:
+}
+
+function capToFront(string) {
+   // Recibes un string con algunas letras en mayúscula y otras en minúscula.
+   // Debes enviar todas las letras en mayúscula al comienzo del string.
+   // Retornar el string.
+   // [EJEMPLO]: soyHENRY ---> HENRYsoy
+   // Tu código:
+}
+
+function asAmirror(frase) {
+   // Recibes una frase. Tu tarea es retornar un nuevo string en el que el orden de las palabras sea el mismo.
+   // La diferencia es que cada palabra estará escrita al inverso.
+   // [EJEMPLO]: "The Henry Challenge is close!"  ---> "ehT yrneH egnellahC si !esolc"
+   // Tu código:
+}
+
+function capicua(numero) {
+   // Si el número que recibes es capicúa debes retornar el string: "Es capicua".
+   // Caso contrario: "No es capicua".
+   // Tu código:
+}
+
+function deleteAbc(string) {
+   // Tu tarea es eliminar las letras "a", "b" y "c" del string recibido.
+   // Retorna el string sin estas letras.
+   // Tu código:
+}
+
+function sortArray(arrayOfStrings) {
+   // Recibes un arreglo de strings.
+   // Debe retornar un nuevo arreglo, pero con las palabras ordenadas en orden creciente a partir
+   // de la longitud de cada string.
+   // [EJEMPLO]: ["You", "are", "beautiful", "looking"]  ---> [“You", "are", "looking", "beautiful"]
+   // Tu código:
+}
+
+function buscoInterseccion(array1, array2) {
+   // Recibes dos arreglos de números.
+   // Debes retornar un nuevo arreglo en el que se guarden los elementos en común entre ambos arreglos.
+   // [EJEMPLO]: [4,2,3] U [1,3,4] = [3,4].
+   // Si no tienen elementos en común, retornar un arreglo vacío.
+   // [PISTA]: los arreglos no necesariamente tienen la misma longitud.
+   // Tu código:
+}
+
+/*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
+module.exports = {
+   deObjetoAarray,
+   numberOfCharacters,
+   capToFront,
+   asAmirror,
+   capicua,
+   deleteAbc,
+   sortArray,
+   buscoInterseccion,
+};
diff --git a/09 - Ejercicios Extra/README.md b/09 - Ejercicios Extra/README.md
new file mode 100644
index 0000000000..9d6cc67698
--- /dev/null
+++ b/09 - Ejercicios Extra/README.md	
@@ -0,0 +1,50 @@
+![HenryLogo](../Assets//logoBannerHenry.png)
+
+# **HOMEWORK 09 | EJERCICIOS EXTRA**
+
+## **✅ TESTING**
+
+Para ejecutar los tests de las homeworks debes:
+
+1. Desde tu terminal, dirígete a la carpeta raíz de todas las homeworks y ejecuta el comando:
+
+```bash
+    npm install
+```
+
+2. Luego de que se hayan instalado las dependencias pueden comenzar a correr los tests.
+
+-  Para ejecutarlos globalmente (es decir, el de todas las homeworks), ejecuta el comando:
+
+```bash
+    npm test
+```
+
+-  Si quieres ejecutar los tests de esta homework en específico ejecuta el comando:
+
+```bash
+    npm test 09
+```
+
+---
+
+</br >
+
+## **📋 INTRODUCCIÓN**
+
+En esta Homework podrás poner en práctica:
+
+-  Lógica de JavaScript
+-  Algunos de los conceptos aprendidos durante el Prep Course
+
+---
+
+</br >
+
+## **📌 INSTRUCCIONES**
+
+### **📍 EJERCICIOS EXTRA**
+
+¡Felicitaciones si haz llegado hasta aquí! 🤩 🥳 😎
+
+En este archivo encontrarás una serie de funciones. Cada función te pedirá que resuelvas un problema poniendo en práctica lógica de programación. Tendrás que utilizar todo lo que haz aprendido a lo largo del Prep Course.
diff --git a/09 - Ejercicios Extra/test/extraExercises.test.js b/09 - Ejercicios Extra/test/extraExercises.test.js
new file mode 100644
index 0000000000..e430226beb
--- /dev/null
+++ b/09 - Ejercicios Extra/test/extraExercises.test.js	
@@ -0,0 +1,104 @@
+/* eslint-disable no-undef */
+const {
+   deObjetoAarray,
+   numberOfCharacters,
+   capToFront,
+   asAmirror,
+   capicua,
+   deleteAbc,
+   sortArray,
+   buscoInterseccion,
+} = require('../Ejercicios Extra');
+
+describe('EJERCICIOS EXTRA', function () {
+   describe('deObjetoAarray(objeto)', function () {
+      it('Debe retornar un arreglo donde cada sub-arreglo contiene el par clave:valor del objeto', function () {
+         expect(deObjetoAarray({ x: 1, y: 2 })).toEqual([
+            ['x', 1],
+            ['y', 2],
+         ]);
+         expect(deObjetoAarray({ x: 10, y: 25 })).toEqual([
+            ['x', 10],
+            ['y', 25],
+         ]);
+      });
+   });
+   describe('numberOfCharacters(string)', function () {
+      it('Debe retornar un objeto donde cada par clave:valor sea una letra:cantidadDeRepeticiones del string recibido', function () {
+         expect(numberOfCharacters('sktpwrroqstkrpwwsqtqopwktsd')).toEqual({
+            s: 4,
+            k: 3,
+            t: 4,
+            p: 3,
+            w: 4,
+            r: 3,
+            o: 2,
+            q: 3,
+            d: 1,
+         });
+         expect(numberOfCharacters('adsjfdsfsfjsdjfhacabcsbajda')).toEqual({
+            a: 5,
+            b: 2,
+            c: 2,
+            d: 4,
+            f: 4,
+            h: 1,
+            j: 4,
+            s: 5,
+         });
+      });
+   });
+   describe('capToFront(string)', function () {
+      it('Debe enviar todas las letras en mayúsculas al comienzo del string', function () {
+         expect(capToFront('soyHENRY')).toEqual('HENRYsoy');
+         expect(capToFront('DESArrollaDOR')).toEqual('DESADORrrolla');
+      });
+   });
+   describe('asAmirror(frase)', function () {
+      it('Debe transformar la frase en una frase espejo.', function () {
+         expect(asAmirror('I love you so much!')).toBe('I evol uoy os !hcum');
+         expect(asAmirror('The Henry Challenge is close!')).toBe(
+            'ehT yrneH egnellahC si !esolc'
+         );
+      });
+   });
+   describe('capicua(numero)', function () {
+      it('Debe retornar el string esperado dependiendo si el número es o no capicúa.', function () {
+         expect(capicua(12321)).toEqual('Es capicua');
+         expect(capicua(1111)).toEqual('Es capicua');
+         expect(capicua(105217)).toEqual('No es capicua');
+         expect(capicua(7878700)).toEqual('No es capicua');
+      });
+   });
+   describe('deleteAbc(string)', function () {
+      it('Debe retornar el mismo string, pero eliminando las letras "a", "b" y "c"', function () {
+         expect(deleteAbc('abcefgh')).toEqual('efgh');
+         expect(deleteAbc('abc')).toEqual('');
+         expect(deleteAbc('plural')).toEqual('plurl');
+         expect(deleteAbc('limon')).toEqual('limon');
+      });
+   });
+   describe('sortArray(arrayOfStrings)', function () {
+      it('Debe retornar un nuevo arreglo con los elementos en orden de crecimiento a partir de sus longitudes', function () {
+         expect(sortArray(['You', 'are', 'beautiful', 'looking'])).toEqual([
+            'You',
+            'are',
+            'looking',
+            'beautiful',
+         ]);
+         expect(sortArray(['pera', 'manzana', 'alcaucil', 'papa'])).toEqual([
+            'pera',
+            'papa',
+            'manzana',
+            'alcaucil',
+         ]);
+      });
+   });
+   describe('buscoInterseccion(array1, array2)', function () {
+      it('Debe retornar un arreglo con los elementos en común de cada arreglo. Si no hay elementos en común, retornar un arreglo vacío', function () {
+         expect(buscoInterseccion([1, 2, 3], [1, 5, 8, 3])).toEqual([1, 3]);
+         expect(buscoInterseccion([7, 23, 4], [23, 70])).toEqual([23]);
+         expect(buscoInterseccion([1, 20, 3], [22, 5, 7])).toEqual([]);
+      });
+   });
+});
diff --git a/Assets/M1Video.png b/Assets/M1Video.png
new file mode 100644
index 0000000000..c0b18b57cb
Binary files /dev/null and b/Assets/M1Video.png differ
diff --git a/Assets/logoBannerHenry.png b/Assets/logoBannerHenry.png
new file mode 100644
index 0000000000..88c36b0492
Binary files /dev/null and b/Assets/logoBannerHenry.png differ
diff --git a/Assets/logoHenry.png b/Assets/logoHenry.png
new file mode 100644
index 0000000000..d97c746879
Binary files /dev/null and b/Assets/logoHenry.png differ
diff --git a/README.md b/README.md
new file mode 100644
index 0000000000..2a161a5847
--- /dev/null
+++ b/README.md
@@ -0,0 +1,89 @@
+![HenryLogo](./Assets//logoBannerHenry.png)
+
+# **🧑‍💻 PREP COURSE | HENRY 👩‍💻**
+
+## **📌 INTRODUCCIÓN**
+
+¡Hola 😄! Bienvenid@ al Prep Course para la carrera de Desarrollo Web Full Stack.
+
+En este curso introductorio podrás aprender y practicar todo el contenido que necesitas para convertirte en un desarrollador de JavaScript. Encontrarás todo el material que necesitas para lograr avanzar en la evaluación del Henry Challenge (último paso para ingresar a la carrera de Desarrollo Web Full Stack).
+
+</br >
+
+## **🔎 ¿QUÉ ES EL PREP COURSE?**
+
+El Prep Course (curso preparatorio) es un curso diseñado con la finalidad de nivelar a todos nuestros aplicantes. Con este curso darás tus primeros pasos en el mundo de la tecnología y aprenderás esos conceptos básicos que son necesarios para poder realizar la carrera.
+
+El curso consiste en una serie de videos, material teórico y ejercicios con los que podrás aprender nuestro lenguaje de desarrollo: Javascript. Puedes avanzar con el contenido a tu ritmo y de manera asincrónica (es decir, en los horarios y tiempos que tu prefieras). Cuando hayas finalizado, podrás inscribirte para realizar el Henry Challenge.
+
+</br >
+
+## **📖 ¿QUÉ ES EL HENRY CHALLENGE?**
+
+Es un examen en el que evaluamos los conceptos que se aprenden durante el Prep Course. El examen tiene la finalidad de asegurarnos que realmente has adquirido los conocimientos, dado que tenerlos bien claros es la clave del éxito para que puedas avanzar sin problemas dentro de la carrera. El examen se realiza todos los sábados, con previa [inscripción](https://www.admissions.soyhenry.com/). Podrás rendirlo todas las veces que quieras.
+
+</br >
+
+## **🤨 ¿QUÉ PUEDO HACER SI TENGO DUDAS?**
+
+### Contamos con dos herramientas de apoyo:
+
+-  **SLACK:** es una plataforma de comunicación, donde podrás ponerte en contacto con nuestra comunidad que siempre te ayudará a resolver todas tus dudas. Encontrarás acceso a Slack desde la [plataforma de admisión](https://www.admissions.soyhenry.com/) o desde los mails que recibiste al momento de aplicar.
+
+-  **CLASES DE APOYO EN VIVO:** de lunes a viernes hay un espacio en vivo por _Zoom_ con estudiantes avanzados que se postulan para responder todas tus consultas.
+
+</br >
+
+## **😋 ¿CÓMO AVANZAR EN ESTE PROCESO?**
+
+Para avanzar debes seguir el material teórico junto con los videos de este curso introductorio. Para afianzar tus conocimientos y comenzar a practicar realiza cada una de estas **_Homeworks_**. Esto te facilitará resolver el Henry Challenge.
+
+Cualquier duda, nos puedes escribir a admisiones@soyhenry.com
+
+</br>
+
+## **✅ TESTING**
+
+Para ejecutar los tests de las homeworks debes:
+
+1. Desde tu terminal, dirígete a la carpeta raíz de todas las homeworks y ejecuta el comando:
+
+```bash
+    npm install
+```
+
+2. Luego de que se hayan instalado las dependencias pueden comenzar a correr los tests.
+
+-  Para ejecutarlos globalmente (es decir, el de todas las homeworks), ejecuta el comando:
+
+```bash
+    npm test
+```
+
+-  Si quieres ejecutar los tests de una homework específica escribe en tu terminal:
+
+```bash
+    npm test XX
+```
+
+... donde "_**XX**_" es el número de la homework.
+
+---
+
+</br >
+
+## **👀 CLASES DE APOYO**
+
+Para poder acompañarte en esta etapa te ofrecemos las **Clases de Apoyo en Vivo**. Este es un espacio donde los Henry Heros (HHs) (estudiantes avanzados de Henry) se ponen a disposición para despejar todas las dudas que puedas tener mientras estás estudiando el Prep Course.
+
+Las clases son de lunes a viernes. Cada día se establece una temática distinta a trabajar. Deberás llegar a la clase habiendo visto los videos sobre ese tema e intentado resolver los ejercicios, dado que en las clases no se explicará los temas desde cero sino que se resolverán dudas puntuales.
+
+Si no puedes asistir al espacio en vivo, podrás ver la grabación. Puedes encontrar el calendario con las clases, el link de acceso y el link de la grabación, aquí: [**CALENDARIO**](https://prep.soyhenry.com/calendario/)
+
+</br>
+
+## **🤜 OPEN HOUSE**
+
+Te compartimos esta grabación del último Open House que hicimos en nuestro canal de Youtube. Aquí puedes conocer más sobre Henry, la carrera y el proceso de admisión:
+
+[![Alt text](./Assets//logoHenry.png)](https://www.youtube.com/watch?v=QNydgNRgGS4)
diff --git a/package.json b/package.json
new file mode 100644
index 0000000000..a23960c034
--- /dev/null
+++ b/package.json
@@ -0,0 +1,15 @@
+{
+   "name": "prepcourse",
+   "version": "3.0.0",
+   "description": "",
+   "main": "index.js",
+   "scripts": {
+      "test": "jest --collectCoverage=false"
+   },
+   "author": "Henry",
+   "license": "ISC",
+   "dependencies": {
+      "eslint": "^8.28.0",
+      "jest": "^29.3.1"
+   }
+}