diff --git a/.gitattributes b/.gitattributes
index 9c8739fb24f3dc75783cd572e4761f7e3a0823f3..f4ea6ed3fdba6ee680675960c2e2013bc52540ce 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -193,3 +193,58 @@ prompt-engineering/8-Estructura[[:space:]]de[[:space:]]prompts[[:space:]]con[[:s
04-Variables[[:space:]]en[[:space:]]el[[:space:]]lenguaje[[:space:]]C/03-Uso[[:space:]]de[[:space:]]Constantes[[:space:]]y[[:space:]]Literales[[:space:]]en[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
04-Variables[[:space:]]en[[:space:]]el[[:space:]]lenguaje[[:space:]]C/04-Uso[[:space:]]de[[:space:]]define[[:space:]]y[[:space:]]const[[:space:]]para[[:space:]]constantes[[:space:]]en[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
05-Conclusiones/01-Funciones[[:space:]]Básicas[[:space:]]del[[:space:]]Lenguaje[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/01-Fundamentos[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]control[[:space:]]de[[:space:]]versiones/01-Control[[:space:]]de[[:space:]]Versiones[[:space:]]con[[:space:]]Git[[:space:]]y[[:space:]]GitHub[[:space:]]De[[:space:]]Básico[[:space:]]a[[:space:]]Avanzado.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/01-Fundamentos[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]control[[:space:]]de[[:space:]]versiones/02-Fundamentos[[:space:]]de[[:space:]]Git[[:space:]]Configuración[[:space:]]y[[:space:]]Comandos[[:space:]]Básicos.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/01-Fundamentos[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]control[[:space:]]de[[:space:]]versiones/03-Control[[:space:]]de[[:space:]]Versiones[[:space:]]con[[:space:]]Git[[:space:]]Comandos[[:space:]]Básicos[[:space:]]y[[:space:]]Flujo[[:space:]]de[[:space:]]Trabajo.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/01-Fundamentos[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]control[[:space:]]de[[:space:]]versiones/04-Gestión[[:space:]]de[[:space:]]ramas[[:space:]]en[[:space:]]Git[[:space:]]creación[[:space:]]fusión[[:space:]]y[[:space:]]eliminación[[:space:]]eficiente.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/01-Fundamentos[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]control[[:space:]]de[[:space:]]versiones/05-Git[[:space:]]Reset[[:space:]]vs[[:space:]]Git[[:space:]]Revert[[:space:]]Manejo[[:space:]]de[[:space:]]Historial[[:space:]]y[[:space:]]Corrección[[:space:]]de[[:space:]]Errores.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/01-Fundamentos[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]control[[:space:]]de[[:space:]]versiones/06-Uso[[:space:]]de[[:space:]]Git[[:space:]]Tag[[:space:]]y[[:space:]]Git[[:space:]]Checkout[[:space:]]para[[:space:]]Gestión[[:space:]]de[[:space:]]Versiones[[:space:]]y[[:space:]]Revisión.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/01-Fundamentos[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]control[[:space:]]de[[:space:]]versiones/07-Resolución[[:space:]]de[[:space:]]Conflictos[[:space:]]de[[:space:]]Ramas[[:space:]]en[[:space:]]Git[[:space:]]paso[[:space:]]a[[:space:]]paso.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/01-Fundamentos[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]control[[:space:]]de[[:space:]]versiones/08-Uso[[:space:]]de[[:space:]]Git[[:space:]]en[[:space:]]Visual[[:space:]]Studio[[:space:]]Code.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/02-Introducción[[:space:]]a[[:space:]]GitHub/01-Uso[[:space:]]de[[:space:]]GitHub[[:space:]]para[[:space:]]Colaboración[[:space:]]y[[:space:]]Desarrollo[[:space:]]Seguro.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/02-Introducción[[:space:]]a[[:space:]]GitHub/02-Creación[[:space:]]y[[:space:]]configuración[[:space:]]de[[:space:]]cuenta[[:space:]]GitHub[[:space:]]paso[[:space:]]a[[:space:]]paso.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/02-Introducción[[:space:]]a[[:space:]]GitHub/03-Proceso[[:space:]]de[[:space:]]Trabajo[[:space:]]con[[:space:]]Git[[:space:]]y[[:space:]]GitHub[[:space:]]Creación[[:space:]]y[[:space:]]Revisión[[:space:]]de[[:space:]]Repositorios.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/02-Introducción[[:space:]]a[[:space:]]GitHub/04-Creación[[:space:]]y[[:space:]]colaboración[[:space:]]en[[:space:]]repositorios[[:space:]]de[[:space:]]GitHub.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/02-Introducción[[:space:]]a[[:space:]]GitHub/06-Configuración[[:space:]]de[[:space:]]SSH[[:space:]]en[[:space:]]GitHub[[:space:]]para[[:space:]]Windows[[:space:]]Linux[[:space:]]y[[:space:]]Mac.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/02-Introducción[[:space:]]a[[:space:]]GitHub/07-Uso[[:space:]]de[[:space:]]Forks[[:space:]]y[[:space:]]Estrellas[[:space:]]en[[:space:]]Repositorios[[:space:]]de[[:space:]]GitHub.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/02-Introducción[[:space:]]a[[:space:]]GitHub/08-Uso[[:space:]]de[[:space:]]git[[:space:]]pull[[:space:]]git[[:space:]]push[[:space:]]y[[:space:]]git[[:space:]]fetch[[:space:]]en[[:space:]]repositorios[[:space:]]GitHub.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/02-Introducción[[:space:]]a[[:space:]]GitHub/09-Creación[[:space:]]de[[:space:]]Plantillas[[:space:]]de[[:space:]]Issues[[:space:]]en[[:space:]]GitHub.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/02-Introducción[[:space:]]a[[:space:]]GitHub/10-Uso[[:space:]]de[[:space:]]Pull[[:space:]]Requests[[:space:]]en[[:space:]]GitHub[[:space:]]para[[:space:]]Colaboración[[:space:]]Efectiva.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/03-Herramientas[[:space:]]de[[:space:]]colaboración[[:space:]]en[[:space:]]GitHub/01-Gestión[[:space:]]de[[:space:]]Proyectos[[:space:]]con[[:space:]]GitHub[[:space:]]Projects[[:space:]]Planificación[[:space:]]Colaborativa.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/03-Herramientas[[:space:]]de[[:space:]]colaboración[[:space:]]en[[:space:]]GitHub/02-Automatización[[:space:]]de[[:space:]]flujos[[:space:]]de[[:space:]]trabajo[[:space:]]en[[:space:]]GitHub[[:space:]]Projects.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/03-Herramientas[[:space:]]de[[:space:]]colaboración[[:space:]]en[[:space:]]GitHub/04-Creación[[:space:]]de[[:space:]]una[[:space:]]Portada[[:space:]]de[[:space:]]Perfil[[:space:]]en[[:space:]]GitHub[[:space:]]con[[:space:]]Markdown.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/03-Herramientas[[:space:]]de[[:space:]]colaboración[[:space:]]en[[:space:]]GitHub/06-Uso[[:space:]]de[[:space:]]GitHub[[:space:]]Gist[[:space:]]para[[:space:]]Compartir[[:space:]]y[[:space:]]Revisar[[:space:]]Código[[:space:]]Colaborativo.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/03-Herramientas[[:space:]]de[[:space:]]colaboración[[:space:]]en[[:space:]]GitHub/07-Creación[[:space:]]y[[:space:]]Publicación[[:space:]]de[[:space:]]Sitios[[:space:]]Web[[:space:]]con[[:space:]]GitHub[[:space:]]Pages.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/04-GitHub[[:space:]]Codespaces/01-Creación[[:space:]]y[[:space:]]Gestión[[:space:]]de[[:space:]]GitHub[[:space:]]Codespaces[[:space:]]en[[:space:]]la[[:space:]]Nube.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/04-GitHub[[:space:]]Codespaces/02-Uso[[:space:]]de[[:space:]]Codespaces[[:space:]]y[[:space:]]plantillas[[:space:]]en[[:space:]]GitHub[[:space:]]para[[:space:]]proyectos[[:space:]]con[[:space:]]Django.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/04-GitHub[[:space:]]Codespaces/03-Programación[[:space:]]Colaborativa[[:space:]]con[[:space:]]Live[[:space:]]Share[[:space:]]en[[:space:]]VS[[:space:]]Code.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/04-GitHub[[:space:]]Codespaces/04-Uso[[:space:]]del[[:space:]]Editor[[:space:]]Web[[:space:]]de[[:space:]]GitHub[[:space:]]para[[:space:]]Edición[[:space:]]Rápida[[:space:]]de[[:space:]]Archivos.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/05-Seguridad[[:space:]]y[[:space:]]buenas[[:space:]]prácticas[[:space:]]en[[:space:]]GitHub/01-Gestión[[:space:]]de[[:space:]]GitHub[[:space:]]Tokens[[:space:]]para[[:space:]]Acceso[[:space:]]Seguro[[:space:]]a[[:space:]]Repositorios.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/05-Seguridad[[:space:]]y[[:space:]]buenas[[:space:]]prácticas[[:space:]]en[[:space:]]GitHub/02-Mitigación[[:space:]]de[[:space:]]Brechas[[:space:]]de[[:space:]]Seguridad[[:space:]]en[[:space:]]Repositorios[[:space:]]GitHub.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/05-Seguridad[[:space:]]y[[:space:]]buenas[[:space:]]prácticas[[:space:]]en[[:space:]]GitHub/03-Gestión[[:space:]]de[[:space:]]Seguridad[[:space:]]de[[:space:]]Paquetes[[:space:]]con[[:space:]]Dependabot[[:space:]]en[[:space:]]Proyectos[[:space:]]NET.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/05-Seguridad[[:space:]]y[[:space:]]buenas[[:space:]]prácticas[[:space:]]en[[:space:]]GitHub/04-Configuración[[:space:]]de[[:space:]]Repositorios[[:space:]]Privados[[:space:]]en[[:space:]]GitHub.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/06-Administración[[:space:]]de[[:space:]]GitHub/01-Creación[[:space:]]y[[:space:]]gestión[[:space:]]de[[:space:]]repositorios[[:space:]]en[[:space:]]GitHub.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/06-Administración[[:space:]]de[[:space:]]GitHub/02-Automatización[[:space:]]de[[:space:]]GitHub[[:space:]]Actions[[:space:]]para[[:space:]]Actualizar[[:space:]]Perfil.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/06-Administración[[:space:]]de[[:space:]]GitHub/03-Uso[[:space:]]de[[:space:]]GitHub[[:space:]]CLI[[:space:]]instalación[[:space:]]y[[:space:]]comandos[[:space:]]básicos.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/07-Gestión[[:space:]]de[[:space:]]Cambios[[:space:]]con[[:space:]]Pull[[:space:]]Requests/01-Configuración[[:space:]]de[[:space:]]Proyectos[[:space:]]de[[:space:]]Software[[:space:]]con[[:space:]]Git[[:space:]]y[[:space:]]GitHub.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/07-Gestión[[:space:]]de[[:space:]]Cambios[[:space:]]con[[:space:]]Pull[[:space:]]Requests/02-Creación[[:space:]]y[[:space:]]Gestión[[:space:]]de[[:space:]]Branches[[:space:]]y[[:space:]]Pull[[:space:]]Requests[[:space:]]en[[:space:]]GitHub.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/08-GitHub[[:space:]]Releases/01-Creación[[:space:]]de[[:space:]]Releases[[:space:]]en[[:space:]]Github[[:space:]]para[[:space:]]Desarrolladores[[:space:]]de[[:space:]]Software.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/08-GitHub[[:space:]]Releases/02-Creación[[:space:]]y[[:space:]]Uso[[:space:]]de[[:space:]]Paquetes[[:space:]]PIP[[:space:]]en[[:space:]]Python[[:space:]]desde[[:space:]]GitHub.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Git[[:space:]]y[[:space:]]GitHub/09-Cierre/01-Tips[[:space:]]Avanzados[[:space:]]para[[:space:]]Mejorar[[:space:]]tu[[:space:]]Flujo[[:space:]]de[[:space:]]Trabajo[[:space:]]en[[:space:]]GitHub.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Introducción[[:space:]]a[[:space:]]C/01-Introducción[[:space:]]al[[:space:]]lenguaje[[:space:]]C/01-Fundamentos[[:space:]]del[[:space:]]Lenguaje[[:space:]]de[[:space:]]Programación[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Introducción[[:space:]]a[[:space:]]C/01-Introducción[[:space:]]al[[:space:]]lenguaje[[:space:]]C/01-presentacion-curso-de-introduccion-a-c_03d52e2b-ae7d-4f48-a639-97796abeae8f.pdf filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Introducción[[:space:]]a[[:space:]]C/01-Introducción[[:space:]]al[[:space:]]lenguaje[[:space:]]C/02-Programación[[:space:]]en[[:space:]]C[[:space:]]Estructuras[[:space:]]Funciones[[:space:]]y[[:space:]]Memoria.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Introducción[[:space:]]a[[:space:]]C/01-Introducción[[:space:]]al[[:space:]]lenguaje[[:space:]]C/03-Cómo[[:space:]]una[[:space:]]computadora[[:space:]]interpreta[[:space:]]datos[[:space:]]binarios.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Introducción[[:space:]]a[[:space:]]C/01-Introducción[[:space:]]al[[:space:]]lenguaje[[:space:]]C/04-Fundamentos[[:space:]]del[[:space:]]Lenguaje[[:space:]]C[[:space:]]para[[:space:]]Microcontroladores.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Introducción[[:space:]]a[[:space:]]C/01-Introducción[[:space:]]al[[:space:]]lenguaje[[:space:]]C/05-Configuración[[:space:]]de[[:space:]]Entorno[[:space:]]para[[:space:]]Programar[[:space:]]en[[:space:]]C[[:space:]]en[[:space:]]Windows.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Introducción[[:space:]]a[[:space:]]C/01-Introducción[[:space:]]al[[:space:]]lenguaje[[:space:]]C/06-Instalación[[:space:]]y[[:space:]]Ejecución[[:space:]]de[[:space:]]Programas[[:space:]]C[[:space:]]en[[:space:]]Linux.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Introducción[[:space:]]a[[:space:]]C/02-Estructura[[:space:]]de[[:space:]]un[[:space:]]programa[[:space:]]C/01-Estructura[[:space:]]Básica[[:space:]]de[[:space:]]un[[:space:]]Programa[[:space:]]en[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Introducción[[:space:]]a[[:space:]]C/03-Tipos[[:space:]]de[[:space:]]Datos[[:space:]]en[[:space:]]el[[:space:]]lenguaje[[:space:]]C/01-Tipos[[:space:]]de[[:space:]]Datos[[:space:]]en[[:space:]]C[[:space:]]Enteros[[:space:]]y[[:space:]]Flotantes.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Introducción[[:space:]]a[[:space:]]C/03-Tipos[[:space:]]de[[:space:]]Datos[[:space:]]en[[:space:]]el[[:space:]]lenguaje[[:space:]]C/02-Uso[[:space:]]del[[:space:]]Tipo[[:space:]]de[[:space:]]Dato[[:space:]]Void[[:space:]]en[[:space:]]Programación[[:space:]]en[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Introducción[[:space:]]a[[:space:]]C/03-Tipos[[:space:]]de[[:space:]]Datos[[:space:]]en[[:space:]]el[[:space:]]lenguaje[[:space:]]C/03-Enums[[:space:]]en[[:space:]]C[[:space:]]Uso[[:space:]]y[[:space:]]Ejemplos[[:space:]]Prácticos[[:space:]]para[[:space:]]Constantes.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Introducción[[:space:]]a[[:space:]]C/03-Tipos[[:space:]]de[[:space:]]Datos[[:space:]]en[[:space:]]el[[:space:]]lenguaje[[:space:]]C/04-Tipos[[:space:]]de[[:space:]]datos[[:space:]]char[[:space:]]y[[:space:]]unsigned[[:space:]]char[[:space:]]en[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Introducción[[:space:]]a[[:space:]]C/04-Variables[[:space:]]en[[:space:]]el[[:space:]]lenguaje[[:space:]]C/01-Declaración[[:space:]]y[[:space:]]uso[[:space:]]de[[:space:]]variables[[:space:]]en[[:space:]]lenguaje[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Introducción[[:space:]]a[[:space:]]C/04-Variables[[:space:]]en[[:space:]]el[[:space:]]lenguaje[[:space:]]C/02-Manejo[[:space:]]de[[:space:]]Variables[[:space:]]Externas[[:space:]]en[[:space:]]C[[:space:]]y[[:space:]]Precisión[[:space:]]Numérica.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Introducción[[:space:]]a[[:space:]]C/04-Variables[[:space:]]en[[:space:]]el[[:space:]]lenguaje[[:space:]]C/03-Uso[[:space:]]de[[:space:]]Constantes[[:space:]]y[[:space:]]Literales[[:space:]]en[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Introducción[[:space:]]a[[:space:]]C/04-Variables[[:space:]]en[[:space:]]el[[:space:]]lenguaje[[:space:]]C/04-Uso[[:space:]]de[[:space:]]define[[:space:]]y[[:space:]]const[[:space:]]para[[:space:]]constantes[[:space:]]en[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
+Curso[[:space:]]de[[:space:]]Introducción[[:space:]]a[[:space:]]C/05-Conclusiones/01-Funciones[[:space:]]Básicas[[:space:]]del[[:space:]]Lenguaje[[:space:]]C.mp4 filter=lfs diff=lfs merge=lfs -text
diff --git "a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/01-Control de Versiones con Git y GitHub De B\303\241sico a Avanzado.mp4" "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/01-Control de Versiones con Git y GitHub De B\303\241sico a Avanzado.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..19d2599a6cbffe552595a0a241422bdf6d60b16d
--- /dev/null
+++ "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/01-Control de Versiones con Git y GitHub De B\303\241sico a Avanzado.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:96293b8903f7e83b9015781e1a669dbdde2c337916df612f308a40cafa911752
+size 75495300
diff --git "a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/01-Control de Versiones con Git y GitHub De B\303\241sico a Avanzado.vtt" "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/01-Control de Versiones con Git y GitHub De B\303\241sico a Avanzado.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..f5f449cab9f8376e90eb0593f36af081a13adc30
--- /dev/null
+++ "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/01-Control de Versiones con Git y GitHub De B\303\241sico a Avanzado.vtt"
@@ -0,0 +1,183 @@
+WEBVTT
+
+00:00.000 --> 00:07.080
+Versión final, versión final final y por
+supuesto versión final final ahora sí.
+
+00:07.080 --> 00:13.560
+Trabajar así es un caos y cuando trabajas
+en equipo el caos se convierte en desastre.
+
+00:13.560 --> 00:17.800
+Aquí es en donde entra Git, un software de
+control de versiones.
+
+00:17.800 --> 00:21.280
+Git guarda sólo los cambios que haces en
+cada archivo.
+
+00:21.280 --> 00:26.160
+Además te permite coordinar los cambios
+que haces con otras personas y ellas contigo,
+
+00:26.160 --> 00:29.280
+es decir facilita la colaboración en equipo.
+
+00:29.280 --> 00:34.240
+Antes de que pienses esto suena muy
+complicado, te voy a contar un secreto.
+
+00:34.240 --> 00:39.600
+Git es la razón por la que los
+desarrolladores hoy en día no se vuelven locos.
+
+00:39.600 --> 00:45.120
+Antes de su existencia los desarrolladores
+solíamos lidiar con múltiples versiones de
+
+00:45.120 --> 00:50.000
+archivos de manera manual, lo que era
+ineficiente y muy propenso a errores.
+
+00:50.000 --> 00:54.320
+Cuando Git llegó sus enciges provocó que
+su adopción fuera inmediata.
+
+00:54.320 --> 00:59.560
+Pronto se estableció como la herramienta
+de referencia volviéndose prácticamente
+
+00:59.560 --> 01:01.880
+un estándar para los y las programadoras.
+
+01:01.880 --> 01:07.320
+Ahora aquí te va un dato curioso, el
+creador de Git es Linus Torvalds,
+
+01:07.320 --> 01:13.080
+el mismo que creó el kernel de Linux y lo
+hizo para resolver sus propios problemas de control de
+
+01:13.080 --> 01:18.360
+versiones. Git no sólo es una herramienta
+poderosa sino también open source, lo que
+
+01:18.360 --> 01:23.200
+significa que puedes no sólo ver su código
+fuente sino también contribuir a sus mejoras.
+
+01:23.200 --> 01:26.360
+Es por esto que sigue siendo cada vez mejor.
+
+01:26.360 --> 01:29.440
+Ahora, ¿por qué es importante para
+ti?
+
+01:29.440 --> 01:35.960
+Bueno, porque desde que escribes tu primer
+hola mundo, necesitas una manera eficiente
+
+01:35.960 --> 01:41.680
+de gestionar tu código y aprender a usar
+un control de versiones como Git es fundamental
+
+01:41.680 --> 01:46.600
+para tu crecimiento profesional. No sólo
+te permitirá colaborar en proyectos con otros
+
+01:46.600 --> 01:51.320
+developers dentro de una empresa, sino que
+también te ayudará a publicar tu trabajo
+
+01:51.320 --> 01:54.200
+individual y contribuir a proyectos de
+terceros.
+
+01:54.200 --> 02:00.400
+Al final del día, en la industria del
+software, casi ningún producto es creado por una sola
+
+02:00.400 --> 02:06.280
+persona. Siempre se trata de equipos
+trabajando juntos. Aquí es en donde Git se convierte en
+
+02:06.280 --> 02:10.200
+una herramienta esencial para volverte un
+gran desarrollador de software.
+
+02:10.200 --> 02:15.280
+Git funciona en tu máquina local a través
+de la terminal o editores como Visual Studio Code,
+
+02:15.280 --> 02:20.120
+y tiene comandos como merge, pull, commit,
+push y muchos más.
+
+02:20.120 --> 02:24.280
+Si quieres colaborar con otros, usarás una
+plataforma en la web como GitHub,
+
+02:24.280 --> 02:29.960
+donde podrás guardar tu código en la nube,
+sus cambios y cada una de sus versiones.
+
+02:29.960 --> 02:35.360
+GitHub es tan popular que en los últimos
+años ha crecido en su uso y ha incorporado
+
+02:35.360 --> 02:40.160
+funcionalidades que van mucho más allá de Git,
+pero que aumentan la productividad
+
+02:40.160 --> 02:46.200
+y felicidad de sus developers. En este curso,
+vas a configurar Git en tu propia computadora,
+
+02:46.200 --> 02:52.880
+crear repositorios locales, cambiar los
+archivos, crear ramas, fusionarlas y dominar el flujo de
+
+02:52.880 --> 02:58.400
+trabajo con Git. Después, vas a crear un
+repositorio remoto en GitHub. Verás cómo
+
+02:58.400 --> 03:04.320
+integrar a otros programadores en tu proyecto,
+revisar sus aportes, fusionarlos con tu rama
+
+03:04.320 --> 03:10.520
+principal, arreglar errores y conflictos,
+así como entender un flujo de trabajo profesional
+
+03:10.520 --> 03:14.800
+en GitHub con Git. Ahora que sabes esto,
+te daré un secreto.
+
+03:14.800 --> 03:20.320
+Muchos dicen saber Git, pero solo rascan
+la superficie. Tú serás diferente.
+
+03:20.320 --> 03:26.240
+En este curso, vamos a profundizar para
+que no solo sepas hacer commit, pull y push,
+
+03:26.240 --> 03:31.200
+sino que también domines herramientas
+avanzadas como ramas, merge, code spaces,
+
+03:31.200 --> 03:35.920
+seguimiento de proyectos y
+automatizaciones que harán que destaques en la industria.
+
+03:35.920 --> 03:41.800
+Para empezar, solo necesitas saber lo
+esencial de una terminal, crear directorios y archivos,
+
+03:41.800 --> 03:47.080
+moverte entre directorios y conocer lo
+esencial de cualquier lenguaje de programación.
+
+03:47.080 --> 04:14.080
+¿Quieres destacar en la industria del
+software? La próxima clase es tu siguiente paso. Te espero allá.
+
diff --git a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/01-Lecturas recomendadas.txt b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/01-Lecturas recomendadas.txt
new file mode 100644
index 0000000000000000000000000000000000000000..096db84a1aa9875aae7ccc51ed8c04b1ec93c52e
--- /dev/null
+++ b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/01-Lecturas recomendadas.txt
@@ -0,0 +1,2 @@
+https://git-scm.com/
+https://github.com/
diff --git a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/01-Resumen.html b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/01-Resumen.html
new file mode 100644
index 0000000000000000000000000000000000000000..29a4d3f05a4a0f6eb70109a43e5e62d58fd192ac
--- /dev/null
+++ b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/01-Resumen.html
@@ -0,0 +1,75 @@
+
+
+
+
+
+
+ Control de Versiones con Git y GitHub: De Básico a Avanzado
+
+
+
+
+
+
Resumen
Aprender a gestionar versiones en proyectos de software es fundamental para evitar el caos de múltiples archivos llamados “versión final” y mejorar la colaboración en equipo. Git, un sistema de control de versiones, permite a los desarrolladores trabajar de manera ordenada, manteniendo solo los cambios realizados en los archivos y simplificando el trabajo en equipo al coordinar y sincronizar las modificaciones.
+
¿Qué es Git y por qué debería importarte?
+
Git es la herramienta de control de versiones más utilizada por programadores. Su función es clara: gestiona versiones de archivos de forma eficaz, algo vital en proyectos colaborativos. Sin Git, los desarrolladores enfrentaban problemas de organización y errores en la sincronización manual de archivos, un proceso que era tan lento como propenso a fallos.
+
¿Quién creó Git y por qué es tan relevante?
+
El creador de Git es Linus Torvalds, el mismo desarrollador detrás del núcleo de Linux, quien creó esta herramienta para resolver sus propias necesidades de control de versiones. Además, Git es open source, lo que permite a cualquier persona contribuir a su mejora constante, garantizando que siga siendo una herramienta poderosa y en evolución.
+
¿Cómo te beneficia aprender Git desde el inicio?
+
Desde que comienzas a programar, aprender Git te brinda una ventaja profesional. Esta herramienta te permitirá organizar tu código, colaborar con otros desarrolladores y, eventualmente, contribuir a proyectos externos. En el desarrollo de software, los productos suelen ser el resultado del esfuerzo de un equipo, y Git se vuelve esencial para gestionar el trabajo de manera efectiva.
+
¿Cómo funciona Git en tu entorno de trabajo?
+
Git se usa en la terminal o en editores como Visual Studio Code, utilizando comandos clave como commit, pull, push, merge, entre otros. Para colaborar en proyectos con otros desarrolladores, se usa una plataforma en la nube como GitHub. Allí puedes almacenar tu código, gestionar versiones y acceder a funcionalidades adicionales que aumentan la productividad y facilitan la colaboración.
+
¿Qué aprenderás en este curso de Git?
+
En este curso, aprenderás a:
+
+
Configurar Git en tu computadora y crear repositorios locales.
+
Realizar cambios, crear ramas, fusionarlas y gestionar el flujo de trabajo en equipo.
+
Configurar un repositorio remoto en GitHub para colaborar en proyectos.
+
Revisar y fusionar aportes de otros programadores, resolver conflictos y entender un flujo de trabajo profesional.
+
+
Al final, dominarás tanto los comandos básicos como las herramientas avanzadas, desde ramas y fusiones hasta Code Spaces y automatizaciones, para que realmente te destaques en el uso de Git.
+
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/02-Fundamentos de Git Configuraci\303\263n y Comandos B\303\241sicos.mp4" "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/02-Fundamentos de Git Configuraci\303\263n y Comandos B\303\241sicos.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..b1af9baae52b9afa27becde22c8a679a38728d7a
--- /dev/null
+++ "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/02-Fundamentos de Git Configuraci\303\263n y Comandos B\303\241sicos.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:db99c2af8f27a0557b67bc31115be9378eecec317ca8b84042caf61a674bcb46
+size 44475479
diff --git "a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/02-Fundamentos de Git Configuraci\303\263n y Comandos B\303\241sicos.vtt" "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/02-Fundamentos de Git Configuraci\303\263n y Comandos B\303\241sicos.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..af0ea8f1c8ee192a1c465e2052df02d935620d2f
--- /dev/null
+++ "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/02-Fundamentos de Git Configuraci\303\263n y Comandos B\303\241sicos.vtt"
@@ -0,0 +1,455 @@
+WEBVTT
+
+00:00.000 --> 00:02.400
+La herramienta con la que
+vamos a comenzar a trabajar
+
+00:02.400 --> 00:04.700
+es una terminal de
+comandos.
+
+00:04.700 --> 00:08.300
+Esta terminal de comandos en Linux, en Mac,
+
+00:08.300 --> 00:12.200
+o en el sistema de WSL dentro de Windows,
+
+00:12.200 --> 00:14.700
+que es el subsistema de Linux,
+
+00:14.700 --> 00:17.700
+trae ya por defecto Git instalado,
+
+00:17.700 --> 00:20.000
+así que no hay nada que hacer.
+
+00:20.000 --> 00:21.700
+Para confirmar esto,
+
+00:21.700 --> 00:24.800
+lo primero que puedes hacer dentro de tu
+terminal
+
+00:24.800 --> 00:31.000
+es escribir el comando
+git-version,
+
+00:31.000 --> 00:33.500
+y ahí te va a mostrar la
+versión
+
+00:33.500 --> 00:36.000
+confirmando que tienes la herramienta.
+
+00:36.000 --> 00:37.800
+Si esto no
+sucede,
+
+00:37.800 --> 00:39.600
+dentro de los recursos de la
+clase
+
+00:39.600 --> 00:41.900
+te dejamos los artículos
+necesarios
+
+00:41.900 --> 00:43.600
+para que puedas instalar
+Git
+
+00:43.600 --> 00:46.000
+en cualquiera de estos sistemas
+operativos
+
+00:46.000 --> 00:47.700
+sin mayores
+problemas.
+
+00:47.700 --> 00:51.700
+Ahora, ya que estamos listos y seguros de
+que tenemos Git,
+
+00:51.700 --> 00:55.300
+es momento de comenzar a jugar con esta
+plataforma.
+
+00:55.300 --> 00:57.800
+Primero voy a limpiar mi
+terminal.
+
+00:57.800 --> 01:01.800
+Después voy a crear un folder o una
+carpeta
+
+01:01.800 --> 01:05.100
+que me permitan utilizarlo como el primer
+proyecto.
+
+01:05.100 --> 01:06.800
+mkdir,
+
+01:06.800 --> 01:10.300
+y puedo poner mi primer
+proyecto.
+
+01:13.000 --> 01:14.500
+Dentro de esta
+carpeta,
+
+01:14.500 --> 01:16.700
+ahora me necesito
+mover
+
+01:16.700 --> 01:18.200
+antes de hacer cualquier
+comando,
+
+01:18.200 --> 01:22.700
+es decir, cd mi primer
+proyecto.
+
+01:23.700 --> 01:24.900
+Ahora
+sí,
+
+01:24.900 --> 01:28.300
+el primer comando de Git que siempre vamos
+a utilizar,
+
+01:28.300 --> 01:30.300
+git
+init,
+
+01:31.100 --> 01:33.100
+presiona
+Enter,
+
+01:33.100 --> 01:37.100
+y te va a aparecer el nombre de
+master
+
+01:37.100 --> 01:40.200
+como el nombre de la rama
+inicial.
+
+01:40.200 --> 01:43.700
+Esta rama por defecto es sujeta a cambio,
+
+01:43.700 --> 01:46.400
+y de hecho es algo que vamos a hacer.
+
+01:46.400 --> 01:49.900
+Hace mucho tiempo todos utilizábamos
+master
+
+01:49.900 --> 01:51.700
+como la rama
+principal.
+
+01:51.700 --> 01:56.200
+Ahora el nombre original ha cambiado a main.
+
+01:56.200 --> 02:01.200
+Entonces, quiero primero ajustar la rama
+por defecto para main.
+
+02:01.700 --> 02:03.700
+Limpio mi
+terminal,
+
+02:04.200 --> 02:05.700
+y voy a
+escribir
+
+02:05.700 --> 02:11.200
+git
+config-global
+
+02:11.200 --> 02:18.200
+y después
+init.defaultbranch
+
+02:19.200 --> 02:22.200
+main.
+
+02:22.200 --> 02:23.200
+Enter.
+
+02:23.200 --> 02:27.700
+No hay ninguna retroalimentación por parte
+de mi terminal.
+
+02:27.700 --> 02:31.200
+Sin embargo, gracias a que yo hice este
+comando,
+
+02:31.200 --> 02:33.200
+lo que sigue es
+escribir
+
+02:33.200 --> 02:39.200
+git
+branch-m
+
+02:39.200 --> 02:42.200
+main.
+
+02:42.200 --> 02:43.200
+Listo.
+
+02:43.200 --> 02:46.200
+De nuevo, la terminal no me ha confirmado
+nada,
+
+02:46.200 --> 02:49.200
+pero todos estos cambios han sido realizados.
+
+02:49.200 --> 02:51.200
+En primer lugar, hay que
+mencionar
+
+02:51.200 --> 02:54.200
+que no tengo una memoria
+privilegiada
+
+02:54.200 --> 02:56.700
+que me haga recordar todos los comandos.
+
+02:56.700 --> 02:58.700
+Lo que sí tengo es la
+facilidad
+
+02:58.700 --> 03:02.700
+de saber cuáles son estos comandos y cómo leerlos.
+
+03:02.700 --> 03:05.700
+Para ello, te puedo dar el gran tip de escribir
+
+03:05.700 --> 03:09.700
+git
+space--help
+
+03:10.700 --> 03:12.200
+para que veas aquí
+
+03:12.200 --> 03:16.200
+todas las posibilidades de comandos que
+puedes utilizar.
+
+03:16.200 --> 03:18.700
+Esta documentación, aunque es breve,
+
+03:18.700 --> 03:22.700
+sirve muchísimo para que si no te acuerdas
+de una sintaxis,
+
+03:22.700 --> 03:25.200
+que es algo que a mí me pasa comúnmente,
+
+03:25.200 --> 03:27.700
+sepas cómo llegar a la
+documentación
+
+03:27.700 --> 03:31.200
+y poder buscar el comando que estabas
+olvidando.
+
+03:31.700 --> 03:32.700
+Limpié mi
+terminal
+
+03:32.700 --> 03:36.700
+y ahora voy a escribir el primero de estos
+dos comandos mencionados.
+
+03:36.700 --> 03:38.700
+git
+config.
+
+03:38.700 --> 03:41.200
+De hecho, ambos van a ser de configuración,
+
+03:41.200 --> 03:44.200
+pero son diferentes en los datos que voy a
+poner.
+
+03:44.200 --> 03:47.200
+Voy a agregar el parámetro -global.
+
+03:47.200 --> 03:51.200
+Esto va a hacer que esta configuración que
+estoy agregando
+
+03:51.200 --> 03:53.700
+no solo corresponda a este repositorio
+
+03:53.700 --> 03:56.200
+que tengo dentro de mi primer proyecto,
+
+03:56.200 --> 04:00.200
+sino a la configuración global de mi
+instalación de git.
+
+04:00.200 --> 04:02.700
+Es decir, para todos mis
+repos.
+
+04:02.700 --> 04:05.700
+Ya que puse ese parámetro de global,
+
+04:05.700 --> 04:10.200
+escribo espacio user.name
+
+04:10.700 --> 04:13.700
+y voy a poner, entre comillas, mi nombre.
+
+04:13.700 --> 04:17.200
+Puedes poner aquí el nombre de usuario que
+más te guste.
+
+04:17.200 --> 04:19.200
+No solo tiene que ser un nombre real,
+
+04:19.200 --> 04:22.200
+puede ser algún apodo o cosas por el estilo.
+
+04:22.200 --> 04:26.200
+En mi caso, lo dejo como Amin Espinosa y
+presiono Enter.
+
+04:26.200 --> 04:29.200
+Después, el segundo comando de
+configuración
+
+04:29.200 --> 04:34.200
+que más me interesa es git config espacio,
+
+04:34.200 --> 04:38.700
+de nuevo, los dos guiones para escribir el
+parámetro global,
+
+04:39.700 --> 04:44.700
+espacio, y ahora va a ser user.email.
+
+04:44.700 --> 04:46.700
+Con este correo
+electrónico,
+
+04:46.700 --> 04:54.000
+yo puedo acceder a que todos los
+repositorios sepan cuál es el correo electrónico
+
+04:54.000 --> 04:57.000
+del usuario que está trabajando en ese repositorio.
+
+04:57.000 --> 04:59.700
+O en cualquiera de todos los que vaya a crear.
+
+05:00.000 --> 05:08.000
+Entre comillas, puedo poner amin.espinoza@gmail.com, Enter.
+
+05:08.000 --> 05:13.800
+Si te aparece este error de desconocido,
+puede ser que haya algún error de dedo.
+
+05:13.800 --> 05:17.700
+Y aquí está, gloabal es global.
+
+05:17.900 --> 05:27.000
+Puedes presionar la flecha hacia arriba para regresar a tu último
+comando y corregir ese problema sin tener escribirlo todo de nuevo.
+
+05:27.700 --> 05:30.200
+Listo, git config global, Enter.
+
+05:30.200 --> 05:33.200
+Ahora sí, todo está funcionando de maravilla.
+
+05:33.200 --> 05:42.100
+Voy a limpiar de nuevo mi terminal. Ya que establecimos todo este conjunto de configuraciones dentro de nuestra instancia de git,
+
+05:42.100 --> 05:44.200
+es momento de saber que todo está en orden.
+
+05:44.200 --> 05:56.100
+Y para poder hacerlo, escribes git config --list
+y aquí viene toda la configuración que acabas de establecer.
+
+05:56.300 --> 06:04.100
+Es decir, a partir de ahora, git va a utilizar
+este username y user email para poder trabajar.
+
+06:04.800 --> 06:09.700
+También va a comenzar a trabajar con la
+rama por defecto, pero ahora llamada main.
+
+06:11.700 --> 06:14.700
+Es decir, todos mis repositorios
+nacerán
+
+06:14.700 --> 06:17.700
+con esta rama main como la rama por defecto.
+
+06:17.700 --> 06:20.700
+Ya que pasamos por nuestros primeros
+comandos
+
+06:20.700 --> 06:23.700
+dentro de git, puede ser que te sientas un
+poco abrumado
+
+06:23.700 --> 06:26.700
+de saber que todos estos te los tienes que
+recordar
+
+06:26.700 --> 06:29.700
+cada vez que estés configurando una
+instancia de git,
+
+06:29.700 --> 06:31.700
+pero la verdad es que no es
+cierto.
+
+06:31.700 --> 06:33.700
+Al principio también yo me
+abrumé,
+
+06:33.700 --> 06:36.700
+hasta que me di cuenta que había un
+recurso bastante útil
+
+06:36.700 --> 06:39.700
+que te estamos dejando en los recursos de
+esta clase.
+
+06:39.700 --> 06:41.700
+Es una lista de referencia de estos
+comandos
+
+06:41.700 --> 06:43.700
+y qué es lo que
+hacen,
+
+06:43.700 --> 06:46.700
+así como de algunos términos que vamos a
+estar utilizando
+
+06:46.700 --> 06:48.700
+a lo largo de todo este
+curso.
+
+06:48.700 --> 06:51.700
+Lo ideal es que tengas esta hoja de
+referencia a la mano,
+
+06:51.700 --> 06:53.700
+de preferencia la puedas
+imprimir
+
+06:53.700 --> 06:56.700
+y la puedas utilizar para
+visitar
+
+06:56.700 --> 07:01.000
+cada vez que te olvides de lo que
+uno de esos comandos puede hacer por ti.
\ No newline at end of file
diff --git a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/02-Lecturas recomendadas.txt b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/02-Lecturas recomendadas.txt
new file mode 100644
index 0000000000000000000000000000000000000000..34950151e491eb636d96b109a8eb877fcce994d2
--- /dev/null
+++ b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/02-Lecturas recomendadas.txt
@@ -0,0 +1,7 @@
+https://git-scm.com/
+https://git-scm.com/docs/git-init
+https://education.github.com/git-cheat-sheet-education.pdf
+https://git-scm.com/docs/git-config
+https://git-scm.com/book/es/v2/Inicio---Sobre-el-Control-de-Versiones-Configurando-Git-por-primera-vez
+https://platzi.com/home/clases/6900-configuracion-windows/60922-configurar-windows-11-para-soportar-la-instalacion/
+https://github.com/
diff --git a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/02-Resumen.html b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/02-Resumen.html
new file mode 100644
index 0000000000000000000000000000000000000000..4319e03008a19c25c6eaa772b0b69482ced8d3f1
--- /dev/null
+++ b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/02-Resumen.html
@@ -0,0 +1,139 @@
+
+
+
+
+
+
+ Fundamentos de Git: Configuración y Comandos Básicos
+
+
+
+
+
+
Resumen
Trabajar con Git en la terminal permite a los desarrolladores gestionar sus proyectos de manera eficiente. A continuación, revisamos cómo instalar, configurar y utilizar Git en Linux, Mac y WSL de Windows, junto con algunas recomendaciones prácticas para dominar los comandos iniciales de esta herramienta.
+
¿Cómo confirmar que Git está instalado en tu sistema?
+
Para verificar la instalación de Git:
+
+
Abre la terminal y escribe el comando git --version.
+
Si el comando devuelve un número de versión, Git está listo para usarse.
+
Si no aparece la versión, revisa los recursos adjuntos donde se explican las instalaciones para cada sistema operativo.
+
+
¿Cómo crear y preparar el primer proyecto con Git?
+
El primer paso para crear un proyecto en Git es:
+
+
Limpia la terminal para evitar confusión visual.
+
Crea una carpeta para el proyecto con mkdir nombre_del_proyecto.
+
Navega a la carpeta con cd nombre_del_proyecto.
+
+
¿Cómo inicializar un repositorio en Git?
+
Al estar dentro de la carpeta de tu proyecto, inicia el repositorio con:
+
+
git init: Esto crea la rama inicial “master” por defecto.
+
+
Si prefieres la rama principal como “main”:
+
+
Cambia la configuración global escribiendo git config --global init.defaultBranch main.
+
Actualiza la rama en el proyecto actual con git branch -m main.
+
+
¿Cómo personalizar tu configuración de usuario en Git?
+
Configura el nombre de usuario y correo electrónico de Git, que identificará todas tus contribuciones:
+
+
Usa git config --global user.name "Tu Nombre o Apodo".
+
Configura el correo electrónico con git config --global user.email "tu.email@example.com".
+
+
Tip: Si necesitas corregir algún error en el comando, puedes usar la tecla de flecha hacia arriba para recuperar y editar el último comando escrito.
+
¿Cómo confirmar la configuración de Git?
+
Para revisar tu configuración, ejecuta:
+
+
git config --list: Aquí verás los datos de usuario y el nombre de la rama principal.
+
+
Esta configuración se aplicará a todos los repositorios que crees en adelante.
+
¿Qué hacer si olvidas un comando?
+
Git incluye un recurso rápido y útil para recordar la sintaxis de comandos:
+
+
Escribe git help en la terminal.
+
Navega la lista de comandos disponibles y consulta la documentación oficial de cada uno cuando sea necesario.
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/03-Control de Versiones con Git Comandos B\303\241sicos y Flujo de Trabajo.mp4" "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/03-Control de Versiones con Git Comandos B\303\241sicos y Flujo de Trabajo.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..3af9acd6648e95d05c3c73b21d8dbece736a537d
--- /dev/null
+++ "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/03-Control de Versiones con Git Comandos B\303\241sicos y Flujo de Trabajo.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca86e2dbcb7be0d2208149b38168161c444629e6229b92642861f7ca667ec37d
+size 69225670
diff --git "a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/03-Control de Versiones con Git Comandos B\303\241sicos y Flujo de Trabajo.vtt" "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/03-Control de Versiones con Git Comandos B\303\241sicos y Flujo de Trabajo.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..8372d8b4a7db6845b62428af5998719f9562ba3d
--- /dev/null
+++ "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/03-Control de Versiones con Git Comandos B\303\241sicos y Flujo de Trabajo.vtt"
@@ -0,0 +1,831 @@
+WEBVTT
+
+00:00.000 --> 00:03.800
+Ahora que ya hicimos nuestros primeros
+comandos dentro de Git,
+
+00:03.800 --> 00:07.600
+es momento de avanzar para poder empezar a
+generar contenido
+
+00:07.600 --> 00:09.100
+dentro de mi
+proyecto,
+
+00:09.100 --> 00:12.900
+que obviamente sea registrado con este
+control de versiones.
+
+00:12.900 --> 00:14.600
+Te muestro en mi
+pantalla.
+
+00:14.600 --> 00:17.100
+En la clase anterior establecí un
+comando
+
+00:17.100 --> 00:20.900
+que fue el primero que puse, git init.
+
+00:20.900 --> 00:24.800
+Este comando lo que hace dentro de mi
+carpeta
+
+00:24.800 --> 00:27.100
+es crear una carpeta
+oculta.
+
+00:27.100 --> 00:28.800
+Voy a borrar esta
+parte
+
+00:28.800 --> 00:33.200
+y voy a escribir ls-a para poder verla.
+
+00:33.200 --> 00:36.900
+Esa carpeta.git es la
+carpeta
+
+00:36.900 --> 00:41.100
+que va a guardar básicamente un registro
+detallado
+
+00:41.100 --> 00:44.700
+de todos mis cambios realizados dentro de
+mis archivos.
+
+00:44.700 --> 00:46.700
+Es como mi
+bitácora,
+
+00:46.700 --> 00:50.300
+justamente el corazón de este control de
+versiones.
+
+00:50.300 --> 00:56.500
+Para continuar, voy a escribir en mi
+editor de notas de la terminal, nano,
+
+00:56.500 --> 01:01.600
+un nuevo archivo llamado testing.txt.
+
+01:01.600 --> 01:05.600
+Y aquí voy a poner cualquier contenido,
+probando, probando.
+
+01:05.600 --> 01:09.800
+Este contenido es algo que ya se va a
+quedar registrado
+
+01:09.800 --> 01:14.200
+dentro de mi historial de Git, dentro de
+mi control de versiones.
+
+01:14.200 --> 01:16.600
+Guardo los cambios con
+Ctrl-X
+
+01:16.600 --> 01:21.600
+y después la terminal me pide que lo
+confirme con la letra Y de yes.
+
+01:21.600 --> 01:23.600
+Enter y
+listo.
+
+01:23.600 --> 01:26.600
+Ya que estos cambios fueron realizados,
+
+01:26.600 --> 01:31.600
+ahora sí puedo escribir un comando que se
+llame git status.
+
+01:33.300 --> 01:37.300
+Este comando me dice que me encuentro en
+la rama main,
+
+01:37.300 --> 01:40.300
+que aún no he realizado ningún commit,
+
+01:40.300 --> 01:46.300
+pero que hay un archivo recién creado
+llamado testing.txt
+
+01:46.300 --> 01:50.300
+que ya está registrado como que fue creado,
+
+01:50.300 --> 01:53.800
+pero no ha sido agregado en ningún lado.
+
+01:53.800 --> 01:56.800
+Lo que necesito es escribir
+aquí
+
+01:56.800 --> 02:01.800
+git add
+testing.txt
+
+02:01.800 --> 02:03.800
+y presiono
+Enter.
+
+02:03.800 --> 02:07.800
+Ahora, si vuelvo a escribir el comando git
+status,
+
+02:07.800 --> 02:13.800
+me aparece un mensaje diciendo que no hay
+commits realizados,
+
+02:13.800 --> 02:16.800
+pero que los cambios para ser
+realizados
+
+02:16.800 --> 02:19.300
+ya están como un nuevo
+archivo.
+
+02:19.300 --> 02:23.300
+Observa que el cambio de color es el mejor
+indicativo
+
+02:23.300 --> 02:25.800
+de que el archivo ya fue
+creado,
+
+02:25.800 --> 02:29.800
+sin embargo, no ha sido ingresado o comiteado.
+
+02:31.300 --> 02:35.300
+Esto coloca a este archivo en un pequeño
+limbo
+
+02:35.300 --> 02:40.300
+entre que fue creado y que fue ingresado,
+llamado stage.
+
+02:40.300 --> 02:42.300
+En la etapa de
+staging,
+
+02:42.300 --> 02:46.300
+yo soy capaz de poder subir los archivos
+que necesito,
+
+02:46.300 --> 02:51.300
+tanto uno por uno como lo hice con git add
+testing.txt,
+
+02:51.300 --> 02:54.300
+o puedo subirlos a todos de
+golpe.
+
+02:54.300 --> 02:58.300
+De cualquier manera, mientras estén sin un
+commit,
+
+02:58.300 --> 03:02.800
+son archivos que se encuentran en este
+limbo llamado stage,
+
+03:02.800 --> 03:06.300
+es decir, ya fueron creados, pero no han
+estado ingresados.
+
+03:06.300 --> 03:08.800
+Ese es el limbo de
+stage.
+
+03:08.800 --> 03:10.800
+Para poder entenderlo un poco mejor,
+
+03:10.800 --> 03:12.800
+te lo explico en este
+diagrama.
+
+03:12.800 --> 03:15.800
+Dentro de tu proyecto, tú creas un archivo.
+
+03:15.800 --> 03:18.800
+Cuando escribes el comando git
+add,
+
+03:18.800 --> 03:23.300
+este archivo pasa a la etapa de stage.
+
+03:23.300 --> 03:26.300
+Se queda ahí, en un limbo,
+volando.
+
+03:26.300 --> 03:29.300
+Ya que yo estoy en la etapa de stage,
+
+03:29.300 --> 03:31.300
+pueden suceder dos
+cosas.
+
+03:31.300 --> 03:34.300
+Podría regresarlo como un archivo normal,
+
+03:34.300 --> 03:37.800
+pero también, gracias al comando git commit,
+
+03:37.800 --> 03:40.800
+lo podría ingresar a mi control de versiones.
+
+03:40.800 --> 03:42.800
+Cualquiera de estas dos
+opciones
+
+03:42.800 --> 03:47.300
+son la razón por la cual existe esta etapa
+de stage.
+
+03:47.300 --> 03:52.300
+Para permitirme decidir qué archivos sí y
+qué archivos no,
+
+03:52.300 --> 03:55.300
+quiero que se guarden dentro de mi control
+de versiones.
+
+03:55.300 --> 03:57.800
+Es decir, en un flujo más
+común,
+
+03:57.800 --> 03:59.800
+cuando tú creas este
+archivo,
+
+03:59.800 --> 04:02.800
+lo pasas con git add a
+stage.
+
+04:02.800 --> 04:04.800
+Y ya que está en git
+stage,
+
+04:04.800 --> 04:08.300
+puedes utilizar un comando que vamos a
+mostrar a continuación
+
+04:08.300 --> 04:11.300
+para regresarlo como archivo
+ordinario
+
+04:11.300 --> 04:13.300
+por ponerle alguna
+palabra.
+
+04:13.300 --> 04:16.800
+Si no lo has regresado a ese archivo
+ordinario
+
+04:16.800 --> 04:18.800
+y sigue en
+stage,
+
+04:18.800 --> 04:21.800
+solo basta que selecciones un git
+commit
+
+04:21.800 --> 04:24.800
+para llevarlo hacia tu control de versiones.
+
+04:24.800 --> 04:27.800
+Es esto lo que vamos a hacer a continuación.
+
+04:27.800 --> 04:32.800
+Por ejemplo, ya ingresé dentro de la etapa
+de stage a Testing,
+
+04:32.800 --> 04:34.800
+por eso cambio de
+color.
+
+04:34.800 --> 04:36.800
+Si limpio mi
+terminal
+
+04:37.300 --> 04:40.800
+y escribo git
+rm,
+
+04:40.800 --> 04:43.800
+--caché,
+
+04:43.800 --> 04:47.800
+que es la forma en la que lo saco de stage,
+
+04:47.800 --> 04:50.300
+presiono el nombre del
+archivo,
+
+04:50.300 --> 04:52.800
+testing.txt.
+
+04:52.800 --> 04:54.800
+Con
+Enter,
+
+04:54.800 --> 04:59.800
+me aparece una leyenda diciendo rm testing.
+txt.
+
+04:59.800 --> 05:03.800
+Ahora escribo git
+status
+
+05:03.800 --> 05:06.800
+y ese archivo regresó al modo
+rojo.
+
+05:06.800 --> 05:08.800
+Es decir, un archivo
+original
+
+05:08.800 --> 05:11.300
+que no ha tenido ningún
+trabajo
+
+05:11.300 --> 05:13.800
+ni se ha involucrado con
+git.
+
+05:13.800 --> 05:17.300
+De nuevo, puedo escribir el comando git
+add
+
+05:17.300 --> 05:20.300
+y el nombre de
+testing.txt
+
+05:20.300 --> 05:24.800
+o solo presionar un punto, git add punto,
+
+05:24.800 --> 05:26.800
+para ingresar no solo
+este,
+
+05:26.800 --> 05:30.300
+sino los 25 archivos que podría tener ya
+generados.
+
+05:30.300 --> 05:34.300
+Es decir, git add punto ingresa todos los
+archivos
+
+05:34.300 --> 05:37.300
+que no han sido ingresados al área de stage,
+
+05:37.300 --> 05:38.800
+a esa
+área.
+
+05:38.800 --> 05:42.800
+Presiono Enter y de nuevo, git status.
+
+05:43.800 --> 05:46.300
+Aquí puedo estar
+pivoteando
+
+05:46.300 --> 05:48.800
+cuantas veces mi proyecto lo necesite,
+
+05:48.800 --> 05:50.800
+regresando los archivos
+originales,
+
+05:50.800 --> 05:52.800
+poniéndolos en
+stage
+
+05:52.800 --> 05:55.300
+o ya mandándolos a un
+commit.
+
+05:55.300 --> 06:00.300
+Esto sería git commit -m.
+
+06:00.300 --> 06:03.300
+El parámetro m es de
+mensaje.
+
+06:03.300 --> 06:05.300
+A cada uno de mis
+commits
+
+06:05.300 --> 06:07.300
+les tengo que poner un
+mensaje
+
+06:07.300 --> 06:09.300
+que indique qué fue lo que
+hice.
+
+06:09.300 --> 06:11.300
+Puedo poner, entre
+comillas,
+
+06:11.300 --> 06:14.300
+nuevo archivo de
+testing.
+
+06:14.300 --> 06:16.300
+Cierro las comillas y
+Enter.
+
+06:16.300 --> 06:20.300
+Aquí aparece la respuesta de que main,
+
+06:20.300 --> 06:22.300
+que es la rama con la que estuve trabajando,
+
+06:22.300 --> 06:24.300
+ahora tiene este
+commit,
+
+06:24.300 --> 06:26.300
+nuevo archivo de
+testing.
+
+06:26.300 --> 06:30.300
+Me da también el resultado de este commit.
+
+06:30.300 --> 06:32.300
+Ha sido un archivo
+cambiado
+
+06:32.300 --> 06:34.300
+y se le ha agregado una
+inserción
+
+06:34.300 --> 06:37.300
+porque solo escribí una línea de código.
+
+06:37.300 --> 06:39.300
+Esto ya está
+listo
+
+06:39.300 --> 06:42.300
+y entonces puedo primero limpiar mi terminal.
+
+06:42.300 --> 06:45.300
+Voy a crear un segundo
+archivo.
+
+06:45.300 --> 06:52.300
+nano
+testings2.txt
+
+06:52.300 --> 06:55.300
+y voy a poner probando
+2.
+
+06:56.300 --> 06:58.300
+Luego otra vez para
+que
+
+06:58.300 --> 07:00.300
+esté igual que el
+original.
+
+07:00.300 --> 07:04.300
+Control-X de nuevo, Y y
+Enter.
+
+07:04.300 --> 07:06.300
+Si presiono el comando
+L-S,
+
+07:06.300 --> 07:09.300
+ahí están, testing y
+testing2.
+
+07:09.300 --> 07:11.300
+Sin embargo, gracias a que ya
+hice
+
+07:11.300 --> 07:14.300
+mi primer commit, en git
+status
+
+07:14.300 --> 07:18.300
+solo aparece
+testing2.
+
+07:18.300 --> 07:20.300
+Es decir, los cambios
+realizados
+
+07:20.300 --> 07:23.300
+son como una especie de punto y aparte.
+
+07:23.300 --> 07:25.300
+Gracias a que ya hay un
+commit
+
+07:25.300 --> 07:27.300
+que trabajó con
+testing,
+
+07:27.300 --> 07:31.300
+ahora solo a git le interesa
+testing2
+
+07:31.300 --> 07:33.300
+que no está
+registrado.
+
+07:33.300 --> 07:37.300
+Lo voy a mandar a stage con git add
+punto
+
+07:37.300 --> 07:39.300
+y después de eso puedo ver de
+nuevo
+
+07:39.300 --> 07:41.300
+en mi git
+status
+
+07:41.300 --> 07:44.300
+que este nuevo archivo ya está en stage.
+
+07:44.300 --> 07:46.300
+De nuevo, lo único que hace
+falta
+
+07:46.300 --> 07:50.300
+es git
+commit-m
+
+07:50.300 --> 07:53.300
+y voy a poner segundo archivo creado.
+
+07:53.300 --> 07:55.300
+Presiono
+Enter.
+
+07:55.300 --> 07:59.300
+Y ahora ya tengo todo este cambio registrado.
+
+07:59.300 --> 08:02.300
+Es decir, primero limpio mi terminal.
+
+08:02.300 --> 08:06.300
+Después pongo git
+status.
+
+08:06.300 --> 08:09.300
+Me aparece que no hay
+nada.
+
+08:09.300 --> 08:11.300
+Mi árbol de trabajo está
+limpio.
+
+08:11.300 --> 08:13.300
+Y la mejor manera de
+saber
+
+08:13.300 --> 08:15.300
+que todo esto está sucediendo
+bien
+
+08:15.300 --> 08:18.300
+es con un git
+log.
+
+08:18.300 --> 08:20.300
+Aquí aparece el bitácora
+
+08:20.300 --> 08:23.300
+de los cambios que he ido
+haciendo.
+
+08:23.300 --> 08:25.300
+Para concluir, lo que necesito
+hacer
+
+08:25.300 --> 08:27.300
+es primero limpiar mi
+terminal
+
+08:27.300 --> 08:30.300
+y después actualizar este nuevo archivo,
+
+08:30.300 --> 08:32.300
+porque hasta ahora solo los he
+creado
+
+08:32.300 --> 08:34.300
+y les he puesto
+contenido.
+
+08:34.300 --> 08:36.300
+Pero también, si los
+actualizó,
+
+08:36.300 --> 08:38.300
+la verdad es que el
+proceso
+
+08:38.300 --> 08:40.300
+tiene que ser el
+mismo.
+
+08:40.300 --> 08:45.300
+Es decir, voy a escribir nano testing.
+txt
+
+08:45.300 --> 08:48.300
+y aquí está probando,
+probando.
+
+08:48.300 --> 08:52.300
+Desde un nuevo
+commit.
+
+08:52.300 --> 08:54.300
+Ya actualicé este archivo de
+texto.
+
+08:54.300 --> 08:56.300
+Ya hay nuevo
+contenido.
+
+08:56.300 --> 09:00.300
+Control X, Y,
+Enter.
+
+09:00.300 --> 09:03.300
+Ahora, con un git
+status,
+
+09:03.300 --> 09:07.300
+voy a ver que no aparece como creado.
+
+09:07.300 --> 09:11.300
+Ahora la leyenda que me aparece es modificado.
+
+09:11.300 --> 09:14.300
+Esencialmente, el proceso es el mismo.
+
+09:14.300 --> 09:17.300
+Lo único que cambia es esa ligera
+palabra
+
+09:17.300 --> 09:21.300
+que puede ser creado, modificado o eliminado.
+
+09:21.300 --> 09:23.300
+Aquí, con git
+status,
+
+09:23.300 --> 09:26.300
+escribo git add,
+punto,
+
+09:26.300 --> 09:29.300
+y git
+commit,
+
+09:29.300 --> 09:31.300
+diciendo en mi
+mensaje,
+
+09:31.300 --> 09:34.300
+primer archivo
+modificado.
+
+09:34.300 --> 09:36.300
+Enter.
+
+09:36.300 --> 09:37.300
+Ya
+está.
+
+09:37.300 --> 09:39.300
+Quedo
+listo.
+
+09:39.300 --> 09:41.300
+Limpio mi
+terminal,
+
+09:41.300 --> 09:44.300
+presiono git
+status
+
+09:44.300 --> 09:47.300
+y me da de cuenta que ya no hay
+cambios
+
+09:47.300 --> 09:49.300
+que deba de
+registrar.
+
+09:49.300 --> 09:52.300
+Listo, ya terminaste con tu primer commit.
+
+09:52.300 --> 09:54.300
+Es momento de recapitular un
+poco
+
+09:54.300 --> 09:56.300
+haciendo una breve
+pausa.
+
+09:56.300 --> 09:58.300
+Lo que acabas de hacer es crear un archivo,
+
+09:58.300 --> 10:02.300
+pasarlo gracias a git add al área de
+staging
+
+10:02.300 --> 10:05.300
+y ya que esté ahí, hacer con el
+commit
+
+10:05.300 --> 10:08.300
+el ingreso de ese archivo y su
+contenido
+
+10:08.300 --> 10:10.300
+a tu control de
+versiones.
+
+10:10.300 --> 10:14.300
+Esto es lo que termina un proceso de commit.
+
+10:14.300 --> 10:16.300
+Que git sepa y
+registre
+
+10:16.300 --> 10:19.300
+los cambios que has
+realizado.
+
+10:19.300 --> 10:21.300
+Ahora, yo hice todos estos
+cambios
+
+10:21.300 --> 10:25.300
+con un archivo.txt de manera ilustrativa.
+
+10:25.300 --> 10:28.300
+No importa si estos archivos son archivos
+de texto
+
+10:28.300 --> 10:30.300
+como los que yo
+utilicé
+
+10:30.300 --> 10:32.300
+o archivos de cualquier
+tipo.
+
+10:32.300 --> 10:35.300
+Pueden ser archivos de lenguajes de
+programación
+
+10:35.300 --> 10:38.300
+con extensiones PHP, Go,
+JS
+
+10:38.300 --> 10:40.300
+o cualquiera de todos
+ellos.
+
+10:40.300 --> 10:42.300
+Pueden ser incluso
+imágenes
+
+10:42.300 --> 10:44.300
+o cualquier tipo de
+archivos.
+
+10:44.300 --> 10:48.300
+El chiste es que cuando tú haces un git
+add
+
+10:48.300 --> 10:50.300
+todos estos archivos se
+manejan
+
+10:50.300 --> 10:53.300
+de manera exactamente
+igual.
+
+10:53.300 --> 10:55.300
+Y cuando los haces un
+commit
+
+10:55.300 --> 10:57.300
+también se registran en la base de
+git
+
+10:57.300 --> 11:02.000
+de la misma forma,
+no importando sus extensiones.
\ No newline at end of file
diff --git a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/03-Lecturas recomendadas.txt b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/03-Lecturas recomendadas.txt
new file mode 100644
index 0000000000000000000000000000000000000000..be0eb129c4185644bd86a08b141b4c8ef2c26b22
--- /dev/null
+++ b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/03-Lecturas recomendadas.txt
@@ -0,0 +1,4 @@
+https://git-scm.com/docs/git-add
+https://git-scm.com/docs/git-commit
+https://git-scm.com/docs/git-log
+https://docs.github.com/es/get-started/start-your-journey
diff --git a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/03-Resumen.html b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/03-Resumen.html
new file mode 100644
index 0000000000000000000000000000000000000000..c6a5cab4a82caeaf042150e8571359d7175bdc4b
--- /dev/null
+++ b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/03-Resumen.html
@@ -0,0 +1,127 @@
+
+
+
+
+
+
+ Control de Versiones con Git: Comandos Básicos y Flujo de Trabajo
+
+
+
+
+
+
Resumen
Aprender a utilizar Git desde los primeros pasos puede parecer desafiante, pero es esencial para registrar cambios y manejar versiones de cualquier proyecto. Siguiendo un flujo de trabajo sencillo y utilizando los comandos adecuados, puedes dominar el control de versiones y llevar un seguimiento preciso de tus archivos.
+
¿Cómo inicia el control de versiones con Git?
+
El primer paso es iniciar un repositorio con el comando git init, que crea una carpeta oculta llamada .git en el directorio de trabajo. Esta carpeta actúa como una bitácora, almacenando cada cambio y movimiento de los archivos que se manejan en el proyecto.
+
¿Cómo se crean y agregan archivos a Git?
+
Para crear un archivo desde la terminal, utiliza un editor como nano. Una vez creado, puedes verificar su existencia y estado con git status, que te mostrará el archivo como no registrado. Para incluirlo en el área de staging, donde estará listo para el commit, usa git add nombre_del_archivo.txt. Esta área de staging es un “limbo” donde decides qué archivos entrarán en el control de versiones.
+
+
Ejemplo de comandos:
+
+
nano testing.txt para crear el archivo.
+
git add testing.txt para agregarlo al área de staging.
+
+
+
+
¿Qué es el área de staging y cómo funciona?
+
El área de staging permite revisar los cambios antes de que se registren oficialmente en el repositorio. Los archivos en staging aún no forman parte del historial de versiones; están en espera de que se realice un commit o de ser devueltos a su estado original con git rm --cached nombre_del_archivo.txt.
+
¿Cómo realizar el commit de los archivos en Git?
+
Una vez en staging, se ejecuta git commit -m "mensaje descriptivo" para registrar los cambios en el repositorio. El mensaje en el commit es crucial porque indica la acción realizada, como “nuevo archivo de testing”. Este mensaje permite identificar los cambios de forma clara y ordenada en el historial del proyecto.
+
+
Ejemplo de commit:
+
+
git commit -m "nuevo archivo de testing"
+
+
+
+
¿Cómo gestionar múltiples archivos en Git?
+
Para trabajar con varios archivos a la vez, utiliza git add . que agrega todos los archivos sin registrar en el área de staging. Puedes decidir entre realizar commits individuales o múltiples en función de la cantidad de archivos y los cambios realizados en cada uno.
+
¿Cómo visualizar el historial de cambios en Git?
+
El comando git log muestra el historial de commits, proporcionando una vista completa de cada cambio realizado en el proyecto. Esta bitácora permite ver el estado de cada archivo y la información de cada commit.
+
¿Qué sucede al modificar un archivo en Git?
+
Cuando un archivo se edita, Git lo detecta como “modificado”. El flujo de trabajo para registrar este cambio es el mismo que para un archivo nuevo: git add para llevarlo a staging y git commit para guardar la modificación. Esto asegura que Git mantenga un registro detallado de cada cambio, actualización o eliminación en el proyecto.
+
¿Cómo maneja Git diferentes tipos de archivos?
+
Git trata cualquier archivo de igual manera, sin importar su extensión o tipo, ya sea de texto, código o imagen. Con git add y git commit, cualquier cambio en estos archivos se registra, facilitando el control de versiones sin importar el tipo de contenido.
+
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/04-Gesti\303\263n de ramas en Git creaci\303\263n fusi\303\263n y eliminaci\303\263n eficiente.mp4" "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/04-Gesti\303\263n de ramas en Git creaci\303\263n fusi\303\263n y eliminaci\303\263n eficiente.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..9d1a9516d0a54a3cf937e419ba53310ebe6f36f4
--- /dev/null
+++ "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/04-Gesti\303\263n de ramas en Git creaci\303\263n fusi\303\263n y eliminaci\303\263n eficiente.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70462a3975de4de1ace23cd999288b6c08785919bba3fba03424496e841247c7
+size 51098214
diff --git "a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/04-Gesti\303\263n de ramas en Git creaci\303\263n fusi\303\263n y eliminaci\303\263n eficiente.vtt" "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/04-Gesti\303\263n de ramas en Git creaci\303\263n fusi\303\263n y eliminaci\303\263n eficiente.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..3243701896c4fd0481ad5b291d2cb2c4f5bcf0cf
--- /dev/null
+++ "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/04-Gesti\303\263n de ramas en Git creaci\303\263n fusi\303\263n y eliminaci\303\263n eficiente.vtt"
@@ -0,0 +1,313 @@
+WEBVTT
+
+00:00.000 --> 00:05.760
+El concepto de ramas se inventó para que
+nosotros podamos trabajar de manera aislada
+
+00:05.760 --> 00:10.680
+y sin obstaculizar a todos los demás con
+nuestro trabajo.
+
+00:10.680 --> 00:16.320
+Esto puede derivar en grandes ventajas
+para ti, porque si tú no te sientes cómodo, simplemente,
+
+00:16.320 --> 00:22.880
+bueno, eliminas tu rama, vuelves a empezar
+con el trabajo que tienes pendiente y lo unificas.
+
+00:22.880 --> 00:27.940
+Cada una de todas las actividades que
+hagas dentro de tu proyecto puede ser generada dentro
+
+00:27.940 --> 00:31.520
+de una o, naturalmente, muchas ramas.
+
+00:31.520 --> 00:35.760
+Vamos a conocer este concepto de una forma
+mucho más práctica para que sea más fácil
+
+00:35.760 --> 00:37.320
+entenderlo.
+
+00:37.320 --> 00:42.360
+Moviéndome a mi terminal, lo primero que
+voy a hacer es escribir el comando de git
+
+00:42.360 --> 00:44.960
+branch para saber en qué rama me encuentro.
+
+00:44.960 --> 00:50.640
+Ahora, naturalmente, estoy ubicado dentro
+de la rama main y, de hecho, hay un pequeño
+
+00:50.640 --> 00:54.080
+asterisco indicando que me encuentro en
+esta rama.
+
+00:54.080 --> 00:58.840
+Naturalmente, conforme mis ramas crezcan,
+voy a poder tener aquí toda la lista.
+
+00:58.840 --> 01:05.120
+Sin embargo, lo que me importa es que el
+asterisco va a ser el indicador o la seña exacta de
+
+01:05.120 --> 01:08.240
+saber en qué rama me encuentro en este
+momento.
+
+01:08.240 --> 01:11.240
+Lo primero que yo necesito es crear una
+nueva rama.
+
+01:11.240 --> 01:20.080
+Voy a escribir git checkout-m-b de branch
+y voy a escribir a min.
+
+01:20.080 --> 01:27.960
+Ahora, ya que git me indicó que me moví a
+una nueva rama llamada a min, puedo escribir
+
+01:27.960 --> 01:35.280
+git branch y escribo nada más el comando
+para ver que el asterisco ahora está apuntando
+
+01:35.280 --> 01:40.920
+a a min y main está enlistada, pero no es
+la rama en la que me encuentro.
+
+01:40.920 --> 01:46.240
+Dentro de esta nueva rama, voy a utilizar
+de nuevo mi editor de texto nano para crear
+
+01:46.240 --> 01:47.240
+testing-a-min.txt.
+
+01:47.240 --> 02:00.840
+Y en este editor voy a tener archivo
+creado desde mi nueva rama.
+
+02:00.840 --> 02:09.280
+Guardo los cambios y ahora puedo ver
+dentro del comando ls que está aquí, testing-a-min
+
+02:09.280 --> 02:10.280
+ya
+creado.
+
+02:10.280 --> 02:17.360
+Con este nuevo cambio, lo que puedo hacer
+es escribir git status para darme cuenta que
+
+02:17.360 --> 02:21.320
+esta notificación me está indicando lo que
+ya sé.
+
+02:21.320 --> 02:26.200
+Hice un nuevo archivo, pero este nuevo
+archivo no ha sido ingresado dentro de mi historial
+
+02:26.200 --> 02:32.720
+de commits, así que escribiré git add
+espacio punto para tenerlo ya guardado.
+
+02:32.720 --> 02:42.960
+Después escribo git commit con un nuevo
+mensaje que diga nuevo archivo creado.
+
+02:42.960 --> 02:48.880
+Guardo los cambios y estos cambios fueron
+creados actualmente dentro de mi rama de a
+
+02:48.880 --> 02:52.240
+min, no dentro de la rama de
+main.
+
+02:52.240 --> 02:58.600
+Esto significa que nadie puede ver dentro
+de la rama de main lo que yo acabo de hacer.
+
+02:58.600 --> 03:03.760
+Una vez que ya tienes todos los cambios
+que tú deseas dentro de tu rama local o individual,
+
+03:03.760 --> 03:09.800
+como quieras llamarla, es momento de
+fusionar todos estos cambios dentro de la rama principal.
+
+03:09.800 --> 03:14.400
+Esto quiere decir que todo lo que tú has
+estado trabajando ahora debe de irse a la
+
+03:14.400 --> 03:19.660
+rama principal para que no solo tú, sino
+que todo tu equipo tenga la posibilidad de
+
+03:19.660 --> 03:22.560
+acceder a estos nuevos
+cambios.
+
+03:22.560 --> 03:28.560
+Para ello, es momento de fusionar la rama
+a min con la rama main para que así todo
+
+03:28.560 --> 03:31.540
+se unifique en una sola
+rama.
+
+03:31.540 --> 03:37.880
+Lo ideal es que cuando tú quieras hacer
+esto y te sientas listo, utilices el comando merge.
+
+03:37.880 --> 03:43.720
+De esta manera vas a dejar main como la
+rama principal, pero con el contenido actualizado
+
+03:43.720 --> 03:45.800
+de tu rama
+individual.
+
+03:45.800 --> 03:54.120
+Voy a escribir ahora el comando git
+checkout main, que significa la manera de volver a
+
+03:54.120 --> 03:55.920
+mi rama
+principal.
+
+03:55.920 --> 04:02.080
+Un tip, si eres una persona arraigada a
+las costumbres, es probable que utilices git checkout
+
+04:02.080 --> 04:03.080
+main.
+
+04:03.080 --> 04:09.800
+Sin embargo, también existe el comando que
+ahora tiene mayor adopción, git switch a
+
+04:09.800 --> 04:10.800
+min.
+
+04:10.800 --> 04:16.600
+Es decir, puedes cambiar con el comando
+git checkout o git switch, cualquiera de los dos
+
+04:16.600 --> 04:18.840
+hacen exactamente lo
+mismo.
+
+04:18.840 --> 04:23.280
+Vamos a utilizar git switch para regresar
+a min.
+
+04:23.280 --> 04:30.200
+De nuevo, ya que yo estoy en esta rama
+principal, es momento de cambiar o actualizar los cambios
+
+04:30.200 --> 04:32.600
+de a min para
+acá.
+
+04:32.600 --> 04:38.080
+Lo único que necesito es escribir git
+merge a min para que mi terminal me notifique de
+
+04:38.080 --> 04:40.460
+esta unificación de
+ramas.
+
+04:40.460 --> 04:45.320
+El resultado de la terminal es que me está
+diciendo que gracias a un fast forward, que
+
+04:45.320 --> 04:52.080
+es un método de unificación, testing a min,
+junto con una línea de código actualizada,
+
+04:52.080 --> 04:57.240
+ha sido agregado un cambio en los archivos
+y una nueva inserción.
+
+04:57.240 --> 05:06.560
+Ahora, si yo dentro de mi rama, para
+confirmar, git branch main, puedo escribir ls, ya puedo
+
+05:06.560 --> 05:12.840
+ver testing a min como el documento que
+está unificado dentro de mi rama principal.
+
+05:12.840 --> 05:19.040
+Lo que a continuación sigue es escribir
+git log para confirmar que en mi historial de
+
+05:19.040 --> 05:23.040
+actividades está la parte de nuevo archivo
+creado.
+
+05:23.040 --> 05:29.920
+Obviamente, yo fui el autor y fue
+insertada como la última modificación dentro de mi
+
+05:29.920 --> 05:31.600
+historial de
+commits.
+
+05:31.600 --> 05:38.120
+Ahora, lo que es importante y muy buena
+práctica es que puedo limpiar mi terminal para poder
+
+05:38.120 --> 05:40.040
+tener un poco más de
+espacio.
+
+05:40.040 --> 05:47.040
+Y ya que yo unifiqué mi rama individual
+con la rama principal, el propósito de la rama
+
+05:47.040 --> 05:50.640
+individual ya dejó de tener sentido.
+
+05:50.640 --> 05:56.660
+Quiere decir que yo ya no necesito tener
+esa rama dentro de mi equipo.
+
+05:56.660 --> 06:05.360
+Para poder deshacerme de ella, voy a
+escribir git branch, j, D mayúscula, a min.
+
+06:05.360 --> 06:09.960
+Y aquí git me está diciendo que ya se
+eliminó esta rama.
+
+06:09.960 --> 06:11.520
+¿Por qué tengo que hacer
+esto?
+
+06:11.520 --> 06:16.920
+Es altamente probable que yo quiera
+utilizar esta rama para otro propósito en una nueva
+
+06:16.920 --> 06:17.920
+tarea.
+
+06:17.920 --> 06:24.960
+De esta forma, no me estoy poniendo yo
+solo el pie de tener ramas como a min, a min 1,
+
+06:24.960 --> 06:28.240
+2, 3 o cosas que puedan causar un conflicto.
+
+06:28.240 --> 06:35.780
+Lo ideal es que la rama existe para un
+propósito y una vez que ese propósito se cumplió, entonces
+
+06:35.780 --> 06:41.260
+es momento de eliminarla para no tener
+ningún problema y tampoco ningún conflicto con las
+
+06:41.260 --> 06:56.260
+ramas
+anteriores.
+
diff --git a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/04-Lecturas recomendadas.txt b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/04-Lecturas recomendadas.txt
new file mode 100644
index 0000000000000000000000000000000000000000..69dd321660a5fd7597b27f7294a8998f641f09c0
--- /dev/null
+++ b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/04-Lecturas recomendadas.txt
@@ -0,0 +1,4 @@
+https://git-scm.com/docs/git-branch
+https://git-scm.com/docs/git-merge
+https://git-scm.com/docs/git-switch
+https://git-scm.com/docs/git-checkout
diff --git a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/04-Resumen.html b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/04-Resumen.html
new file mode 100644
index 0000000000000000000000000000000000000000..4f5551f62952eea7f882096a2bca57e51e978261
--- /dev/null
+++ b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/04-Resumen.html
@@ -0,0 +1,141 @@
+
+
+
+
+
+
+ Gestión de ramas en Git: creación, fusión y eliminación eficiente
+
+
+
+
+
+
Resumen
El uso de ramas en Git permite trabajar en un entorno aislado sin interferir con otros, facilitando la organización y el control del proyecto. Aprender a crear, gestionar y fusionar ramas optimiza la colaboración y ayuda a mantener la limpieza en el historial de cambios.
+
¿Por qué son útiles las ramas en Git?
+
Las ramas son una herramienta que permite trabajar en tareas específicas sin alterar la rama principal. Entre sus ventajas se encuentran:
+
+
Aislamiento de cambios individuales.
+
Posibilidad de desechar una rama sin afectar la principal.
+
Organización de actividades múltiples en diferentes ramas.
+
+
¿Cómo verificar la rama actual?
+
Para saber en qué rama estás trabajando, ejecuta:
+
git branch
+
+
El asterisco (*) indica la rama activa. Inicialmente, suele ser main, pero al crear más ramas, la lista crecerá, permitiéndote ver todas las disponibles y cuál es la actual.
+
¿Cómo crear una nueva rama en Git?
+
La creación de ramas permite desarrollar sin riesgo en paralelo. Para crear y moverte a una nueva rama, usa:
+
git checkout -b
+
+
Por ejemplo, git checkout -b Amin crea y mueve a la rama Amin. Puedes verificar que estás en esta rama ejecutando git branch.
+
¿Cómo agregar y confirmar cambios en una rama?
+
Dentro de una nueva rama, los archivos se editan y confirman sin que impacten otras ramas. Sigue estos pasos para agregar y confirmar:
+
+
Crea o edita un archivo.
+
Añádelo con:
git add .
+
+
+
Confirma el cambio:
git commit -m "mensaje de confirmación"
+
+
+
+
Los cambios ahora son parte de la rama en la que trabajas y no afectan la principal.
+
¿Cómo fusionar cambios de una rama secundaria a la principal?
+
Para unificar el trabajo en la rama principal:
+
+
Cambia a la rama principal:
git switch main
+
+Nota: Puedes usar también git checkout main.
+
Fusiona la rama secundaria:
git merge
+
+
+
+
Git indicará que el proceso fue exitoso y actualizará el contenido en la rama main con los cambios de la rama secundaria.
+
¿Por qué es importante eliminar ramas que ya no se usan?
+
Una vez fusionada una rama, es buena práctica eliminarla para evitar desorden. Hazlo con:
+
git branch -d
+
+
Eliminar ramas que ya cumplieron su propósito previene conflictos y mantiene el entorno de trabajo limpio y organizado.
+
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/05-Git Reset vs Git Revert Manejo de Historial y Correcci\303\263n de Errores.mp4" "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/05-Git Reset vs Git Revert Manejo de Historial y Correcci\303\263n de Errores.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..db815a3d09cc066607021d5d6450265caea6d2e3
--- /dev/null
+++ "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/05-Git Reset vs Git Revert Manejo de Historial y Correcci\303\263n de Errores.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:525e41977ac6e934fa36bd72651f42dd612b5b85f77c372f51204ecf394389b4
+size 112515730
diff --git "a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/05-Git Reset vs Git Revert Manejo de Historial y Correcci\303\263n de Errores.vtt" "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/05-Git Reset vs Git Revert Manejo de Historial y Correcci\303\263n de Errores.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..29800f0e75bb466f43c4099bd89b840c4fca0be9
--- /dev/null
+++ "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/05-Git Reset vs Git Revert Manejo de Historial y Correcci\303\263n de Errores.vtt"
@@ -0,0 +1,377 @@
+WEBVTT
+
+00:00.000 --> 00:04.660
+Es momento de hablar de dos comandos que,
+con nuestra falta de experiencia,
+
+00:04.660 --> 00:10.560
+son sumamente útiles. Quizá con el paso
+del tiempo los vamos olvidando y dejando de lado.
+
+00:10.560 --> 00:16.200
+Sin embargo, nos van a salvar el trabajo
+más de una vez en el momento en que estamos aprendiendo
+
+00:16.200 --> 00:21.640
+con Git. Son comandos a los que yo les
+tengo bastante cariño porque me sacaron de varias
+
+00:21.640 --> 00:26.840
+situaciones cuando comenzaba a trabajar
+con un control de versiones. Así que es momento de
+
+00:26.840 --> 00:34.280
+hablar de Git Reset y Git Revert. Vamos a
+ver primero cuál es la diferencia entre ambos comandos
+
+00:34.280 --> 00:40.400
+y después veremos cómo los podemos
+utilizar de manera especializada en cada una de las situaciones.
+
+00:40.400 --> 00:48.000
+En el caso de Git Reset, se trata de un
+comando que me va a permitir establecer el puntero de
+
+00:48.000 --> 00:54.640
+mis commits en un commit anterior,
+significando que podría regresar en el tiempo o explorar de
+
+00:54.640 --> 01:00.320
+esta manera el historial de mis commits.
+No solamente me sirve para revertir algunos cambios,
+
+01:00.320 --> 01:06.240
+sino que también me sirve para, a lo mejor,
+recordar qué fue lo que estuve haciendo en cada
+
+01:06.240 --> 01:12.040
+uno de estos commits. Es bastante útil
+para que las personas que tienen tan mala memoria como yo
+
+01:12.040 --> 01:18.200
+podamos explorar qué fue lo que hicimos en
+los commits anteriores. Es decir, puedo regresar a
+
+01:18.200 --> 01:23.680
+un commit anterior, ponerlo como el
+puntero de los commits, ver los cambios en los archivos y
+
+01:23.680 --> 01:31.000
+regresar al último commit hecho. Es decir,
+Git Reset no solo me permite revertir ciertos cambios,
+
+01:31.000 --> 01:38.240
+sino que también explorar el historial de
+mis commits sin ningún problema. En el caso de Git
+
+01:38.240 --> 01:45.760
+Revert, este comando sí, es mucho más
+acotado a saber qué es lo que va a hacer. Por medio de un
+
+01:45.760 --> 01:54.800
+nuevo commit, va a tener la capacidad de
+llevarme a un commit anterior. Es decir, va a ser un tapón
+
+01:54.800 --> 02:01.320
+que me permita brincar los commits
+realizados para regresar a uno y colocarlo como el último
+
+02:01.320 --> 02:08.880
+commit realizado. Voy a arrancar desde mi
+terminal y escribiré el comando git log. Dentro del comando
+
+02:08.880 --> 02:14.440
+de git log, naturalmente ya puedo ver el
+historial de mis commits. Sin embargo, debo de fijarme ahora
+
+02:14.440 --> 02:21.440
+en un detalle muy importante. Aquí hay un
+paréntesis que dice, head una flecha apuntando a main,
+
+02:21.440 --> 02:28.520
+indicando que este es el último commit
+realizado, pero también es el puntero de todos los que he
+
+02:28.520 --> 02:34.840
+hecho. Es decir, cuando yo actualizo con
+un nuevo commit, este puntero se va a colocar en ese último
+
+02:34.840 --> 02:40.960
+commit. Es muy importante de tenerlo
+presente porque gracias a Git Revert y Reset, yo puedo
+
+02:40.960 --> 02:47.320
+alterar esta funcionalidad. Lo primero que
+yo voy a hacer aquí es crear un archivo que se llame con
+
+02:47.320 --> 02:56.000
+mi editor nano error.txt, que es el
+archivo que no voy a querer en un futuro incorporar o que
+
+02:56.000 --> 03:07.480
+simplemente voy a querer deshacer. Este es
+mi archivo de error. Guardo los cambios y con mi
+
+03:07.480 --> 03:16.640
+terminal ya mostrándose, voy a poner clear
+y aquí pongo ls, dándome cuenta que junto a los tres
+
+03:16.640 --> 03:24.840
+archivos anteriores, ahora tengo error.txt.
+Naturalmente, yo que todavía no sé que este
+
+03:24.840 --> 03:32.600
+es un archivo que va a causar un conflicto,
+voy a subir mis cambios. git add, git commit,
+
+03:32.600 --> 03:41.040
+con el mensaje nuevo archivo especial,
+vamos a ponerle alguna diferencia, creado.
+
+03:43.040 --> 03:51.720
+Mis cambios fueron reflejados. Si yo
+escribo git log, puedo confirmarlo. Nuevo archivo especial
+
+03:51.720 --> 03:58.760
+creado. Aquí es en donde comienza a tomar
+mucha relevancia el tipo de mensaje que pongas en tu
+
+03:58.760 --> 04:05.200
+commit, porque es muy fácil, gracias a
+estos mensajes, saber qué fue lo que hiciste en cada
+
+04:05.200 --> 04:15.280
+una de tus actividades. Limpio mi terminal
+y ahora que ya sé que yo subí estos cambios y que alguien
+
+04:15.280 --> 04:22.960
+me notificó que esto no es necesario,
+entonces dentro de git log voy a ver que nuevo archivo
+
+04:22.960 --> 04:30.240
+especial creado debería de ser el cambio
+que voy a revertir. Nota que enfrente de cada leyenda de
+
+04:30.240 --> 04:38.680
+commit hay un identificador. Este se
+conoce como el hash de ese commit. El identificador del commit
+
+04:38.680 --> 04:45.480
+que yo quiero eliminar es este. Copio su
+identificador y como sé que yo quiero revertir
+
+04:45.480 --> 04:56.960
+estos cambios y regresar a esto, es el que
+necesito para poder trabajar. Escribo git revert
+
+04:56.960 --> 05:04.840
+y el identificador de estos cambios.
+Me aparece un blog de notas indicándome que hay un mensaje
+
+05:04.840 --> 05:12.720
+que dice revert nuevo cambio especial
+creado y lo ideal por camaradería con mi equipo es
+
+05:12.720 --> 05:19.560
+escribir por Amin, es decir, asumir la
+responsabilidad de que soy yo quien está
+
+05:19.560 --> 05:27.480
+deshaciendo esos cambios. Esto me regresa
+a mi terminal y con mi terminal puedo escribir git
+
+05:27.480 --> 05:35.080
+log para darme cuenta que revert crea un
+nuevo commit con el mensaje revert archivo especial.
+
+05:35.080 --> 05:43.840
+Está el autor de este revert y dice que
+este revert elimina esta parte del historial. Si te das
+
+05:43.840 --> 05:49.560
+cuenta, de hecho no lo elimina del
+historial porque aquí está el identificador. Simplemente
+
+05:49.560 --> 05:58.240
+te regresa a donde estabas originalmente.
+¿Cómo puedo confirmar eso? Puedo hacer solamente un ls
+
+05:58.240 --> 06:05.520
+y darme cuenta que están los tres archivos
+originales sin el archivo de error que yo creé.
+
+06:05.520 --> 06:12.680
+Ahora es momento de ver cómo utilizar el
+comando de git reset. Voy a crear de nuevo el historial
+
+06:12.680 --> 06:19.440
+para poder ver en dónde estoy ubicado.
+El último historial que tengo es el de git revert que fue
+
+06:19.440 --> 06:25.320
+el que acabamos de hacer en este ejercicio.
+Voy a limpiar mi terminal y ahora crear un nuevo
+
+06:25.320 --> 06:36.320
+archivo que se llame nano reset.txt y voy
+a escribir este es el archivo que voy a resetear.
+
+06:36.320 --> 06:43.680
+Guardo mis cambios y no sé si será
+resetear o reiniciar, pero de cualquier manera este archivo
+
+06:43.680 --> 06:48.600
+en algún momento se irá. Voy a agregar
+esta configuración porque gracias a git status
+
+06:48.600 --> 06:58.840
+puedo ver que este archivo de reset está
+en la lista para ser agregado. git add, git commit,
+
+07:03.400 --> 07:07.280
+nuevo archivo para
+reiniciar
+
+07:11.520 --> 07:17.200
+y guardo mis cambios. Con mis cambios ya
+guardados quiero confirmar que si esté ahí,
+
+07:17.200 --> 07:25.720
+nuevo archivo para reiniciar es el momento
+en donde yo me quedé hasta ahora. Quiere decir
+
+07:25.720 --> 07:30.480
+que todos mis archivos deberían estar sumados.
+Como lo confirmo, ya sabes,
+
+07:30.480 --> 07:39.680
+ls, aquí está, reset sumado a los tres
+archivos originales. Voy a escribir git log para tomar el
+
+07:39.680 --> 07:48.360
+hash que necesito, es decir, quiero
+resetear este commit. Sin embargo, ya no necesito sólo este,
+
+07:48.360 --> 07:55.040
+sino todos los errores que estuve
+cometiendo durante esta clase. Es decir, quiero reiniciar
+
+07:55.040 --> 08:03.920
+también este y este commit, volviendo al
+commit original que tuvimos al principio, este. Voy a
+
+08:03.920 --> 08:13.440
+copiar el hash de este commit, regresar a
+mi terminal y escribir git reset --hard,
+
+08:13.440 --> 08:21.360
+pegando este identificador. El parámetro
+hard es un parámetro que permite que git reset no
+
+08:21.360 --> 08:28.440
+sólo elimine los archivos, sino también
+los el historial de los commits mencionados hasta antes
+
+08:28.440 --> 08:35.800
+de este identificador, o de hecho, después
+de este identificador. Tengo tres opciones de parámetros,
+
+08:35.800 --> 08:43.560
+soft que me permite eliminar los archivos,
+mix que me permite regresar los commits y hard que
+
+08:43.560 --> 08:50.120
+me permite hacer deshacer todos los cambios.
+Es importante mencionar que el comando git reset
+
+08:50.120 --> 08:57.960
+hard debe de ser siempre tu última opción,
+porque puede ser que estés afectando no solamente tu
+
+08:57.960 --> 09:03.360
+trabajo, sino el trabajo de alguien más en
+tu equipo. Aquí presionaré enter.
+
+09:06.360 --> 09:15.120
+Y me dice que head está ahora colocado
+dentro del nuevo archivo creado. Si yo escribo git log,
+
+09:15.120 --> 09:23.560
+te darás cuenta que head y main están ya
+ubicados en donde originalmente estuve antes de arrancar
+
+09:23.560 --> 09:29.800
+esta clase. Ahora que ya conocemos la
+funcionalidad práctica de estos comandos, es momento de recordar
+
+09:29.800 --> 09:36.640
+para qué nos sirve. Git revert recuerda
+que te sirve para poder desbaratar un commit realizado
+
+09:36.640 --> 09:43.200
+y todos sus cambios dentro de los archivos.
+Git reset, por el otro lado, te permite deshacer
+
+09:43.200 --> 09:50.280
+el historial de commits, volviendo a un
+punto previo de todas las actualizaciones. Ambos comandos
+
+09:50.280 --> 09:57.000
+son bastante útiles para tres casos
+particulares, la corrección de errores, un poco de limpieza
+
+09:57.000 --> 10:02.840
+del historial y también el manejo de
+conflictos entre algunas ramas. En cuanto a la corrección
+
+10:02.840 --> 10:10.080
+de errores, es muy fácil que si tú subiste
+un archivo que no te está funcionando, es bastante
+
+10:10.080 --> 10:17.520
+simple utilizar git revert. En cuanto a
+otros compañeros que hayan hecho algunos cambios que
+
+10:17.520 --> 10:24.200
+ellos también quieren sumar para revertir,
+es probable que git reset sea la opción más adecuada.
+
+10:24.200 --> 10:30.840
+De nuevo, todos estos comandos deben de
+ser utilizados en conjunto y comunicación con todo
+
+10:30.840 --> 10:36.880
+tu equipo para que no alteres el trabajo
+de los demás. En cuanto a la limpieza del historial de
+
+10:36.880 --> 10:42.280
+las versiones, cuando tú tienes un
+historial demasiado largo, pero ya tienes un proyecto muy
+
+10:42.280 --> 10:48.120
+sólido, probablemente quieres deshacer
+algunos de los commits para que te sea mucho más fácil
+
+10:48.120 --> 10:54.680
+navegar sin tanto problema con el comando
+de git log. Por último, si tú encuentras que hay un
+
+10:54.680 --> 11:01.920
+conflicto entre los archivos que
+definitivamente no se puede solucionar, bueno, git reset está
+
+11:01.920 --> 11:07.240
+aquí para ayudar. Creo que siempre se
+pueden solucionar todos los conflictos de las ramas
+
+11:07.240 --> 11:13.800
+sin utilizar git reset. Esto significa que
+en mi experiencia te puedo decir que git reset,
+
+11:13.800 --> 11:16.800
+y particularmente el parámetro hud que
+utilizamos,
+
+11:16.800 --> 11:23.000
+es y será por mucho el último recurso que
+debes utilizar en todos tus repositorios.
\ No newline at end of file
diff --git a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/05-Lecturas recomendadas.txt b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/05-Lecturas recomendadas.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0e6f02057cc0d3cc4985756702686b5533608e49
--- /dev/null
+++ b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/05-Lecturas recomendadas.txt
@@ -0,0 +1,2 @@
+https://git-scm.com/docs/git-reset
+https://git-scm.com/docs/git-revert
diff --git a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/05-Resumen.html b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/05-Resumen.html
new file mode 100644
index 0000000000000000000000000000000000000000..f617c5f64742684ea762a8f1f0a5ff779284c3d8
--- /dev/null
+++ b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/05-Resumen.html
@@ -0,0 +1,142 @@
+
+
+
+
+
+
+ Git Reset vs Git Revert: Manejo de Historial y Corrección de Errores
+
+
+
+
+
+
Resumen
Para quienes se inician en el manejo de versiones con Git, comandos como git reset y git revert se vuelven herramientas indispensables, ya que permiten deshacer errores y ajustar el historial de cambios sin complicaciones. Aunque al avanzar en la experiencia puedan dejarse de lado, dominar su uso resulta clave para un control de versiones eficiente.
+
¿Cuál es la diferencia entre Git Reset y Git Revert?
+
+
Git Reset: mueve el puntero de los commits a uno anterior, permitiendo “volver en el tiempo” y explorar el historial de cambios. Es útil para deshacer actualizaciones recientes o revisar lo que se hizo en cada commit.
+
Git Revert: crea un nuevo commit que revierte los cambios de un commit específico, permitiendo conservar el historial original sin eliminaciones. Es ideal para regresar a un estado anterior sin afectar los commits de otros usuarios.
+
+
¿Cómo se utiliza Git Reset?
+
+
Ejecuta git log para identificar el historial de commits. El commit actual se marca con HEAD apuntando a main.
+
Si quieres eliminar cambios recientes:
+
+
Crea un archivo temporal (ejemplo: error.txt) y realiza un commit.
+
Verifica el historial con git log y localiza el hash del commit que deseas restablecer.
+
+
+
Para revertir a un estado anterior:
+
+
Usa git reset con parámetros:
+
+
--soft: solo elimina el archivo del área de staging.
+
--mixed: remueve los archivos de staging, manteniendo el historial de commits.
+
--hard: elimina los archivos y el historial hasta el commit seleccionado.
+
+
+
Este último parámetro debe ser una última opción debido a su impacto irreversible en el historial.
+
+
+
+
¿Cómo funciona Git Revert?
+
+
Identificación del commit: usa git log para encontrar el commit a revertir.
+
Ejecuta git revert seguido del hash del commit: crea un nuevo commit inverso, preservando el historial.
+
Editar el mensaje de commit: permite dejar claro el motivo de la reversión, ideal en equipos colaborativos para mantener claridad.
+
+
¿Cuándo es recomendable utilizar Git Reset o Git Revert?
+
Ambos comandos resultan útiles en diversas situaciones:
+
+
Corrección de errores: si has subido un archivo incorrecto, git revert es rápido y seguro para deshacer el cambio sin afectar el historial.
+
Limpieza del historial: en proyectos sólidos, puede que quieras simplificar el historial de commits; git reset ayuda a limpiar entradas innecesarias.
+
Manejo de conflictos: en casos extremos de conflicto de archivos, git reset es útil, aunque puede ser mejor optar por resolver conflictos manualmente.
+
+
¿Cómo aseguras una correcta comunicación en el uso de estos comandos?
+
+
Utiliza estos comandos en sincronización con el equipo.
+
Evita el uso de git reset --hard sin coordinación para prevenir la pérdida de trabajo ajeno.
+
Documenta cada reversión con un mensaje claro para asegurar el seguimiento de cambios.
+
+
+
+
+
+
\ No newline at end of file
diff --git a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/06-Lecturas recomendadas.txt b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/06-Lecturas recomendadas.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c3051ab693e79960c2c04d314c4fdfb1e9a3be65
--- /dev/null
+++ b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/06-Lecturas recomendadas.txt
@@ -0,0 +1,2 @@
+https://git-scm.com/docs/git-tag
+https://git-scm.com/docs/git-checkout
diff --git a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/06-Resumen.html b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/06-Resumen.html
new file mode 100644
index 0000000000000000000000000000000000000000..3e37248eb32c469a2632002bd550037b5dbdc45b
--- /dev/null
+++ b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/06-Resumen.html
@@ -0,0 +1,119 @@
+
+
+
+
+
+
+ Uso de Git Tag y Git Checkout para Gestión de Versiones y Revisión
+
+
+
+
+
+
Resumen
Git facilita el control de versiones y organización de proyectos, y los comandos git tag y git checkout son piezas clave para una gestión eficiente y ordenada de los cambios en el código. Ambos comandos ayudan a crear puntos de referencia y explorar cambios sin afectar el desarrollo principal, ofreciendo opciones robustas para pruebas y organización.
+
¿Cómo se utiliza git tag para organizar versiones?
+
El comando git tag permite marcar un commit con una etiqueta descriptiva, ideal para señalar versiones estables o hitos importantes en el proyecto. Esto resulta útil en proyectos donde el equipo necesita identificar fácilmente puntos clave de avance. Al etiquetar, se añade una nota visible en el historial, lo cual facilita encontrar versiones específicas en un flujo de trabajo con muchos commits.
+
Para crear un tag:
+
+
Escribe git tag -a v1.0 -m "primera versión estable" y presiona Enter.
+
Al consultar git log, se verá el tag junto al commit en el historial.
+
+
Además, git show muestra detalles de la etiqueta, quién la creó, el mensaje de la versión y los cambios asociados a ese commit. Esto es especialmente útil cuando el historial es extenso, ya que permite regresar a puntos específicos sin necesidad de revisar cada commit en el log completo.
+
Para eliminar un tag:
+
+
Usa git tag -d v1.0 para remover el tag sin afectar el historial ni los archivos. Esto es conveniente si el nombre del tag necesita ser corregido o ajustado.
+
+
¿Qué permite git checkout al explorar el historial?
+
El comando git checkout tiene usos más amplios que solo cambiar entre ramas. También permite revisar commits previos para explorar o probar cambios sin alterar la rama principal. Al usar git checkout , puedes regresar a un punto específico en el historial y evaluar cómo afectaban los cambios al proyecto en ese momento.
+
Por ejemplo:
+
+
Cambia a un commit específico con git checkout .
+
Realiza pruebas o modificaciones. Esto te permite simular cambios o ver el estado del proyecto en esa versión.
+
Para regresar a la rama principal, escribe git checkout main. Esto restaura el proyecto al estado actual y evita que los cambios temporales afecten el historial o la estructura del proyecto.
+
+
Al navegar entre commits y regresar a main, es importante notar que no se crean ramas adicionales, ni se modifican commits previos, lo cual asegura la integridad del historial y la rama principal.
+
¿Cómo integran git tag y git checkout una experiencia de desarrollo ordenada?
+
Ambos comandos permiten explorar y organizar sin interferir en el flujo principal del trabajo. Git tag marca versiones y puntos importantes, actuando como separadores en el historial, mientras que git checkout permite regresar a esos puntos y probar sin comprometer la rama actual. Esto proporciona una estructura en la que el equipo puede trabajar con libertad para realizar pruebas, versionar cambios y retornar al estado actual en cualquier momento sin temor a alterar el trabajo original.
+
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/06-Uso de Git Tag y Git Checkout para Gesti\303\263n de Versiones y Revisi\303\263n.mp4" "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/06-Uso de Git Tag y Git Checkout para Gesti\303\263n de Versiones y Revisi\303\263n.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..87d6d03a2958aeedc6d49c46f821c7baf1b80e05
--- /dev/null
+++ "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/06-Uso de Git Tag y Git Checkout para Gesti\303\263n de Versiones y Revisi\303\263n.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:43fed4ca3944c310db088746e29c8d65296e5c9939d9564b7d113ec3f433a9fa
+size 88278422
diff --git "a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/06-Uso de Git Tag y Git Checkout para Gesti\303\263n de Versiones y Revisi\303\263n.vtt" "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/06-Uso de Git Tag y Git Checkout para Gesti\303\263n de Versiones y Revisi\303\263n.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..0abd88359468613a308e6fbbec6140a7ec423206
--- /dev/null
+++ "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/06-Uso de Git Tag y Git Checkout para Gesti\303\263n de Versiones y Revisi\303\263n.vtt"
@@ -0,0 +1,734 @@
+WEBVTT
+
+00:00.000 --> 00:02.200
+Es momento de explorar dos
+comandos
+
+00:02.200 --> 00:05.200
+que trabajan de una forma un tanto
+complementaria.
+
+00:05.200 --> 00:07.700
+git tag y git
+checkout.
+
+00:07.700 --> 00:10.200
+Ya sé que hemos utilizado git
+checkout
+
+00:10.200 --> 00:12.700
+para poder crear y alternar entre ramas.
+
+00:12.700 --> 00:15.200
+Sin embargo, podemos explorar un poco
+más
+
+00:15.200 --> 00:18.700
+los diferentes usos que este comando nos
+está dando.
+
+00:18.700 --> 00:21.200
+En el caso del comando de git
+tag,
+
+00:21.200 --> 00:25.200
+yo puedo agregarle una etiqueta a ciertos
+commits.
+
+00:25.200 --> 00:27.700
+Digamos que mi equipo y yo
+mismo
+
+00:27.700 --> 00:31.200
+hemos avanzado en una versión un tanto más
+estable.
+
+00:31.200 --> 00:34.700
+Una versión que queremos recordar como
+nuestra versión 1
+
+00:34.700 --> 00:38.700
+o incluso nuestra versión alfa o el tag
+que tú quieras poner.
+
+00:38.700 --> 00:41.700
+Esto permite que cuando tú utilices git
+log
+
+00:41.700 --> 00:43.700
+no solo veas el
+commit,
+
+00:43.700 --> 00:47.200
+sino al lado veas agregada una pequeña
+etiqueta
+
+00:47.200 --> 00:50.200
+indicadora para tu equipo de cualquier
+mensaje
+
+00:50.200 --> 00:52.200
+que quieras tener
+presente.
+
+00:52.200 --> 00:53.700
+Este comando es bastante
+útil
+
+00:53.700 --> 00:56.200
+no solo para trabajar con versiones,
+
+00:56.200 --> 00:59.200
+sino también para demostrar algunos hitos.
+
+00:59.200 --> 01:01.700
+Lo puedes utilizar de la forma que tú gustes.
+
+01:01.700 --> 01:04.200
+En el caso del comando git checkout,
+
+01:04.200 --> 01:07.700
+tú vas a poder utilizarlo como ya lo hemos
+hecho previamente
+
+01:07.700 --> 01:09.700
+para alternar entre
+ramas,
+
+01:09.700 --> 01:13.700
+pero también para evaluar ciertos cambios
+en una rama
+
+01:13.700 --> 01:16.200
+antes de integrarlos dentro de
+main
+
+01:16.200 --> 01:19.200
+sin que esto afecte a la rama principal.
+
+01:19.200 --> 01:22.200
+Comenzaré con el comando git
+log
+
+01:22.200 --> 01:24.200
+para ver mi
+historial.
+
+01:24.200 --> 01:26.200
+Tengo nuevo archivo
+creado
+
+01:26.200 --> 01:30.200
+y yo quisiera que este commit que acabo de
+hacer
+
+01:30.200 --> 01:33.200
+sea el commit de la versión
+1.
+
+01:33.200 --> 01:35.200
+Entonces necesito
+escribir
+
+01:35.200 --> 01:41.700
+git tag-a
+v1.0
+
+01:41.700 --> 01:46.200
+De esta forma yo puedo tener ya ese
+indicador de la etiqueta
+
+01:46.200 --> 01:48.200
+y después poner un
+mensaje
+
+01:48.200 --> 01:54.200
+que es mi primera
+versión.
+
+01:56.200 --> 01:59.200
+Con estos dos mensajes presiono
+Enter
+
+01:59.200 --> 02:03.200
+y después de limpiar mi
+terminal,
+
+02:03.200 --> 02:05.200
+escribo git
+log.
+
+02:06.200 --> 02:08.700
+Ahora podrás observar que en el paréntesis,
+
+02:08.700 --> 02:10.700
+junto a head
+main,
+
+02:10.700 --> 02:12.200
+aparece este
+tag,
+
+02:12.200 --> 02:15.200
+un hito muy importante para mi
+equipo
+
+02:15.200 --> 02:18.200
+que le permite identificar en dónde
+está
+
+02:18.200 --> 02:21.200
+un avance mayor en mis
+versiones.
+
+02:21.200 --> 02:23.200
+Siendo bien
+estrictos,
+
+02:23.200 --> 02:27.200
+lo ideal sería que cada commit llevara un
+tag
+
+02:27.200 --> 02:30.700
+para poder identificarlo de una forma muy
+acertada.
+
+02:30.700 --> 02:34.200
+Sin embargo, eso generaría demasiado
+trabajo extra
+
+02:34.200 --> 02:35.700
+en nuestro
+equipo.
+
+02:35.700 --> 02:39.700
+Si yo controlo las versiones en cada uno
+de sus decimales,
+
+02:39.700 --> 02:42.700
+bueno, ya me pondré de acuerdo con todos
+mis compañeros
+
+02:42.700 --> 02:47.200
+y determinaremos cuándo utilizar tag y en
+qué commits.
+
+02:47.200 --> 02:52.200
+Voy a limpiar mi terminal y ahora escribir
+git tag.
+
+02:52.200 --> 02:55.200
+Este comando me va a dar la enorme
+ventaja
+
+02:55.200 --> 02:59.200
+de poder empezar a buscar en mi lista de tags,
+
+02:59.200 --> 03:02.200
+no en mi lista de commits como git log.
+
+03:02.200 --> 03:05.700
+Significa que cada vez que yo le ponga un
+tag
+
+03:05.700 --> 03:07.700
+a cierto número de
+commits,
+
+03:07.700 --> 03:10.700
+ahora puedo navegar entre las etiquetas,
+
+03:10.700 --> 03:14.700
+no solo entre todo el historial de mis
+commits.
+
+03:14.700 --> 03:18.200
+Ahora, si yo quisiera profundizar un poco
+más
+
+03:18.200 --> 03:21.200
+de lo que versión 1 o la etiqueta versión
+1
+
+03:21.200 --> 03:22.700
+me están
+indicando,
+
+03:22.700 --> 03:25.700
+podré escribir git
+show
+
+03:25.700 --> 03:29.200
+y copio la etiqueta que quiero explorar.
+
+03:29.200 --> 03:32.700
+Pongo un espacio, versión
+1,
+
+03:32.700 --> 03:35.700
+y aquí en la etiqueta me
+dice
+
+03:35.700 --> 03:39.200
+que la persona que hizo esta etiqueta fui yo.
+
+03:39.200 --> 03:43.200
+Cuando fue creada y la primera versión de
+la etiqueta.
+
+03:43.200 --> 03:46.700
+¿Te acuerdas que agregue un mensaje dentro
+de esta etiqueta?
+
+03:46.700 --> 03:48.700
+Bueno, pues aquí lo puedes
+ver.
+
+03:48.700 --> 03:51.200
+Además de eso, también me está
+indicando
+
+03:51.200 --> 03:55.200
+el commit de referencia al cual le agregue
+esta etiqueta.
+
+03:55.200 --> 03:57.700
+Quiere decir que de esta
+forma,
+
+03:57.700 --> 04:01.200
+después de 50, 100, 200
+commits,
+
+04:01.200 --> 04:04.200
+si tú agregaste tags en ciertos hitos,
+
+04:04.200 --> 04:07.700
+es como una especie de separador en un libro.
+
+04:07.700 --> 04:10.700
+De esta forma, puedes navegar mucho más
+cómodo
+
+04:10.700 --> 04:13.700
+y cuando llegues a la ubicación que tú
+quieres,
+
+04:13.700 --> 04:16.200
+entonces puedes escribir git
+show
+
+04:16.200 --> 04:19.200
+para que la etiqueta te dé muchísima más
+información
+
+04:19.200 --> 04:20.700
+de todo
+esto.
+
+04:20.700 --> 04:22.700
+No solo la información del
+commit,
+
+04:22.700 --> 04:24.700
+de hecho, podrás darte
+cuenta
+
+04:24.700 --> 04:27.200
+qué fue lo que sucedió en ese commit.
+
+04:27.200 --> 04:30.200
+Es decir, cuáles fueron los cambios
+realizados.
+
+04:30.200 --> 04:33.700
+Quizá esto en un historial bastante grande
+de commits
+
+04:33.700 --> 04:35.700
+no sea tan
+relevante.
+
+04:35.700 --> 04:39.700
+Sin embargo, saber de qué trató ese commit
+y su mensaje
+
+04:39.700 --> 04:43.700
+puede que sean mucho más importantes para
+ti en este momento.
+
+04:43.700 --> 04:47.200
+Ahora, ya que yo sé cómo crear un tag,
+
+04:47.200 --> 04:50.200
+también considero que es muy importante
+saber
+
+04:50.200 --> 04:52.200
+cómo
+eliminarlo.
+
+04:52.200 --> 04:54.700
+Voy a limpiar mi terminal y
+escribir
+
+04:54.700 --> 04:58.200
+git
+tag-d
+
+04:58.200 --> 05:02.200
+y presionaré la versión que tengo
+previamente creada.
+
+05:02.200 --> 05:06.200
+Gracias al parámetro guión de o delete,
+
+05:06.200 --> 05:10.700
+voy a poder eliminar ese tag dentro de mis
+commits.
+
+05:10.700 --> 05:14.200
+Esto no altera en absoluto el historial de
+commits.
+
+05:14.200 --> 05:18.200
+No altera en absoluto a los archivos ni nada.
+
+05:18.200 --> 05:20.700
+Simplemente quite esa
+etiqueta.
+
+05:20.700 --> 05:23.700
+Si yo pongo git
+log,
+
+05:23.700 --> 05:26.700
+mi historial permanece
+intacto.
+
+05:26.700 --> 05:29.700
+Sin embargo, ya no tengo esa etiqueta aquí.
+
+05:29.700 --> 05:32.200
+Digamos que yo me
+equivoqué,
+
+05:32.200 --> 05:35.700
+que a lo mejor bauticé la versión de una
+forma equivocada.
+
+05:35.700 --> 05:40.700
+Entonces, ahora podría poner git tag v 2.
+0
+
+05:40.700 --> 05:42.700
+de nuevo, solo para
+saber
+
+05:42.700 --> 05:45.700
+que esa era la versión que correspondía.
+
+05:45.700 --> 05:48.700
+Escribo git
+log
+
+05:48.700 --> 05:52.700
+para confirmar que ahora mi nueva etiqueta
+ya está ahí.
+
+05:52.700 --> 05:55.700
+De nuevo, agregar o quitar
+etiquetas
+
+05:55.700 --> 05:59.200
+no altera para nada el historial de tus
+commits.
+
+05:59.200 --> 06:01.700
+Solo establece un nuevo
+separador.
+
+06:01.700 --> 06:04.200
+Entonces, tú puedes crear y
+modificarlas
+
+06:04.200 --> 06:08.200
+sin preocuparte por alterar el trabajo de
+todos los demás.
+
+06:08.200 --> 06:10.700
+Es momento de pasar al siguiente comando,
+
+06:10.700 --> 06:12.700
+al de git
+checkout.
+
+06:12.700 --> 06:16.700
+Si yo quiero hacer una revisión de un
+punto en particular
+
+06:16.700 --> 06:20.700
+sin tener que modificar el trabajo que
+actualmente estoy haciendo,
+
+06:20.700 --> 06:23.700
+puedo hacerlo utilizando git
+checkout
+
+06:23.700 --> 06:28.700
+y el hash del commit que yo desee explorar
+a profundidad.
+
+06:28.700 --> 06:30.700
+Voy a copiar este
+commit
+
+06:30.700 --> 06:33.700
+y escribir limpiando mi terminal primero,
+
+06:33.700 --> 06:37.700
+git
+checkout
+
+06:37.700 --> 06:41.700
+y copio aquí ese hash que voy a utilizar.
+
+06:45.700 --> 06:49.700
+Presiono Enter y me dice que estoy
+regresando
+
+06:49.700 --> 06:53.200
+o moviéndome hacia ese identificador.
+
+06:53.200 --> 06:56.700
+Me aparece una leyenda diciendo qué es lo
+que yo estoy haciendo,
+
+06:56.700 --> 07:01.700
+indicándome que si quiero o estoy
+regresando a estos cambios,
+
+07:01.700 --> 07:04.700
+puedo desbaratarlos de cierta manera.
+
+07:04.700 --> 07:07.200
+Es decir, escribiendo este
+comando.
+
+07:07.200 --> 07:10.200
+De nuevo, el comando switch aparece aquí,
+
+07:10.200 --> 07:12.700
+que es un comando que ha
+comenzado
+
+07:12.700 --> 07:15.700
+a prestarle mucha funcionalidad a checkout.
+
+07:15.700 --> 07:18.700
+Sin embargo, ¿qué quiero ver
+aquí?
+
+07:18.700 --> 07:21.700
+Voy a ver git
+log
+
+07:21.700 --> 07:24.700
+y me voy a dar cuenta que dentro de mi
+historial
+
+07:24.700 --> 07:27.200
+regresé al punto
+principal.
+
+07:27.200 --> 07:30.700
+Sin embargo, si eres muy detallista,
+
+07:30.700 --> 07:33.700
+te vas a dar cuenta que git ya no
+aparece
+
+07:33.700 --> 07:36.700
+con la flechita indicando
+main.
+
+07:36.700 --> 07:40.200
+Esto es para hacerte saber que estás
+ubicado
+
+07:40.200 --> 07:43.700
+en una parte particular de tu historial.
+
+07:43.700 --> 07:47.700
+Sin embargo, eso no quiere decir que tú
+estés aquí
+
+07:47.700 --> 07:49.700
+como tu último
+commit.
+
+07:49.700 --> 07:53.700
+Solamente digamos que estás explorando
+entre tu historial.
+
+07:53.700 --> 07:56.700
+Si quisieras desbaratar estos
+cambios
+
+07:56.700 --> 07:58.700
+o agregar un cambio en
+particular,
+
+07:58.700 --> 08:00.700
+podríamos
+hacerlo.
+
+08:00.700 --> 08:04.700
+Si presiono ls, me doy cuenta que el
+tercer archivo creado
+
+08:04.700 --> 08:06.700
+no aparece
+aquí.
+
+08:06.700 --> 08:12.700
+Escribo
+nanotesting3.txt
+
+08:12.700 --> 08:17.700
+y voy a poner archivo de prueba
+3.
+
+08:18.700 --> 08:20.700
+Guardo mis
+cambios
+
+08:20.700 --> 08:23.700
+y puedo ver aquí que ya
+están.
+
+08:24.700 --> 08:30.700
+Ls ya está mostrándome el tercer nuevo
+archivo modificado.
+
+08:30.700 --> 08:33.700
+Aquí puedo escribir git
+status.
+
+08:35.700 --> 08:38.700
+Darme cuenta que este cambio está agregado,
+
+08:38.700 --> 08:42.700
+pero solamente dentro de la parte de el
+checkout
+
+08:42.700 --> 08:44.700
+que estoy
+utilizando.
+
+08:44.700 --> 08:47.700
+Significa que así podría ver qué
+pasa
+
+08:47.700 --> 08:52.700
+si mi sistema tiene este archivo o no.
+
+08:52.700 --> 08:55.700
+Es decir, puedo hacer las pruebas que yo
+quiera aquí
+
+08:55.700 --> 08:57.700
+sin ningún
+problema.
+
+08:57.700 --> 09:01.700
+Una vez que haya hecho todas las pruebas
+que necesito
+
+09:01.700 --> 09:05.700
+utilizando este archivo temporal dentro de
+este espacio temporal,
+
+09:05.700 --> 09:08.700
+simplemente puedo regresar a la
+parte
+
+09:08.700 --> 09:11.700
+en donde originalmente todo mi proyecto ha
+estado,
+
+09:11.700 --> 09:14.700
+haciendo primero limpiar mi
+terminal
+
+09:14.700 --> 09:19.700
+y después git checkout
+main.
+
+09:19.700 --> 09:24.700
+Esto va a hacer que el head ya se coloque
+en la posición adecuada
+
+09:24.700 --> 09:26.700
+y de hecho me mande a
+main.
+
+09:26.700 --> 09:29.700
+Yo escribo git
+log
+
+09:29.700 --> 09:32.700
+y puedo darme cuenta de que ahora
+sí
+
+09:32.700 --> 09:35.700
+ya aparece como originalmente estaba
+head
+
+09:35.700 --> 09:40.700
+apuntando a main y teniendo el tag que
+tenía desde el principio.
+
+09:40.700 --> 09:45.700
+Para confirmar que nada de todo lo que
+acabo de hacer sucedió,
+
+09:45.700 --> 09:48.700
+puedo también escribir git
+branch
+
+09:48.700 --> 09:51.700
+y darme cuenta que no se creó una rama,
+
+09:51.700 --> 09:55.700
+que no hubo cambios, que no hice
+absolutamente nada
+
+09:55.700 --> 09:58.700
+que afectara el historial de todos mis
+commits.
+
+09:58.700 --> 10:01.700
+De esta manera, puedes regresar a un
+commit previo,
+
+10:01.700 --> 10:04.700
+jugar con los archivos, hacer algunas
+modificaciones,
+
+10:04.700 --> 10:07.700
+ver si esto funciona y en caso de que no
+funcione,
+
+10:07.700 --> 10:12.700
+simplemente regresas a la realidad en
+donde todo está en orden
+
+10:12.700 --> 10:15.700
+y puedes regresar toda esa
+funcionalidad
+
+10:15.700 --> 10:38.700
+que estuviste explorando con checkout sin
+mayores consecuencias.
+
diff --git a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/07-Lecturas recomendadas.txt b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/07-Lecturas recomendadas.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e0bc46d3397fa3ae2e8df6f00a0be79983349596
--- /dev/null
+++ b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/07-Lecturas recomendadas.txt
@@ -0,0 +1,2 @@
+https://git-scm.com/docs/git-branch
+https://git-scm.com/docs/git-merge
diff --git "a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/07-Resoluci\303\263n de Conflictos de Ramas en Git paso a paso.mp4" "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/07-Resoluci\303\263n de Conflictos de Ramas en Git paso a paso.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..a0d8ffb5ca06a8e2afd28da5a5d71241ce1744a2
--- /dev/null
+++ "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/07-Resoluci\303\263n de Conflictos de Ramas en Git paso a paso.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ba780b025ddce4d6ec15535a24894f3c635e76d484aab79aa50700abba2511fa
+size 43391573
diff --git "a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/07-Resoluci\303\263n de Conflictos de Ramas en Git paso a paso.vtt" "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/07-Resoluci\303\263n de Conflictos de Ramas en Git paso a paso.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..5796c49aebcf643b411c4c6ceaf41cbe5c5388f5
--- /dev/null
+++ "b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/07-Resoluci\303\263n de Conflictos de Ramas en Git paso a paso.vtt"
@@ -0,0 +1,481 @@
+WEBVTT
+
+00:00.000 --> 00:03.000
+Bien, cuando estamos trabajando en un
+proyecto individual
+
+00:03.000 --> 00:07.000
+y de modo local, todo sale de maravilla
+con nuestros archivos,
+
+00:07.000 --> 00:10.000
+todas nuestras ramas se fusionan y todo es
+felicidad.
+
+00:10.000 --> 00:14.000
+Sin embargo, en un entorno real, en donde
+estoy trabajando en equipo
+
+00:14.000 --> 00:18.000
+y en donde varias personas están
+trabajando con diferentes archivos,
+
+00:18.000 --> 00:21.000
+puede suceder que incluso haya dos o más
+personas
+
+00:21.000 --> 00:24.000
+trabajando en un solo
+archivo.
+
+00:24.000 --> 00:26.000
+Cuando nosotros intentamos hacer esa fusión,
+
+00:26.000 --> 00:30.000
+es que entramos en un pequeño conflicto de
+ramas.
+
+00:30.000 --> 00:35.000
+Ese conflicto de ramas quiere decir que
+puede ser que haya personas
+
+00:35.000 --> 00:38.000
+que al momento de tratar de fusionar sus
+cambios,
+
+00:38.000 --> 00:43.000
+estos cambios estén alterando los que yo
+ya previamente tenía.
+
+00:43.000 --> 00:48.000
+Eso significa que me va a tocar decidir
+cuál de esos dos cambios
+
+00:48.000 --> 00:52.000
+es el que se va a quedar finalmente dentro
+de la rama principal.
+
+00:52.000 --> 00:58.000
+Esto puede ser que suene bastante
+complicado y nos gustaría que no pasara tanto,
+
+00:58.000 --> 01:02.000
+pero suele pasar demasiado cuando estamos
+comenzando a trabajar en equipo.
+
+01:02.000 --> 01:05.000
+Sin embargo, hay una forma muy fácil de
+solucionarlo
+
+01:05.000 --> 01:08.000
+y es en este video en donde vamos a ver
+cómo hacerlo
+
+01:08.000 --> 01:10.000
+para que no tengas ningún
+problema.
+
+01:10.000 --> 01:13.000
+Es hora de ponernos el pie nosotros solos.
+
+01:13.000 --> 01:17.000
+Es decir, vamos a crear un conflicto para
+que también
+
+01:17.000 --> 01:19.000
+al momento de saber cómo es el conflicto,
+
+01:19.000 --> 01:22.000
+podamos saber cómo resolverlo de una forma
+súper práctica.
+
+01:22.000 --> 01:25.000
+Lo primero que voy a hacer es escribir el
+comando git branch
+
+01:25.000 --> 01:27.000
+para saber en qué rama me encuentro.
+
+01:27.000 --> 01:32.000
+Por ahora solo tengo una rama y es main,
+entonces no hay ningún problema.
+
+01:32.000 --> 01:39.000
+Aquí voy a crear un archivo que le voy a
+llamar nano conflict.txt.
+
+01:41.000 --> 01:46.000
+Le puedo poner línea original para saber
+que tiene algún contenido.
+
+01:46.000 --> 01:50.000
+Guardo mis cambios y solamente verifico
+que ya está ahí,
+
+01:50.000 --> 01:53.000
+conflict.txt.
+
+01:53.000 --> 01:57.000
+Después de eso, obviamente necesito
+agregar estos cambios,
+
+01:57.000 --> 02:01.000
+git add, git
+commit,
+
+02:01.000 --> 02:06.000
+y puedo poner un mensaje que haga saber
+que ese archivo existe.
+
+02:06.000 --> 02:09.000
+Es un mensaje muy, muy lógico
+aquí.
+
+02:10.000 --> 02:13.000
+Archivo de conflicto
+creado.
+
+02:13.000 --> 02:17.000
+Entonces ya tengo estos cambios dentro de
+mi rama de main.
+
+02:17.000 --> 02:20.000
+Lo que sigue ahora es crear una nueva rama,
+
+02:20.000 --> 02:25.000
+git checkout v
+developer.
+
+02:27.000 --> 02:32.000
+Con esta nueva rama, yo sabré que ese
+archivo ya está ahí presente,
+
+02:32.000 --> 02:34.000
+ls y
+conflict.
+
+02:34.000 --> 02:37.000
+Voy a confirmar nada
+más,
+
+02:37.000 --> 02:40.000
+dudando de mí mismo que esté dentro de la
+rama,
+
+02:40.000 --> 02:43.000
+es decir, dentro de developer. Aquí está
+ya señalado
+
+02:43.000 --> 02:47.000
+y estoy dentro de developer para saber que
+todo va en orden.
+
+02:47.000 --> 02:53.000
+Aquí voy a crear un cambio, nano conflict.
+txt
+
+02:53.000 --> 03:00.000
+y voy a poner, no sé, cambios desde la
+rama dev.
+
+03:02.000 --> 03:06.000
+Guardo mis cambios y con esto significa
+que estos cambios
+
+03:06.000 --> 03:11.000
+realizados en esta rama local ya están
+guardados.
+
+03:11.000 --> 03:13.000
+Sin embargo, necesito hacer un
+commit
+
+03:13.000 --> 03:17.000
+para estar seguro de que esto se registre
+en mi historial.
+
+03:17.000 --> 03:24.000
+git add, git
+commit-m
+
+03:24.000 --> 03:29.000
+y nuevos cambios desde
+dev.
+
+03:29.000 --> 03:32.000
+Hasta aquí todo parece un flujo normal.
+
+03:32.000 --> 03:36.000
+Voy a regresar ahora a mi rama de main.
+
+03:36.000 --> 03:39.000
+Esto significa primero limpiar mi
+terminal
+
+03:39.000 --> 03:47.000
+y escribir aquí git checkout-b main.
+
+03:48.000 --> 03:52.000
+Ah, solamente necesitaba escribir git
+checkout main.
+
+03:52.000 --> 03:55.000
+Se me fue el parámetro, la costumbre.
+
+03:55.000 --> 03:57.000
+Listo, ya estoy
+ahí.
+
+03:57.000 --> 04:00.000
+Recuerda que puedes usar git checkout o
+git switch,
+
+04:00.000 --> 04:03.000
+cualquiera de los dos hace exactamente lo
+mismo.
+
+04:03.000 --> 04:06.000
+Lo que voy a hacer ahora es crear un
+cambio
+
+04:06.000 --> 04:08.000
+dentro de este mismo archivo, es decir,
+
+04:08.000 --> 04:11.000
+escribir nano
+conflict.txt
+
+04:11.000 --> 04:14.000
+y si te das cuenta en la rama
+main
+
+04:14.000 --> 04:17.000
+todavía no aparecen los cambios de la rama
+de dev.
+
+04:17.000 --> 04:23.000
+Voy a poner aquí segundo cambio desde main.
+
+04:24.000 --> 04:27.000
+Guardo mis cambios y
+regreso.
+
+04:27.000 --> 04:30.000
+Cuando hago esto todavía estoy seguro.
+
+04:30.000 --> 04:34.000
+Sin embargo, si escribo git
+status
+
+04:34.000 --> 04:37.000
+voy a darme cuenta que ya conflict fue
+modificado,
+
+04:37.000 --> 04:39.000
+por lo que quiero registrar esos cambios.
+
+04:39.000 --> 04:44.000
+git add, git
+commit-m
+
+04:44.000 --> 04:49.000
+y aquí voy a poner cambios a conflict.
+
+04:49.000 --> 04:52.000
+Entonces ahora nos podemos dar
+cuenta
+
+04:52.000 --> 04:54.000
+que tanto main como
+developer,
+
+04:54.000 --> 04:57.000
+las dos ramas hicieron
+cambios.
+
+04:57.000 --> 05:00.000
+Esto significa que si yo limpio mi
+terminal
+
+05:00.000 --> 05:05.000
+y escribo git merge
+developer,
+
+05:05.000 --> 05:08.000
+es decir, quiero fusionar developer con main,
+
+05:08.000 --> 05:12.000
+¡voilà! Me aparece un
+conflicto.
+
+05:12.000 --> 05:16.000
+Este conflicto se puede solucionar fácilmente.
+
+05:16.000 --> 05:21.000
+Yo puedo escribir nano
+conflict.txt
+
+05:21.000 --> 05:24.000
+y git me hace el enorme favor de
+poner
+
+05:24.000 --> 05:27.000
+muchas señalizaciones para
+saber
+
+05:27.000 --> 05:29.000
+qué es lo que está
+pasando.
+
+05:29.000 --> 05:31.000
+Este cambio que dice
+head
+
+05:31.000 --> 05:33.000
+es el cambio realizado por la rama principal,
+
+05:33.000 --> 05:36.000
+el último cambio realizado a este archivo.
+
+05:36.000 --> 05:39.000
+Este cambio realizado por la rama
+developer
+
+05:39.000 --> 05:42.000
+es el cambio realizado desde esa rama local.
+
+05:42.000 --> 05:45.000
+Aquí puedo hacer cualquier edición que yo
+necesite,
+
+05:45.000 --> 05:48.000
+es decir, puedo eliminar esta parte,
+
+05:48.000 --> 05:51.000
+puedo también eliminar esta
+parte
+
+05:51.000 --> 05:55.000
+y las señalizaciones de
+head.
+
+05:55.000 --> 05:58.000
+De esta forma yo estoy
+decidiendo
+
+05:58.000 --> 06:01.000
+de qué manera va a quedar como versión
+final mi archivo,
+
+06:01.000 --> 06:04.000
+es decir, puedo poner una línea arriba,
+
+06:04.000 --> 06:06.000
+puedo poner una línea
+abajo,
+
+06:06.000 --> 06:08.000
+puedo incluso crear una nueva
+línea
+
+06:08.000 --> 06:10.000
+que no tenga nada que ver con las
+anteriores
+
+06:10.000 --> 06:13.000
+o cualquier acción que yo
+necesite.
+
+06:13.000 --> 06:15.000
+En cuanto a código, yo puedo
+decidir
+
+06:15.000 --> 06:17.000
+cuál es el código que se
+queda
+
+06:17.000 --> 06:19.000
+y cuál es el código que se
+va.
+
+06:19.000 --> 06:21.000
+Una vez que haya hecho estos cambios,
+
+06:21.000 --> 06:24.000
+guardo mis cambios dentro de este
+archivo
+
+06:24.000 --> 06:28.000
+y ya con esto puedo ahora sí volver a
+intentarlo.
+
+06:28.000 --> 06:32.000
+Es decir, selecciono git
+status
+
+06:32.000 --> 06:35.000
+y aparece una opción que
+dice
+
+06:35.000 --> 06:39.000
+ambos modificados en
+conflict.txt.
+
+06:39.000 --> 06:42.000
+Significa que yo puedo
+escribir
+
+06:42.000 --> 06:47.000
+add git
+commit
+
+06:49.000 --> 06:53.000
+nuevos
+cambios
+
+06:53.000 --> 06:56.000
+y ahora sí puedo volver a intentar otra
+vez
+
+06:56.000 --> 06:59.000
+git merge
+developer.
+
+07:00.000 --> 07:03.000
+Listo, mis conflictos quedaron hechos.
+
+07:03.000 --> 07:07.000
+Ahora, en mi último commit hice que ambos
+archivos
+
+07:07.000 --> 07:10.000
+pudieran ser capaces de unificar sus
+cambios
+
+07:10.000 --> 07:13.000
+y así que dejar dentro de la rama de
+main
+
+07:13.000 --> 07:16.000
+la versión final de mi
+documento.
+
+07:16.000 --> 07:19.000
+Lo ideal, una vez que hayas unificado
+ambas ramas
+
+07:19.000 --> 07:21.000
+y que hayas solucionado este conflicto,
+
+07:21.000 --> 07:24.000
+es que después solo elimines la rama
+adicional
+
+07:24.000 --> 07:28.000
+a la principal para que después no te
+vuelva a suceder
+
+07:28.000 --> 07:40.000
+algún conflicto en uno de tus commits
+posteriores.
+
diff --git a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/07-Resumen.html b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/07-Resumen.html
new file mode 100644
index 0000000000000000000000000000000000000000..e8504a555a6d0cbb83cccb27921d36a8fc98ddb7
--- /dev/null
+++ b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/07-Resumen.html
@@ -0,0 +1,122 @@
+
+
+
+
+
+
+ Resolución de Conflictos de Ramas en Git paso a paso
+
+
+
+
+
+
Resumen
Cuando trabajamos en equipo, el manejo de conflictos de ramas en Git es esencial para evitar problemas y asegurar una integración fluida de cambios en los archivos compartidos. Aquí te mostramos cómo se genera un conflicto de ramas y la forma efectiva de resolverlo paso a paso.
+
¿Qué es un conflicto de ramas en Git?
+
En un entorno colaborativo, es común que varias personas realicen modificaciones en archivos compartidos. Esto puede llevar a conflictos de ramas cuando intentamos fusionar cambios y estos alteran las modificaciones previas realizadas por otro colaborador. En estos casos, se debe elegir qué cambios se mantendrán en la rama principal.
+
¿Cómo crear un conflicto de ramas para aprender a resolverlo?
+
Para experimentar y entender cómo resolver un conflicto, podemos crear uno intencionalmente. Aquí están los pasos básicos:
+
+
Verifica tu rama actual con git branch. Si solo tienes la rama main, estás listo para iniciar.
+
Crea un archivo, por ejemplo, conflict.txt, añade contenido inicial (e.g., “línea original”) y realiza un commit:
Crea una nueva rama con git checkout -b developer y modifica el archivo con nuevos cambios, como “cambios desde la rama dev”, realiza un commit.
+
Vuelve a la rama main con git checkout main y modifica el mismo archivo en esta rama, por ejemplo, añadiendo “segundo cambio desde main”, y realiza otro commit.
+
+
Al regresar a main y realizar la fusión de developer, verás el conflicto.
+
¿Cómo resolver un conflicto de ramas en Git?
+
Cuando Git detecta un conflicto, te indicará las diferencias entre las ramas con etiquetas que facilitan la identificación de cambios:
+
+
Abre el archivo en conflicto. Verás secciones como <<<<< HEAD y >>>>>, que marcan los cambios en main y en la rama que intentas fusionar (developer).
+
Edita el archivo eliminando las líneas de marcación y decide cuáles cambios deseas conservar, combinar o incluso reescribir.
+
Guarda el archivo sin las señalizaciones de conflicto y realiza un commit para registrar la resolución:
Una vez resuelto el conflicto y unificada la versión final en main, considera eliminar la rama developer para evitar conflictos futuros. Esto ayuda a mantener el historial de cambios limpio y reduce la posibilidad de cometer errores en el futuro.
+
+
+
+
+
\ No newline at end of file
diff --git a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/08-Lecturas recomendadas.txt b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/08-Lecturas recomendadas.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8a65484c1f32124dc754f78552d21cf656865a77
--- /dev/null
+++ b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/08-Lecturas recomendadas.txt
@@ -0,0 +1 @@
+https://code.visualstudio.com/
diff --git a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/08-Resumen.html b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/08-Resumen.html
new file mode 100644
index 0000000000000000000000000000000000000000..ad96046e49649f954dc92ea248b597464a0cc328
--- /dev/null
+++ b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/08-Resumen.html
@@ -0,0 +1,130 @@
+
+
+
+
+
+
+ Uso de Git en Visual Studio Code
+
+
+
+
+
+
Resumen
Visual Studio Code ofrece una interfaz visual y eficiente para gestionar versiones con Git, simplificando muchas tareas complejas y ahorrando tiempo a los desarrolladores. Integrar VS Code en nuestro flujo de trabajo diario puede facilitar considerablemente el manejo de ramas, commits y conflictos sin depender tanto de comandos en la terminal.
+
¿Cómo abrir VS Code desde la terminal?
+
+
Inicia VS Code en la ubicación del proyecto con code ..
+
Esto abre una instancia de VS Code en el directorio actual, incluyendo todos los archivos versionados con Git.
+
+
¿Cómo visualizar y gestionar ramas en VS Code?
+
+
Dentro de VS Code, identifica tu rama activa en la sección de control de versiones.
+
Selecciona la rama para ver las opciones de cambio, como alternar entre ramas o crear nuevas.
+
Los cambios en las ramas se presentan en una gráfica visual, diferenciando fusiones y ramas en colores, una ventaja significativa sobre git log.
+
+
¿Cómo hacer un commit de cambios en VS Code?
+
+
Al editar un archivo, el ícono de control de versiones muestra un indicador de cambio.
+
En lugar de usar git commit -m "mensaje", puedes simplemente añadir un mensaje y presionar commit en la interfaz de VS Code.
+
+
¿Cómo crear y alternar entre ramas en VS Code?
+
+
Haz clic en “Create New Branch” y nómbrala, por ejemplo, “VS Code Dev”.
+
VS Code marca esta nueva rama como activa, heredando los cambios de la rama principal.
+
Al editar archivos en esta rama, puedes realizar commits directamente en la interfaz.
+
+
¿Cómo resolver conflictos de fusión en VS Code?
+
+
Selecciona la rama con la que deseas fusionar (por ejemplo, VS Code Dev con Main) usando el menú de Branch > Merge.
+
Cuando ocurre un conflicto, VS Code despliega opciones de resolución con colores para cada cambio, simplificando la selección entre el cambio actual, el entrante o ambos.
+
Puedes optar por “Merge Editor” para una vista más visual y confirmar la fusión con un “Complete Merge” al finalizar.
+
+
¿Cómo iniciar un nuevo repositorio en VS Code?
+
+
Crea un nuevo directorio y abre VS Code en esa ubicación.
+
Al no haber archivos, selecciona “Inicializar repositorio” para configurar un nuevo repositorio.
+
Esto ejecuta git init, crea la rama principal (main) y permite añadir nuevas ramas y hacer commits sin usar comandos.
+
+
+
+
+
+
\ No newline at end of file
diff --git a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/08-Uso de Git en Visual Studio Code.mp4 b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/08-Uso de Git en Visual Studio Code.mp4
new file mode 100644
index 0000000000000000000000000000000000000000..6fed46e6e0828d394cb748f3c41de14a3c69546c
--- /dev/null
+++ b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/08-Uso de Git en Visual Studio Code.mp4
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:932217d17f664ebcdf393cb57df9172a7c9d582054bf44b38ca6796a164956af
+size 84414383
diff --git a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/08-Uso de Git en Visual Studio Code.vtt b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/08-Uso de Git en Visual Studio Code.vtt
new file mode 100644
index 0000000000000000000000000000000000000000..4894af1af705d1847e462f1d899215f82dc4d384
--- /dev/null
+++ b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/08-Uso de Git en Visual Studio Code.vtt
@@ -0,0 +1,662 @@
+WEBVTT
+
+00:00.000 --> 00:04.960
+A pesar de lo mucho que soy feliz
+trabajando con una línea de comandos,
+
+00:04.960 --> 00:09.640
+si nosotros pensamos en un entorno real,
+como lo dijimos en la clase anterior,
+
+00:09.640 --> 00:14.680
+la verdad es que la línea de comandos nos
+puede hacer ligeramente más lentos.
+
+00:14.680 --> 00:16.920
+Un poco nerds, pero muy
+lentos.
+
+00:16.920 --> 00:21.240
+Entonces es momento de comenzar a utilizar
+herramientas más rápidas
+
+00:21.240 --> 00:23.440
+para trabajar con nuestros controles de
+versiones.
+
+00:23.440 --> 00:27.800
+Y una de las herramientas más rápidas para
+todo esto es VS Code.
+
+00:27.800 --> 00:31.360
+Es decir, si yo ya estoy usando VS Code
+para programar,
+
+00:31.360 --> 00:35.760
+bueno, sería muchísimo más fácil utilizar
+esa misma herramienta
+
+00:35.760 --> 00:41.200
+para naturalmente hacer mis commits y
+subir mis cambios a las ramas que yo necesite, ¿cierto?
+
+00:41.200 --> 00:45.160
+En esta clase vamos a ver cómo podemos
+aprender a utilizar
+
+00:45.160 --> 00:48.280
+todo lo que estuvimos haciendo con Git en
+líneas de comandos,
+
+00:48.280 --> 00:50.400
+pero ahora desde Visual Studio Code.
+
+00:50.400 --> 00:56.600
+Dentro de mi terminal, lo único que
+necesito escribir es el comando code espacio punto.
+
+00:56.600 --> 01:00.520
+Esto va a hacer que una nueva instancia de
+Visual Studio Code se abra,
+
+01:00.520 --> 01:06.320
+pero gracias a ese pequeño punto se va a
+abrir en la ubicación donde estaba mi terminal.
+
+01:06.320 --> 01:10.920
+Esto quiere decir con todos los archivos
+que he estado trabajando dentro de Git.
+
+01:10.920 --> 01:16.280
+Cierro la ventana de bienvenida y aquí
+puedo ubicar dentro de Visual Studio
+
+01:16.280 --> 01:18.160
+que hay una parte que dice
+Main.
+
+01:18.160 --> 01:23.360
+Esta es la rama con la cual estoy
+trabajando dentro de este proyecto.
+
+01:23.360 --> 01:29.120
+Si yo la selecciono, hay varias opciones
+que me aparecen como las otras ramas disponibles
+
+01:29.120 --> 01:32.880
+o crear la posibilidad de una nueva rama.
+
+01:32.880 --> 01:38.000
+Entonces voy a cerrar este mensaje por
+ahora y darme cuenta que además de esto,
+
+01:38.000 --> 01:41.040
+tengo el ícono de control de versiones aquí.
+
+01:41.040 --> 01:47.400
+Si yo lo selecciono, el control de
+versiones que he estado utilizando con Git Log
+
+01:47.400 --> 01:51.560
+para ver todo mi historial se muestra de
+una forma mucho más visual.
+
+01:51.560 --> 01:56.880
+Aquí en color azul vas a poder ver la rama
+Main, la rama principal,
+
+01:56.880 --> 02:02.960
+y en determinados colores que Visual
+Studio Code selecciona de manera aleatoria,
+
+02:02.960 --> 02:04.280
+hay varias
+fusiones.
+
+02:04.280 --> 02:09.440
+Por ejemplo, aquí estaba una rama cuando
+fue insertada desde Dev.
+
+02:09.440 --> 02:13.880
+Aquí hay otra rama y aquí hay otras
+fusiones de varias ramas.
+
+02:13.880 --> 02:16.600
+De acuerdo al historial que yo tenga,
+
+02:16.600 --> 02:20.640
+es cómo va a estarse desplegando toda esta
+pequeña gráfica.
+
+02:20.640 --> 02:24.480
+Mucho más cómoda de ver que un Git Log,
+¿cierto?
+
+02:24.480 --> 02:27.800
+Lo que voy a hacer a continuación es
+causar el mismo conflicto
+
+02:27.800 --> 02:30.440
+de la clase anterior dentro de Visual
+Studio Code
+
+02:30.440 --> 02:33.400
+para ver cómo resolverlo con esta herramienta.
+
+02:33.400 --> 02:40.440
+Voy a crear un nuevo archivo que se llame
+CodeConflict.txt.
+
+02:41.960 --> 02:47.600
+Y aquí voy a escribir hola desde Visual
+Studio Code
+
+02:47.600 --> 02:50.600
+para no hablar de ramas por este momento.
+
+02:50.600 --> 02:55.520
+Lo mágico de Visual Studio Code es que
+ahora el control de versiones
+
+02:55.520 --> 03:01.000
+ya me pone un número uno que dice que
+tengo un cambio pendiente por agregar.
+
+03:01.000 --> 03:05.200
+Esto significa que en lugar de escribir
+git commit m,
+
+03:05.200 --> 03:12.920
+ahora puedo poner aquí archivo agregado y
+presiono commit.
+
+03:15.400 --> 03:18.960
+Listo, en mi historial ahora aparece
+archivo agregado
+
+03:18.960 --> 03:21.600
+como el último cambio
+realizado.
+
+03:21.600 --> 03:26.600
+Voy a cerrar el archivo y voy a regresar a
+mi explorador de archivos.
+
+03:26.600 --> 03:32.200
+Aquí ya que yo tengo CodeConflict, voy a
+crear una nueva rama
+
+03:32.200 --> 03:40.400
+y la voy a llamar en create new branch
+vsCodeDev.
+
+03:40.400 --> 03:46.000
+Ahora vsCodeDev aparece como la rama en la
+que estoy actualmente trabajando.
+
+03:46.000 --> 03:49.000
+Quiere decir que si abro CodeConflict,
+
+03:49.000 --> 03:52.800
+naturalmente los cambios desde main
+heredados están aquí.
+
+03:52.800 --> 03:56.000
+Yo necesito agregar cualquier leyenda.
+
+03:56.000 --> 04:00.000
+Cambios desde mi rama local podemos poner.
+
+04:00.000 --> 04:03.800
+Y con estos cambios
+realizados,
+
+04:03.800 --> 04:06.800
+gracias a que mi configuración de Visual
+Studio Code
+
+04:06.800 --> 04:11.000
+lo hace el guardado automático, puedo
+cerrar este archivo
+
+04:11.000 --> 04:14.000
+y sin embargo ya en mi control de
+versiones
+
+04:14.000 --> 04:17.000
+aparece un pequeño número
+1,
+
+04:17.000 --> 04:20.000
+indicándome que hay un cambio por guardar.
+
+04:20.000 --> 04:23.000
+Si yo selecciono
+CodeConflict,
+
+04:23.000 --> 04:27.000
+voy a ver visualmente una gran ventaja de
+vsCode,
+
+04:27.000 --> 04:30.000
+cuáles son los cambios que estoy ejecutando.
+
+04:30.000 --> 04:33.000
+El color verde son los cambios realizados.
+
+04:33.000 --> 04:36.000
+Y aquí aparecen cambios desde mi rama
+local
+
+04:36.000 --> 04:39.000
+y solo necesito presionar
+commit.
+
+04:39.000 --> 04:43.000
+Listo, mis cambios están realizados.
+
+04:43.000 --> 04:49.000
+Voy a regresar ahora a mi rama de
+vsCodeDev main.
+
+04:49.000 --> 04:52.000
+Con la rama main
+seleccionada,
+
+04:52.000 --> 04:56.000
+regreso a mis archivos, puedo cerrar esta
+parte del historial,
+
+04:56.000 --> 04:59.000
+y en CodeConflict,
+naturalmente,
+
+04:59.000 --> 05:02.000
+no tengo el cambio realizado de mi rama local.
+
+05:02.000 --> 05:05.000
+Aquí en main, ahora voy a
+poner...
+
+05:05.000 --> 05:11.000
+cambios desde mi rama
+principal,
+
+05:12.000 --> 05:15.000
+para tener alguna
+actualización.
+
+05:15.000 --> 05:18.000
+Con esto, el control de versiones me
+dice
+
+05:18.000 --> 05:21.000
+que también tengo que ingresar estos cambios,
+y lo hago.
+
+05:25.000 --> 05:28.000
+Ingreso estos
+cambios,
+
+05:29.000 --> 05:32.000
+espero un segundo, y ahora sí, los tengo
+listos.
+
+05:32.000 --> 05:37.000
+Tengo dos cambios de dos ramas realizadas
+en el mismo archivo,
+
+05:37.000 --> 05:40.000
+lo que naturalmente puede causar un conflicto.
+
+05:40.000 --> 05:44.000
+En lugar de escribir el comando git merge
+dentro de una terminal,
+
+05:44.000 --> 05:48.000
+aquí selecciono los tres puntos de Visual
+Studio Code,
+
+05:48.000 --> 05:51.000
+y me voy a branch,
+merge,
+
+05:52.000 --> 05:55.000
+y selecciono la rama en la que quiero
+trabajar
+
+05:55.000 --> 05:59.000
+o que quiero fusionar con main, vsCodeDev.
+
+05:59.000 --> 06:02.000
+Aquí me aparece un
+conflicto.
+
+06:02.000 --> 06:06.000
+Me aparece también una pop-up diciendo que
+hay algunos conflictos de merge,
+
+06:06.000 --> 06:11.000
+y que necesito resolverlos antes de poder
+hacer un commit.
+
+06:11.000 --> 06:15.000
+Selecciono Merge los cambios, y aquí están
+los cambios.
+
+06:15.000 --> 06:18.000
+A diferencia de trabajar con la terminal,
+
+06:18.000 --> 06:21.000
+Visual Studio Code le pone colores a las
+opciones,
+
+06:21.000 --> 06:24.000
+y me aparece aquí, además de
+head,
+
+06:24.000 --> 06:27.000
+entre paréntesis, el cambio
+actual.
+
+06:27.000 --> 06:31.000
+El cambio que estoy intentando aceptar.
+
+06:31.000 --> 06:35.000
+Y podría desde aquí mismo seleccionar
+Aceptar Current Change
+
+06:35.000 --> 06:38.000
+para seleccionar el cambio de
+main.
+
+06:38.000 --> 06:41.000
+Voy a presionar
+Control-Z,
+
+06:41.000 --> 06:44.000
+o podría seleccionar el Incoming Change,
+
+06:44.000 --> 06:48.000
+que es el cambio que viene desde la rama
+local.
+
+06:48.000 --> 06:51.000
+Control-Z, mejor
+todavía.
+
+06:51.000 --> 06:54.000
+Puedo seleccionar Aceptar ambos cambios.
+
+06:54.000 --> 06:57.000
+Y estos dos cambios
+permanecen.
+
+06:57.000 --> 07:00.000
+Dependiendo de cada escenario en donde
+estés trabajando,
+
+07:00.000 --> 07:04.000
+podrás seleccionar una de todas estas
+opciones.
+
+07:04.000 --> 07:07.000
+Una opción que también es muy cómoda para
+trabajar
+
+07:07.000 --> 07:11.000
+es que Visual Studio Code te pone aquí un
+botón que dice Resolver
+
+07:11.000 --> 07:14.000
+en el editor de
+merge,
+
+07:14.000 --> 07:17.000
+que lo hace un poco más cómodo visualmente
+quizá,
+
+07:17.000 --> 07:21.000
+en donde ves aquí la rama de vsCodeDev,
+
+07:21.000 --> 07:24.000
+y la rama de
+main.
+
+07:24.000 --> 07:27.000
+Tú puedes seleccionar ambas
+opciones
+
+07:27.000 --> 07:30.000
+para ver cuáles son los que tú quieras.
+
+07:30.000 --> 07:34.000
+Es decir, vamos a seleccionar la opción de
+Aceptar una combinación.
+
+07:34.000 --> 07:38.000
+Esto quiere decir que van a estar las dos
+actualizaciones
+
+07:38.000 --> 07:41.000
+a este archivo ya
+aquí.
+
+07:41.000 --> 07:44.000
+Selecciono la opción de Complete Merge,
+
+07:44.000 --> 07:47.000
+y en automático, si alcanzaste a ver,
+
+07:47.000 --> 07:50.000
+si no puedes regresar unos segundos,
+
+07:50.000 --> 07:53.000
+la opción de Commit se
+habilita,
+
+07:53.000 --> 07:56.000
+y me aparece un mensaje que dice Merge Branch.
+
+07:56.000 --> 07:59.000
+De nuevo, aquí podemos poner por Amin,
+
+07:59.000 --> 08:02.000
+para saber quién hizo esta
+fusión.
+
+08:02.000 --> 08:05.000
+Selecciono la opción de
+Commit,
+
+08:05.000 --> 08:08.000
+espero unos
+segundos,
+
+08:08.000 --> 08:11.000
+y no solamente se acaba la actualización,
+
+08:11.000 --> 08:14.000
+sino que también en mi gráfica ahora
+vienen cambios
+
+08:14.000 --> 08:17.000
+desde mi rama
+local,
+
+08:17.000 --> 08:20.000
+y se ve aquí
+visualmente.
+
+08:20.000 --> 08:23.000
+Mucho más cómodo que
+GitLog,
+
+08:23.000 --> 08:26.000
+y mucho más rápido que escribir todos
+estos comandos de la terminal.
+
+08:26.000 --> 08:28.000
+¿Cierto?
+
+08:28.000 --> 08:31.000
+Como puedes ver, Visual Studio Code te
+salva muchísimo tiempo,
+
+08:31.000 --> 08:34.000
+y te permite apoyarte en muchas
+referencias visuales.
+
+08:34.000 --> 08:37.000
+Sin embargo, también es necesario darnos
+cuenta
+
+08:37.000 --> 08:40.000
+de que hemos trabajado con Visual
+Studio
+
+08:40.000 --> 08:43.000
+en el mismo repositorio que hemos
+tenido
+
+08:43.000 --> 08:46.000
+durante toda nuestra experiencia con Git.
+
+08:46.000 --> 08:49.000
+Y es por eso que desde
+cero
+
+08:49.000 --> 08:52.000
+podemos crear este mismo repositorio en
+Visual Studio Code.
+
+08:52.000 --> 08:55.000
+Me acabo de crear una carpeta nueva desde
+cero
+
+08:55.000 --> 08:58.000
+que se llama Repo
+Nuevo.
+
+08:58.000 --> 09:01.000
+Creo que el nombre es bastante explícito.
+
+09:01.000 --> 09:04.000
+Aquí voy a crear el comando o escribir el
+comando Code,
+
+09:04.000 --> 09:07.000
+para darme cuenta que ahora que Visual
+Studio Code se abre,
+
+09:07.000 --> 09:10.000
+no tengo ningún
+archivo,
+
+09:10.000 --> 09:13.000
+cierro mi pantalla de
+inicio,
+
+09:13.000 --> 09:16.000
+y no tengo ningún control de versiones.
+
+09:16.000 --> 09:19.000
+Lo único que yo necesito hacer
+aquí
+
+09:19.000 --> 09:22.000
+es crear o presionar el botón de
+Inicializar Repositorio.
+
+09:22.000 --> 09:25.000
+Y todos estos comandos como git init,
+
+09:25.000 --> 09:28.000
+git config y todo lo que hicimos en clases
+anteriores
+
+09:28.000 --> 09:31.000
+fueron realizados a partir de un solo botón.
+
+09:31.000 --> 09:34.000
+Podrás darte cuenta que ya aparece la
+opción
+
+09:34.000 --> 09:37.000
+de publicar una rama si este repositorio
+estuviera en la nube.
+
+09:37.000 --> 09:40.000
+Aparece por defecto la rama
+main
+
+09:40.000 --> 09:43.000
+como la rama principal de este repositorio.
+
+09:43.000 --> 09:46.000
+Y aquí yo puedo comenzar a
+crear
+
+09:46.000 --> 09:49.000
+todas las ramas que necesite sin ningún
+problema.
+
+09:49.000 --> 09:52.000
+Con este último ejercicio podemos dar por
+concluida
+
+09:52.000 --> 09:55.000
+toda la experiencia de Git en un entorno
+local.
+
+09:55.000 --> 09:58.000
+Ya hemos aprendido muchos comandos dentro
+de la terminal
+
+09:58.000 --> 10:01.000
+y también hemos visto cómo
+trasladar
+
+10:01.000 --> 10:04.000
+esos comandos a VS
+Code.
+
+10:04.000 --> 10:07.000
+De esta forma, tú tienes la posibilidad de
+que cada proyecto nuevo
+
+10:07.000 --> 10:10.000
+que comiences a
+desarrollar
+
+10:10.000 --> 10:13.000
+tenga la oportunidad de mantener un
+control de versiones.
+
+10:13.000 --> 10:16.000
+Lo que no solo a ti, sino a las posibles
+personas
+
+10:16.000 --> 10:19.000
+que trabajen en equipo
+contigo,
+
+10:19.000 --> 10:22.000
+les da la posibilidad de colaborar con
+todo lo que acabas de aprender
+
+10:22.000 --> 10:25.000
+sin mayor
+problema.
+
+10:25.000 --> 10:28.000
+En los siguientes módulos lo que vamos a
+hacer es utilizarlo ya aprendido en Git
+
+10:28.000 --> 10:31.000
+pero llevándolo a la nube gracias a la
+plataforma de GitHub.
+
+10:31.000 --> 10:37.000
+Nos vemos en esas siguientes clases.
+
diff --git a/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/09-Quiz.mhtml b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/09-Quiz.mhtml
new file mode 100644
index 0000000000000000000000000000000000000000..b20834d30cb87d497217628ff621fcac92937d43
--- /dev/null
+++ b/Curso de Git y GitHub/01-Fundamentos de Git y control de versiones/09-Quiz.mhtml
@@ -0,0 +1,13243 @@
+From:
+Snapshot-Content-Location: https://platzi.com/clases/quiz/21258/
+Subject:
+Date: Sat, 8 Nov 2025 15:33:12 -0500
+MIME-Version: 1.0
+Content-Type: multipart/related;
+ type="text/html";
+ boundary="----MultipartBoundary--m6oOAkzs5UAcvR8csjzTbTRUgpol4ictKTUj3VWRTQ----"
+
+
+------MultipartBoundary--m6oOAkzs5UAcvR8csjzTbTRUgpol4ictKTUj3VWRTQ----
+Content-Type: text/html
+Content-ID:
+Content-Transfer-Encoding: quoted-printable
+Content-Location: https://platzi.com/clases/quiz/21258/
+
+
+ =20
+
+ =20
+
+
+
+
+
+
+
+
+
+
+
+ =20
+
+ =20
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ =20
+ =20
+ =20
+
+ =20
+
+ =20
+
+
+ =20
+
+ =20
+
+
+
+ =20
+
+
+ =20
+ =20
+ =20
+
+
+
La colaboración en proyectos de software depende de sistemas de control de versiones, y Git es una herramienta central para lograrlo. Usar GitHub, una plataforma en la nube basada en Git, permite que los desarrolladores compartan sus proyectos, trabajen en equipo y accedan a herramientas avanzadas para asegurar y escalar sus desarrollos. Con un enfoque en inteligencia artificial (IA), colaboración, productividad, seguridad y escalabilidad, GitHub ha pasado de ser una red social de programadores a una herramienta integral que optimiza el desarrollo de software moderno.
+
¿Qué opciones existen para hospedar proyectos en Git?
+
+
GitHub: la plataforma más destacada, adquirida por Microsoft en 2018, ofrece amplias herramientas de colaboración y desarrollo.
+
Bitbucket (Atlassian), GitLab, Azure DevOps (Microsoft), CodeCommit (Amazon), y Cloud Source (Google): todas permiten el control de versiones en la nube.
+
Servidores propios de Git: para quienes prefieren un ambiente privado y controlado.
+
+
¿Cómo ha evolucionado GitHub desde su lanzamiento?
+
Inicialmente, GitHub era un simple repositorio de código en la nube; sin embargo, ha evolucionado hasta ofrecer una plataforma avanzada que incluye una interfaz web, herramientas de línea de comandos y flujos de trabajo colaborativos. En lugar de limitarse a compartir proyectos, permite a los usuarios colaborar en tiempo real, automatizar tareas y utilizar inteligencia artificial para mejorar la seguridad y productividad del código.
+
¿Qué funcionalidades destacan en GitHub actualmente?
+
GitHub ahora integra IA y facilita procesos clave en el desarrollo de software mediante:
+
+
Colaboración eficiente: herramientas para trabajo en equipo, seguimiento de cambios y mejoras en el flujo de trabajo.
+
Automatización y productividad: automatiza tareas repetitivas, permitiendo a los desarrolladores enfocarse en resolver problemas complejos.
+
Seguridad integrada: herramientas avanzadas de seguridad que aseguran el código desde el inicio, minimizando riesgos.
+
Escalabilidad: una infraestructura robusta que permite gestionar millones de repositorios y usuarios globalmente.
+
+
¿Qué oportunidades brinda GitHub para los desarrolladores?
+
Con GitHub, cualquier desarrollador puede contribuir a proyectos relevantes, como mejoras en lenguajes de programación o incluso en el kernel de Linux. Esta capacidad de colaboración global eleva el nivel de la ingeniería de software, fomentando el trabajo en equipo entre profesionales de todo el mundo.
+
¿Cómo puede ayudarte GitHub en el desarrollo profesional?
+
Además de ser una herramienta de colaboración y desarrollo, GitHub ofrece la GitHub Foundation Certification, una certificación ideal para validar habilidades en GitHub y dar un primer paso hacia un perfil profesional sólido en desarrollo colaborativo.
+
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/01-Uso de GitHub para Colaboraci\303\263n y Desarrollo Seguro.mp4" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/01-Uso de GitHub para Colaboraci\303\263n y Desarrollo Seguro.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..61b3f70ef543e90e774a97eab35d66eea5016588
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/01-Uso de GitHub para Colaboraci\303\263n y Desarrollo Seguro.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c8307d268509a8ab976f2a4202cd7b24b54783e41aacd59043b9bf8f2976ae0
+size 94277565
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/01-Uso de GitHub para Colaboraci\303\263n y Desarrollo Seguro.vtt" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/01-Uso de GitHub para Colaboraci\303\263n y Desarrollo Seguro.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..989a2f5473df955fdfb3a96d26cbc236b4a7311c
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/01-Uso de GitHub para Colaboraci\303\263n y Desarrollo Seguro.vtt"
@@ -0,0 +1,378 @@
+WEBVTT
+
+00:00.000 --> 00:02.840
+Hasta este momento hemos estado
+practicando con Git,
+
+00:02.840 --> 00:06.720
+lo que es fundamental para poder trabajar
+con el control de versiones
+
+00:06.720 --> 00:11.480
+sin importar exactamente el destino a
+donde nuestro código llegue.
+
+00:11.480 --> 00:14.720
+La verdad es que en un entorno productivo,
+
+00:14.720 --> 00:18.400
+nuestro proyecto se compartirá con otros
+compañeros de trabajo,
+
+00:18.400 --> 00:22.680
+pues al final del día ese es el objetivo
+máximo de todo esto.
+
+00:22.680 --> 00:26.920
+Y aquí hay un sinfín de opciones, para
+todos los gustos.
+
+00:26.920 --> 00:32.440
+GitHub es una plataforma en la nube que
+usa Git como su núcleo.
+
+00:32.440 --> 00:37.360
+Básicamente, es el lugar en donde puedes
+subir todos tus repositorios de Git
+
+00:37.360 --> 00:42.000
+para que otras personas puedan usarlo y
+trabajar de manera colaborativa
+
+00:42.000 --> 00:43.560
+en tus proyectos de
+software.
+
+00:43.560 --> 00:47.320
+Además de GitHub, existen las suites de
+Atleasian,
+
+00:47.320 --> 00:51.120
+que gracias a Bitbucket te permite
+hospedar ahí tu código.
+
+00:51.120 --> 00:55.480
+Tienes GitLab, que es una plataforma muy
+conocida para lo mismo.
+
+00:55.480 --> 00:59.800
+Azure DevOps de Microsoft, CodeCommit de
+Amazon,
+
+00:59.800 --> 01:03.320
+Cloud Source de Google y muchísimos más.
+
+01:03.320 --> 01:08.080
+Es más, hasta podrías crear tu propio
+servidor de control de versiones
+
+01:08.080 --> 01:09.400
+si así lo
+quisieras.
+
+01:09.400 --> 01:12.200
+Pero de todo este buffet de opciones,
+
+01:12.200 --> 01:15.920
+hay una opción que destaca por mucho de
+todas las demás.
+
+01:15.920 --> 01:16.920
+GitHub.
+
+01:16.920 --> 01:20.400
+GitHub fue lanzado en febrero del
+2008
+
+01:20.400 --> 01:23.880
+y se convirtió en una referencia tan
+grande
+
+01:23.880 --> 01:28.000
+que solo 10 años después, Microsoft lo compró.
+
+01:28.000 --> 01:32.520
+La cuestión es que el GitHub que salió al
+mercado
+
+01:32.520 --> 01:35.160
+ha evolucionado
+drásticamente.
+
+01:35.160 --> 01:39.720
+Antes, solo consistía en un lugar donde
+podías colocar tu código.
+
+01:39.720 --> 01:41.240
+Y ya, solo
+eso.
+
+01:41.240 --> 01:46.360
+Con el tiempo, ha agregado una cantidad de
+funcionalidad muy grande.
+
+01:46.360 --> 01:51.360
+La plataforma de GitHub simplifica el
+proceso de colaboración en proyectos
+
+01:51.360 --> 01:56.000
+y proporciona una plataforma web,
+herramienta de líneas de comandos
+
+01:56.000 --> 02:00.200
+y un flujo de trabajo que permite a los
+desarrolladores y usuarios
+
+02:00.200 --> 02:01.760
+trabajar
+juntos.
+
+02:01.760 --> 02:05.720
+Ninguna persona que programe puede
+discutir lo importante
+
+02:05.720 --> 02:08.920
+que esta plataforma se ha vuelto para el
+software.
+
+02:08.920 --> 02:12.600
+Al principio, muchos lo veían como una
+especie de red social
+
+02:12.600 --> 02:15.640
+para programadores en donde podías conocer
+gente,
+
+02:15.640 --> 02:18.360
+podías seguir su perfil y actividad.
+
+02:18.360 --> 02:21.600
+Así como presumir la tuya con el
+famoso
+
+02:21.600 --> 02:24.200
+rectángulo de actividad de
+GitHub.
+
+02:24.200 --> 02:27.480
+Pero podría apostar a que los mismos
+creadores
+
+02:27.480 --> 02:30.560
+se dieron cuenta de que ese no era el
+rumbo que querían
+
+02:30.560 --> 02:35.360
+y comenzaron a pensar en cómo hacerlo más
+una herramienta eficiente
+
+02:35.360 --> 02:38.600
+que un lugar en donde podías conocer a
+otros programadores
+
+02:38.600 --> 02:41.680
+como básicamente en cualquier otra red social.
+
+02:41.680 --> 02:45.160
+Actualmente, GitHub ofrece una plataforma
+de desarrollo
+
+02:45.160 --> 02:47.520
+impulsada por inteligencia
+artificial
+
+02:47.520 --> 02:52.040
+para construir, escalar y entregar
+software seguro.
+
+02:52.040 --> 02:55.320
+Todo esto se basa en cuatro pilares
+fundamentales
+
+02:55.320 --> 02:58.200
+de la plataforma GitHub
+Enterprise.
+
+02:58.200 --> 03:03.840
+AI, colaboración, productividad, seguridad
+y escalabilidad.
+
+03:03.840 --> 03:06.720
+En cuanto a AI, la inteligencia
+artificial
+
+03:06.720 --> 03:08.960
+está transformando el desarrollo de software,
+
+03:08.960 --> 03:13.120
+mejorando la colaboración, productividad y
+seguridad
+
+03:13.120 --> 03:14.720
+en GitHub
+Enterprise.
+
+03:14.720 --> 03:18.360
+Como colaboración, GitHub facilita una
+colaboración
+
+03:18.360 --> 03:21.800
+eficiente con herramientas que aceleran el
+trabajo en equipo
+
+03:21.800 --> 03:23.680
+y la entrega de
+proyectos.
+
+03:23.680 --> 03:27.640
+En cuanto a productividad, GitHub
+automatiza las tareas rutinarias,
+
+03:27.640 --> 03:30.400
+permitiendo a los desarrolladores
+centrarse
+
+03:30.400 --> 03:32.560
+en crear soluciones
+innovadoras.
+
+03:32.560 --> 03:35.760
+GitHub integra la seguridad desde el inicio,
+
+03:35.760 --> 03:39.560
+manteniendo el código protegido y
+reduciendo riesgos
+
+03:39.560 --> 03:41.440
+con herramientas
+avanzadas.
+
+03:41.440 --> 03:43.720
+Y por último, la
+escalabilidad.
+
+03:43.720 --> 03:46.160
+Con millones de usuarios y repositorios,
+
+03:46.160 --> 03:48.720
+GitHub adapta su plataforma para
+satisfacer
+
+03:48.720 --> 03:51.520
+las necesidades cambiantes de los
+desarrolladores.
+
+03:51.520 --> 03:55.440
+Lo que para mí ahora es lo más atractivo
+de GitHub
+
+03:55.440 --> 03:57.600
+es que puedes contribuir a
+proyectos
+
+03:57.600 --> 04:00.440
+que antes requerían que buscaras muchísimo.
+
+04:00.440 --> 04:03.640
+Ahora puedes contribuir sin ningún
+problema
+
+04:03.640 --> 04:06.440
+a los paquetes que usas para tus proyectos,
+
+04:06.440 --> 04:09.280
+a la mejora de lenguajes de
+programación
+
+04:09.280 --> 04:11.920
+o hasta el mismísimo kernel de Linux.
+
+04:11.920 --> 04:15.080
+Es decir, puedes ir al nivel de ingeniería
+de software
+
+04:15.080 --> 04:16.560
+que tú
+desees.
+
+04:16.560 --> 04:18.840
+A título personal, esto me
+encanta.
+
+04:18.840 --> 04:22.120
+Para mí, no hay un nivel de ingeniería más
+retador
+
+04:22.120 --> 04:24.720
+que contribuir con la creación de nuevos
+productos
+
+04:24.720 --> 04:28.320
+y, mejor aún, hacerlo de manera colaborativa,
+
+04:28.320 --> 04:32.920
+en equipo, con profesionales de todos los
+rincones del mundo.
+
+04:32.920 --> 04:37.200
+Ahora, antes de verte como el siguiente
+gran constructor
+
+04:37.200 --> 04:39.080
+de todos estos
+productos,
+
+04:39.080 --> 04:41.520
+siempre hay un primer paso para dar,
+
+04:41.520 --> 04:45.080
+y ese es conocer todas las herramientas y
+ventajas
+
+04:45.080 --> 04:46.520
+que GitHub te
+da.
+
+04:46.520 --> 04:49.080
+Y considera que este curso no solo es para
+aprender,
+
+04:49.080 --> 04:50.880
+sino también para
+prepararte
+
+04:50.880 --> 04:54.320
+para la certificación de GitHub Foundation
+Certification,
+
+04:54.320 --> 04:56.720
+que es un gran primer
+paso.
+
+04:56.720 --> 04:59.120
+Es momento de avanzar y continuar con los
+temas
+
+04:59.120 --> 05:01.920
+porque hay bastante por
+practicar.
+
+05:01.920 --> 05:04.840
+Y desde esta misma clase podemos comenzar.
+
+05:04.840 --> 05:07.240
+Visita el repositorio que usaremos de
+base
+
+05:07.240 --> 05:09.320
+para muchos temas por
+venir.
+
+05:09.320 --> 05:11.720
+Puedes ir al enlace que te
+dejamos
+
+05:11.720 --> 05:39.120
+en los recursos de esta
+clase.
+
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/02-Creaci\303\263n y configuraci\303\263n de cuenta GitHub paso a paso.mp4" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/02-Creaci\303\263n y configuraci\303\263n de cuenta GitHub paso a paso.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..3b5e95b34c8507ab5176eafda92e794e53645de7
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/02-Creaci\303\263n y configuraci\303\263n de cuenta GitHub paso a paso.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7bba73de0980773ecd6063db440eac10c50ad3dfac0f8a06e60cf9dc65d22bf1
+size 88687443
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/02-Creaci\303\263n y configuraci\303\263n de cuenta GitHub paso a paso.vtt" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/02-Creaci\303\263n y configuraci\303\263n de cuenta GitHub paso a paso.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..a273f4a4f1bff8cb0ae428caabbb54a7ac333b60
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/02-Creaci\303\263n y configuraci\303\263n de cuenta GitHub paso a paso.vtt"
@@ -0,0 +1,433 @@
+WEBVTT
+
+00:00.300 --> 00:05.238
+Ya que sabemos que es GitHub. Es momento
+de crear la cuenta que vamos a estar utilizando para
+
+00:05.250 --> 00:09.970
+crear tus repositorios y para utilizar
+todas las herramientas que quedan por ver en el resto de
+
+00:09.978 --> 00:16.620
+este curso. Una vez que entres a GitHub
+com en la pantalla, se verá la presentación del producto
+
+00:17.000 --> 00:22.010
+Lo que a nosotros nos interesa es este botón
+Arriba a la derecha, que dice Sign up
+
+00:22.839 --> 00:26.818
+lo seleccionas y te llevará a la sección de crear una cuenta.
+
+00:27.289 --> 00:31.228
+Aquí te dice Bienvenido a GitHub.
+Vamos a comenzar con la aventura.
+
+00:31.609 --> 00:35.298
+Ingresa tu email. Voy a colocar el email personal.
+
+00:35.310 --> 00:39.368
+Naturalmente, puedes colocar el correo electrónico que tú desees.
+
+00:40.029 --> 00:44.819
+Presiona el botón de continuar.
+Escribe el Password que más te guste.
+
+00:45.209 --> 00:48.090
+Este Password debe de tener cierto nivel de seguridad.
+
+00:49.368 --> 00:53.009
+Presiona continuo y después ingresa el User Name.
+
+00:53.579 --> 00:59.259
+Yo voy a poner Amin Espinoza cuarenta
+y tres sólo para poner algún número que sepa
+
+00:59.450 --> 01:02.329
+pero puedes poner obviamente, el usuario que más te guste.
+
+01:03.000 --> 01:07.189
+Aquí está una opción que dice Amin
+Espinosa43 está disponible.
+
+01:07.719 --> 01:10.819
+Cuando tu usuario esté disponible, presiona continuo.
+
+01:12.448 --> 01:18.469
+Después puedes seleccionar si quieres recibir
+o no información ocasional de los productos de GitHub
+
+01:18.849 --> 01:22.319
+Yo lo dejaré en blanco y puedes dejar la decisión que más te guste.
+
+01:22.790 --> 01:29.480
+Presiona continuo para avanzar. GitHub
+te va a verificar que somos humanos en
+
+01:29.489 --> 01:36.028
+lugar de robots creando cuentas aleatorias.
+El acertijo aquí me dice que debo de buscar dos como
+
+01:36.168 --> 01:41.349
+personitas. Selecciono la opción
+adecuada en donde están estas dos personas.
+
+01:41.439 --> 01:45.430
+Y pongo submit este acertijo es probable que lo tengas que hacer.
+
+01:45.510 --> 01:52.088
+Tres ocasiones te está pidiendo dos pandas. Y aquí está.
+
+01:53.480 --> 01:59.500
+Avanzas al tercer par a la tercera
+parte y que no debe haber estrellas, submit.
+
+02:01.838 --> 02:06.849
+Una vez que hayas concluido la
+verificación de que si eres humano, entonces GitHub te va
+
+02:06.859 --> 02:10.129
+a mandar un código de verificación al correo que tú pusiste.
+
+02:11.179 --> 02:16.330
+Abre tu bandeja de correo electrónico
+y habrás recibido un correo de GitHub con un código que tienes
+
+02:16.338 --> 02:22.379
+que colocar aquí. En mi
+caso, el código es 89076079
+
+02:25.050 --> 02:29.758
+y listo. Ya me manda a la pantalla
+en donde debo de ingresar con mi cuenta.
+
+02:37.240 --> 02:42.479
+Escribe el nombre de usuario que
+elegiste y también el Password que selecciona al momento
+
+02:42.490 --> 02:51.919
+de crear tu cuenta. Sing in lo primero que
+GitHub va a hacer al identificar que eres un usuario
+
+02:51.929 --> 02:57.118
+nuevo es establecer un pequeño cuestionario
+para saber quién eres y qué tipo de perfil tienes
+
+02:57.528 --> 03:03.599
+Me pregunta qué tipo de persona soy yo.
+Si soy alguien que no aplica un estudiante
+
+03:03.610 --> 03:07.580
+o un profesor, soy alguien que no aplica después.
+
+03:07.588 --> 03:10.979
+Cuántos miembros en mi equipo están trabajando conmigo?
+
+03:11.179 --> 03:18.118
+Puedo poner que de dos a cinco continuar
+en qué elementos estás específicamente
+
+03:18.129 --> 03:23.250
+interesado tú aquí siempre. En todas mis
+cuentas suelo seleccionar todo.
+
+03:23.500 --> 03:28.088
+Puedes escoger naturalmente las opciones
+que más te gusten de todas estas opciones
+
+03:28.319 --> 03:32.558
+GitHub te va a dar la información que más
+te acomode para crear tu perfil.
+
+03:33.210 --> 03:38.808
+Después te pedirá crear un tipo de cuenta
+o las diferencias entre estos tipos de cuenta
+
+03:39.080 --> 03:42.500
+ya sea una versión gratuita o una versión de equipo.
+
+03:42.929 --> 03:49.960
+Yo voy a seleccionar la opción de gratuita.
+Una vez que tú hayas seleccionado la opción
+
+03:49.969 --> 03:54.528
+que más te haya gustado, entonces estás
+en la pantalla de Home de tu cuenta.
+
+03:54.919 --> 03:59.618
+A partir de ahora, tú vas a poder
+comenzar a navegar en tu perfil para poder personalizarlo de
+
+03:59.629 --> 04:05.778
+la mejor manera posible para poder personalizar
+tu perfil de la forma que más te guste, puedes irte
+
+04:05.788 --> 04:10.939
+a la extrema derecha aquí arriba,
+en donde está tu foto de perfil recién creado y
+
+04:10.949 --> 04:14.368
+en las opciones, selecciona la categoría de Settings.
+
+04:16.399 --> 04:19.608
+Aquí puedes personalizar el perfil de la forma que más te guste.
+
+04:19.959 --> 04:25.170
+Escribe, por ejemplo, un nombre mucho
+más común que simplemente tu nombre de usuario
+
+04:25.819 --> 04:30.660
+Puedes también seleccionar el correo
+electrónico que vas a desplegar en la biografía
+
+04:30.670 --> 04:38.920
+Puedes escribir lo que más te guste.
+Después puedes tener campos como agregar la URL de algún sitio
+
+04:38.928 --> 04:44.540
+web que tú tengas. Si lo tienes,
+sería fantástico que lo agregues, así como las redes
+
+04:44.548 --> 04:48.548
+sociales que tú tienes. De esta forma,
+tu perfil lucirá un poco más completo.
+
+04:49.290 --> 04:53.379
+Además de todo eso, puedes también
+poner la compañía en la que estás trabajando
+
+04:54.230 --> 04:59.949
+incluso además de poner el nombre,
+podrías ubicarla si ya también de esta compañía
+
+05:00.149 --> 05:04.720
+tiene un perfil de GitHub. Me parece que la mía sí lo tiene.
+
+05:04.988 --> 05:10.579
+Entonces lo puedo agregar con una arroba.
+Después de todo esto, no olvides presionar el
+
+05:10.588 --> 05:15.619
+botón de actualizar perfil en color
+verde que está aquí porque si no todos sus cambios
+
+05:15.790 --> 05:20.730
+al momento de refrescar la página
+se perderán. También puedes modificar tu foto de
+
+05:20.738 --> 05:27.290
+perfil, seleccionar la opción de Edit,
+subir una nueva fotografía y aquí tengo
+
+05:27.298 --> 05:35.040
+una foto de perfil que puedo utilizar.
+Puedes seleccionarla para ubicar la forma y el área que más
+
+05:35.048 --> 05:39.459
+te guste y confirmas subir esta imagen, recuerda.
+
+05:39.738 --> 05:44.980
+Ya que lo hayas hecho, también puedes
+seleccionar la opción de actualizar el perfil sólo
+
+05:44.988 --> 05:49.838
+para garantizar que todo está en orden,
+ya que todo tu perfil está actualizado
+
+05:49.850 --> 05:52.738
+y personalizado de la forma que más te haya gustado.
+
+05:53.059 --> 05:58.350
+Es momento de pasar a una parte
+que es muy importante la seguridad de tu cuenta.
+
+05:58.889 --> 06:03.338
+Es importante que tengas presente
+que tu cuenta de GitHub va a ser una cuenta muy
+
+06:03.350 --> 06:09.088
+importante que debes de cuidar y esto
+tiene sentido porque puede ser que en tu cuenta de GitHub estés
+
+06:09.100 --> 06:12.500
+trabajando como individuo y en proyectos individuales.
+
+06:12.889 --> 06:19.298
+Sin embargo, también puede ser que estés
+trabajando en proyectos en equipo y con código compartido
+
+06:19.588 --> 06:25.069
+lo que significa que si alguien entra
+a tu cuenta no sólo verás sus repositorios, sino también
+
+06:25.079 --> 06:29.369
+esos repositorios privados que
+nadie más tendría que acceder a ellos.
+
+06:29.730 --> 06:35.949
+Entonces, para poder hacer esto más
+seguro, vamos a habilitar la verificación en dos pasos
+
+06:36.309 --> 06:42.769
+y, ojo, un punto muy importante de
+todo esto es que no debemos utilizar nunca
+
+06:42.778 --> 06:48.048
+bajo ningún concepto, la verificación
+en dos pasos por medio de un SMS.
+
+06:48.428 --> 06:53.869
+En este caso, lo que vamos a hacer
+es utilizar la aplicación de GitHub para dispositivos móviles
+
+06:54.108 --> 06:59.769
+para garantizar la seguridad de
+nuestra cuenta. Descarga la aplicación desde Ios o
+
+06:59.778 --> 07:04.358
+Android de GitHub en tu dispositivo
+móvil. Una vez que lo hayas hecho, te va a
+
+07:04.369 --> 07:09.629
+pedir tu usuario y contraseña.
+De esta manera, cuando ingreses estos dos datos te
+
+07:09.639 --> 07:16.798
+aparecerá una pantalla muy similar
+a ésta. Aquí te está pidiendo autorización a utilizar
+
+07:17.088 --> 07:22.769
+tu cuenta dentro de tu dispositivo
+con GitHub Android Desplázate un poco hacia abajo
+
+07:22.778 --> 07:29.178
+y aquí viene la opción de autorizar
+GitHub Cuando lo hayas autorizado en tu pantalla de
+
+07:29.189 --> 07:34.569
+GitHub vas a ver los repositorios,
+organizaciones y todo lo que tengas con tu cuenta
+
+07:34.579 --> 07:40.608
+recién habilitada. Es momento de regresar
+al sitio web en donde vamos a habilitar la verificación
+
+07:40.619 --> 07:45.199
+en dos pasos de vuelta al perfil web
+de nuestra cuenta recién creada de GitHub.
+
+07:45.309 --> 07:50.769
+Ahora lo que necesito es seleccionar
+otra vez mi perfil y la categoría de Settings.
+
+07:52.309 --> 07:55.678
+Aquí dentro de todas las opciones
+que me aparecen a la izquierda.
+
+07:55.879 --> 07:59.108
+La que quiero seleccionar es Password y autenticación.
+
+07:59.959 --> 08:04.428
+Cuando hayas llegado a esta sección
+vas a poder ver que hay una categoría de Passkeys
+
+08:04.720 --> 08:10.750
+y un poco más abajo verás la de autenticación
+en dos pasos te aparece un código
+
+08:10.759 --> 08:15.548
+QR que debes escanear. Con una aplicación
+de autenticación puedes utilizar aplicaciones
+
+08:15.559 --> 08:20.149
+de autenticación como One Password,
+Authy, Microsoft Authenticator, etc.
+
+08:20.709 --> 08:24.709
+Si no sabes cómo utilizar estas aplicaciones,
+te dejo en los recursos de la clase un
+
+08:24.720 --> 08:27.119
+video de referencia para que puedas aprender a hacerlo.
+
+08:27.678 --> 08:34.129
+En mi caso, yo voy a utilizar Microsoft Authenticator,
+con el código que ya tienes escaneado te va
+
+08:34.139 --> 08:37.168
+a dar la aplicación un código que tienes que ingresar aquí.
+
+08:37.668 --> 08:41.210
+Pondré el código que mi aplicación me está dando y listo.
+
+08:41.619 --> 08:47.129
+Ahora, ya que yo valide la autenticación
+en dos pasos, GitHub me da unos códigos
+
+08:47.139 --> 08:56.450
+de recuperación de mi cuenta. Estos
+códigos de recuperación de cuenta es importantísimo que sí
+
+08:56.460 --> 09:02.830
+Los descargues y cuando los tengas
+ descargados, los guardes en el lugar más valioso que tengas.
+
+09:03.029 --> 09:06.489
+Un disco duro externo, una cuenta en la nube o como tú quieras.
+
+09:06.830 --> 09:12.879
+Es una muy buena forma de validar que
+tú eres el propietario de tu cuenta de GitHub, ya que desgaste
+
+09:12.889 --> 09:19.450
+este archivo solamente selecciona el
+botón de que ya guardé estos códigos sin ningún problema y
+
+09:19.460 --> 09:23.239
+confeti. Tu identificación en dos pasos está lista.
+
+09:23.700 --> 09:31.070
+Ahora puedes establecer otros elementos,
+como por ejemplo la aplicación de GitHub Mobile, ya que descargaste
+
+09:31.080 --> 09:36.009
+tu archivo, selecciona el botón
+de done para regresar a la sección de seguridad.
+
+09:36.379 --> 09:42.678
+Ahora, si te desplazas un poco hacia abajo,
+vas a encontrar que la autenticación en dos pasos ya está
+
+09:42.690 --> 09:50.369
+habilitada y gracias a la sesión abierta
+previamente en tu dispositivo móvil, ahora GitHub establece
+
+09:50.668 --> 09:57.009
+el método de verificación en dos pasos
+preferido como tu aplicación de GitHub móvil.
+
+09:57.359 --> 10:03.500
+De hecho, también ya está habilitada
+aquí GitHub móvil y ya está configurada por defecto.
+
+10:04.119 --> 10:09.538
+La recomendación ideal es que
+mantengas esta secuencia de manera preestablecida
+
+10:09.739 --> 10:14.940
+es decir, que utilices tu aplicación
+de GitHub móvil como tu método de verificación de dos
+
+10:14.950 --> 10:20.009
+pasos preferido. Sin embargo, esto
+puede cambiar si tu empresa o la compañía en la que
+
+10:20.019 --> 10:23.239
+estás trabajando establece ciertas políticas de seguridad.
+
+10:24.139 --> 10:29.570
+Listo con tu cuenta de GitHub ya creada,
+es momento de comenzar a entender esa interacción entre Git
+
+10:29.580 --> 10:32.000
+GitHub en las siguientes clases. Nos vemos allá.
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/02-Lecturas recomendadas.txt" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/02-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..f7587de3f963189d653d7c54d2738e12151169df
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/02-Lecturas recomendadas.txt"
@@ -0,0 +1 @@
+https://github.com/
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/02-Resumen.html" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/02-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..914d0e7fa1072745a123f41f816a922737f534a0
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/02-Resumen.html"
@@ -0,0 +1,156 @@
+
+
+
+
+
+
+ Creación y configuración de cuenta GitHub paso a paso
+
+
+
+
+
+
Resumen
¿Cómo crear una cuenta en GitHub?
+
Ahora que comprendes qué es GitHub, es momento de comenzar a utilizarlo. Crear una cuenta te permite acceder a todas las herramientas que ofrece. A continuación, te mostraré cómo registrarte de manera sencilla.
+
+
+
Accede a GitHub: Ingresa a GitHub.com. Verás en la esquina superior derecha el botón "Sign up". Haz clic en él para comenzar el registro.
+
+
+
Proporciona tu información:
+
+
Email: Ingresa tu correo electrónico.
+
Contraseña: Escoge una contraseña segura.
+
Nombre de usuario: Selecciona uno que te guste y esté disponible.
+
+
+
+
Verificación de seguridad: Completa el acertijo de seguridad para confirmar que eres humano.
+
+
+
Verificación de email: GitHub enviará un código de verificación a tu email. Ingresa el código recibido para continuar.
+
+
+
Personalización de perfil: Navega a la sección "Settings" para personalizar tu perfil. Puedes agregar:
+
+
Nombre más común.
+
Información de contacto.
+
Redes sociales y sitio web.
+
Compañía donde trabajas si tiene perfil en GitHub.
+
+
+
+
No olvides guardar los cambios al actualizar el perfil.
+
¿Cómo garantizar la seguridad de tu cuenta de GitHub?
+
Proteger tu cuenta de GitHub es fundamental, no solo para ti, sino para toda la información y repositorios que manejes. La seguridad de tu cuenta se logra a través de la verificación en dos pasos.
+
¿Cómo activar la verificación en dos pasos?
+
+
+
Descarga la aplicación GitHub Mobile: Disponible en iOS y Android, esta app te ayudará a gestionar la seguridad.
+
+
+
Configura la aplicación móvil:
+
+
Ingresa tu usuario y contraseña en la app.
+
Autoriza el acceso.
+
+
+
+
Activa la verificación en dos pasos: En el sitio web de GitHub:
+
+
Accede a "Settings" y luego "Password and authentication".
+
Escanea el código QR con una app de autenticación (como Microsoft Authenticator).
+
Ingresa el código generado por la app para completar la verificación.
+
+
+
+
Guarda los códigos de recuperación: Son esenciales para recuperar el acceso si pierdes tu método de verificación. Guárdalos en un lugar seguro.
+
+
+
¿Por qué evitar la verificación por SMS?
+
Nunca uses SMS para la verificación en dos pasos, ya que son menos seguros. Opta siempre por apps de autenticación.
+
¿Cómo utilizar GitHub Mobile como método de verificación?
+
Gracias a la sincronización con la app móvil de GitHub, puedes establecerla como tu método preferido. Esto simplifica la verificación en dos pasos, asegurando tus proyectos y datos personales de manera eficiente.
+
Con tu cuenta de GitHub segura y configurada, es momento de explorar todo lo que puedes hacer y aprender más sobre su interacción con Git. Continúa explorando y codificando, ¡nos vemos en las próximas clases!
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/03-Lecturas recomendadas.txt" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/03-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..ac5269f9dc5175a408be708be0357f22ce935852
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/03-Lecturas recomendadas.txt"
@@ -0,0 +1 @@
+https://docs.github.com/es/get-started/start-your-journey
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/03-Proceso de Trabajo con Git y GitHub Creaci\303\263n y Revisi\303\263n de Repositorios.mp4" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/03-Proceso de Trabajo con Git y GitHub Creaci\303\263n y Revisi\303\263n de Repositorios.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..0fec29e6ebaf8bd801da467c274c4f4251ca0c0c
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/03-Proceso de Trabajo con Git y GitHub Creaci\303\263n y Revisi\303\263n de Repositorios.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b403a303a9297ec6b044736c06f46114fdc7260c37f7c0829d4cb6a5a0d900f7
+size 52665705
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/03-Proceso de Trabajo con Git y GitHub Creaci\303\263n y Revisi\303\263n de Repositorios.vtt" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/03-Proceso de Trabajo con Git y GitHub Creaci\303\263n y Revisi\303\263n de Repositorios.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..c994239a0b6cb1834bd535adf08f6f54cd229e3d
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/03-Proceso de Trabajo con Git y GitHub Creaci\303\263n y Revisi\303\263n de Repositorios.vtt"
@@ -0,0 +1,277 @@
+WEBVTT
+
+00:00.000 --> 00:02.760
+Ahora que ya tenemos nuestra cuenta en GitHub,
+
+00:02.760 --> 00:05.000
+es momento de hacer una pequeña
+pausa
+
+00:05.000 --> 00:06.880
+para poder platicar un
+poco
+
+00:06.880 --> 00:09.480
+de las dos herramientas de este curso.
+
+00:09.480 --> 00:11.280
+Por un lado tenemos a
+Git,
+
+00:11.280 --> 00:13.640
+que es una herramienta de control de
+versiones
+
+00:13.640 --> 00:15.160
+que se basa en
+comandos,
+
+00:15.160 --> 00:17.880
+pero que puede ser implementado con
+entornos gráficos
+
+00:17.880 --> 00:19.920
+como lo vimos con VS
+Code.
+
+00:19.920 --> 00:22.040
+Sin embargo, sus enormes
+capacidades
+
+00:22.040 --> 00:23.600
+fueron las que dieron la
+oportunidad
+
+00:23.600 --> 00:26.320
+para crear herramientas como GitHub.
+
+00:26.320 --> 00:28.600
+Y ya sé, los creadores de
+GitHub
+
+00:28.600 --> 00:32.240
+no se quebraron mucho la cabeza con el nombre,
+¿cierto?
+
+00:32.240 --> 00:35.560
+Vaya, a diferencia de lo que nos había
+pasado antes,
+
+00:35.560 --> 00:38.840
+con el eterno chiste de Java y
+JavaScript
+
+00:38.840 --> 00:41.560
+que no tienen absolutamente nada que ver,
+
+00:41.560 --> 00:44.240
+aquí la historia no se
+repite.
+
+00:44.240 --> 00:47.960
+Git y GitHub no tienen nada que ver entre
+ellos.
+
+00:47.960 --> 00:49.560
+Eso es
+cierto.
+
+00:49.560 --> 00:52.000
+GitHub usó el nombre para
+demostrar
+
+00:52.000 --> 00:53.800
+que el producto usaría
+Git,
+
+00:53.800 --> 00:55.600
+pero hasta
+ahí.
+
+00:55.600 --> 00:58.120
+Usas Git como control de versiones en GitHub.
+
+00:58.120 --> 01:02.440
+Lo que indica una relación que es lo único
+que los une.
+
+01:02.440 --> 01:06.400
+La relación, a pesar de ser pequeña,
+es indispensable.
+
+01:06.400 --> 01:09.400
+Lo importante es que gracias a que ya
+pasamos el módulo
+
+01:09.400 --> 01:12.400
+en el que platicamos únicamente de Git,
+
+01:12.400 --> 01:14.320
+entonces será mucho más
+cómodo
+
+01:14.320 --> 01:17.640
+aplicar todos estos conceptos en GitHub,
+
+01:17.640 --> 01:21.760
+en donde además podremos usar nuevos
+comandos de Git
+
+01:21.760 --> 01:24.520
+y mejorar mucho el crecimiento de nuestra
+solución
+
+01:24.520 --> 01:26.880
+por medio de ambas
+herramientas.
+
+01:26.880 --> 01:29.120
+Para poder entenderlo un poco mejor,
+
+01:29.120 --> 01:31.800
+es necesario explicar el proceso que
+usaremos
+
+01:31.800 --> 01:34.240
+de una manera muy
+general.
+
+01:34.240 --> 01:36.560
+¿Recuerdas el comando git
+init?
+
+01:36.560 --> 01:39.640
+Bueno, este será reemplazado por la
+creación
+
+01:39.640 --> 01:42.480
+de un repositorio en blanco de GitHub.
+
+01:42.480 --> 01:46.640
+Este repositorio será descargado a tu
+equipo de trabajo
+
+01:46.640 --> 01:50.160
+y ahí podrás comenzar a hacer todos los
+cambios.
+
+01:50.160 --> 01:52.200
+Cuando hayas terminado,
+entonces,
+
+01:52.200 --> 01:55.320
+podrás crear un commit para guardar tus
+cambios
+
+01:55.320 --> 01:58.760
+en un modo local y después vendrá la
+posibilidad
+
+01:58.760 --> 02:00.840
+de subir tus cambios a
+GitHub,
+
+02:00.840 --> 02:02.960
+pero como buenos
+profesionales,
+
+02:02.960 --> 02:05.520
+lo haremos con una rama
+separada.
+
+02:05.520 --> 02:08.240
+Cuando esa rama sea publicada en GitHub,
+
+02:08.240 --> 02:10.240
+entonces iniciaremos un
+proceso
+
+02:10.240 --> 02:13.800
+en donde otros compañeros revisarán
+nuestros cambios
+
+02:13.800 --> 02:15.320
+y los
+aprobarán.
+
+02:15.320 --> 02:18.560
+Este proceso es el Code
+Review.
+
+02:18.560 --> 02:21.080
+Con mis cambios aprobados por mis compañeros,
+
+02:21.080 --> 02:24.760
+entonces podré unir mi rama a la rama
+principal
+
+02:24.760 --> 02:28.400
+y con ello el ciclo habrá terminado
+solamente
+
+02:28.400 --> 02:31.440
+para ser reiniciado con una nueva
+actividad
+
+02:31.440 --> 02:32.920
+asignada para
+mí.
+
+02:32.920 --> 02:36.240
+Este proceso se reiniciará con cada una de
+las tareas
+
+02:36.240 --> 02:37.760
+que te sean
+asignadas.
+
+02:37.760 --> 02:41.880
+Lo ideal es que estas tareas sean lo más
+pequeñas posibles
+
+02:41.880 --> 02:44.560
+para hacerlas de una manera
+simple.
+
+02:44.560 --> 02:47.080
+Que el Code Review sea muy fácil de
+aprobar
+
+02:47.080 --> 02:49.960
+y que no cause conflictos al
+integrarse
+
+02:49.960 --> 02:51.920
+al resto del
+proyecto.
+
+02:51.920 --> 02:54.000
+Hay quienes inventan reglas al respecto,
+
+02:54.000 --> 02:58.040
+como que la tarea no debe tener más de un
+solo objetivo,
+
+02:58.040 --> 03:01.880
+que no debe modificar más de cierto número
+de archivos,
+
+03:01.880 --> 03:05.920
+cumplir con ciertas líneas de código y
+muchas variantes.
+
+03:05.920 --> 03:10.920
+A mí, la única que me gusta es la de una
+tarea, un objetivo.
+
+03:10.920 --> 03:14.600
+Y bueno, ya que conocemos el proceso
+completo en teoría,
+
+03:14.600 --> 03:17.560
+es momento de replicarlo paso a
+paso
+
+03:17.560 --> 03:24.560
+con todas las herramientas de GitHub.
+
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/03-Resumen.html" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/03-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..27d7437d383881d89baff39b88b744cd49f02dea
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/03-Resumen.html"
@@ -0,0 +1,113 @@
+
+
+
+
+
+
+ Proceso de Trabajo con Git y GitHub: Creación y Revisión de Repositorios
+
+
+
+
+
+
Resumen
Para entender cómo Git y GitHub funcionan en conjunto en un flujo de trabajo profesional, debemos recordar que Git es una herramienta de control de versiones basada en comandos, mientras que GitHub facilita su implementación al ofrecer una plataforma que permite manejar proyectos de Git de forma colaborativa y accesible en la nube.
+
¿Cuál es la relación entre Git y GitHub?
+
Aunque Git y GitHub son complementarios, no fueron creados por los mismos desarrolladores ni comparten una dependencia directa. Git es el sistema de control de versiones en sí mismo, mientras que GitHub es un servicio que permite alojar repositorios Git en la nube, facilitando el trabajo colaborativo. La única conexión entre ambos es que GitHub permite gestionar proyectos que usan Git para el control de versiones.
+
¿Cómo se inicia el flujo de trabajo en GitHub?
+
Para trabajar en un proyecto en GitHub, en lugar de comenzar con git init en tu máquina local, creas un repositorio en GitHub. Este repositorio vacío se descarga al equipo y, desde ahí, se pueden hacer cambios locales. La estructura básica del flujo de trabajo incluye los siguientes pasos:
+
+
Crear un commit: Guardar los cambios realizados localmente.
+
Subir cambios a GitHub: Una vez los cambios estén listos, se suben a una rama separada en el repositorio remoto.
+
+
¿Por qué es importante trabajar en ramas?
+
Trabajar en una rama separada permite mantener el código principal estable mientras trabajas en nuevas características. Al subir la rama a GitHub, el proceso de Code Review comienza. Otros compañeros revisarán y aprobarán los cambios antes de integrarlos en la rama principal.
+
¿Qué reglas se pueden seguir para crear tareas?
+
Para facilitar la revisión de código y evitar conflictos, es ideal mantener las tareas pequeñas y con un solo objetivo. Esto hace que:
+
+
El proceso de revisión sea sencillo.
+
Los cambios sean menos propensos a conflictos al integrarse al proyecto principal.
+
+
Algunos equipos imponen reglas como limitar el número de archivos modificados o la cantidad de líneas de código en una tarea, aunque una recomendación básica es “una tarea, un objetivo”.
+
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/04-Creaci\303\263n y colaboraci\303\263n en repositorios de GitHub.mp4" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/04-Creaci\303\263n y colaboraci\303\263n en repositorios de GitHub.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..c5ddced1405b02486abe3db570a40187eef91477
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/04-Creaci\303\263n y colaboraci\303\263n en repositorios de GitHub.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:28e40f081ee750813e4f4e27526dca242b777e1fd997e4aeb49e5cad9987aa39
+size 37776813
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/04-Creaci\303\263n y colaboraci\303\263n en repositorios de GitHub.vtt" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/04-Creaci\303\263n y colaboraci\303\263n en repositorios de GitHub.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..8e8ea603d9fd29421e292bbd57042200ed8b6ec3
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/04-Creaci\303\263n y colaboraci\303\263n en repositorios de GitHub.vtt"
@@ -0,0 +1,340 @@
+WEBVTT
+
+00:00.000 --> 00:02.600
+Ahora que tienes tu perfil de GitHub ya
+creado,
+
+00:02.600 --> 00:05.600
+es momento de comenzar a trabajar con los
+repositorios,
+
+00:05.600 --> 00:09.700
+el equivalente de Git y NIT dentro de la
+terminal de comandos.
+
+00:09.700 --> 00:12.100
+Para ello, te voy a mostrar cómo crear un
+repositorio
+
+00:12.100 --> 00:16.300
+y, además, gracias a que ya estamos
+trabajando de manera colaborativa,
+
+00:16.300 --> 00:20.800
+invitar a un colaborador adicional a
+trabajar en este repositorio.
+
+00:21.300 --> 00:23.600
+En la pantalla de Home de tu perfil,
+
+00:23.600 --> 00:28.300
+selecciona el signo de Más, que te permite
+crear nuevas opciones.
+
+00:28.300 --> 00:31.800
+La primera es crear un nuevo repositorio.
+
+00:31.800 --> 00:36.500
+Si tú la seleccionas, te va a permitir
+hacer por medio de un formulario
+
+00:36.500 --> 00:38.300
+este nuevo
+repositorio.
+
+00:38.300 --> 00:43.700
+Lo primero que necesitamos ver es que me
+pide un template de repositorio
+
+00:43.700 --> 00:45.000
+o una
+plantilla.
+
+00:45.000 --> 00:48.100
+No voy a utilizar ninguna de las
+plantillas por ahora.
+
+00:48.100 --> 00:50.200
+Selecciono a un
+propietario,
+
+00:50.200 --> 00:54.300
+en mi caso, el usuario que ya tengo
+obviamente en mi cuenta.
+
+00:54.300 --> 00:57.500
+Voy a crear mi primer
+repositorio.
+
+00:57.500 --> 01:02.900
+Considera que mi primer repo va a estar
+disponible para todos nosotros
+
+01:02.900 --> 01:05.400
+porque el nombre de usuario
+cambia.
+
+01:05.400 --> 01:09.300
+Es decir, el repositorio será Aminespinoza10,
+
+01:09.300 --> 01:12.400
+diagonal, mi primer repo, en mi caso.
+
+01:12.400 --> 01:14.900
+En el tuyo, el nombre de usuario
+cambiado
+
+01:14.900 --> 01:19.000
+va a permitir que puedas utilizar este
+mismo nombre si así lo deseas.
+
+01:19.000 --> 01:21.900
+Establece después una
+descripción.
+
+01:21.900 --> 01:24.300
+Con la descripción que ya hayas agregado,
+
+01:24.300 --> 01:26.900
+viene una decisión muy
+importante.
+
+01:26.900 --> 01:30.400
+Puedes hacer que este repositorio sea
+público o privado,
+
+01:30.400 --> 01:34.000
+dependiendo de las necesidades del
+proyecto que vas a alojar aquí.
+
+01:34.000 --> 01:37.000
+En mi caso, lo voy a mantener como público.
+
+01:37.000 --> 01:41.100
+Después, me dice qué si quiero inicializar
+este repositorio
+
+01:41.100 --> 01:42.900
+con un archivo
+README.
+
+01:42.900 --> 01:44.700
+Comúnmente, yo lo agrego.
+
+01:44.700 --> 01:48.500
+Depende de si quieres empezar a establecer
+tu documentación o no.
+
+01:48.500 --> 01:50.700
+De cualquier manera, creo que por costumbre,
+
+01:50.700 --> 01:53.000
+en mi caso, lo tengo ya listo.
+
+01:53.000 --> 01:56.700
+Después vienen dos opciones de agregar un
+archivo gitignore
+
+01:56.700 --> 01:59.700
+y una licencia que por ahora no necesitamos.
+
+01:59.700 --> 02:02.900
+Voy a seleccionar el botón verde de Create
+Repository
+
+02:02.900 --> 02:05.700
+y también puedes hacer lo mismo en este
+momento.
+
+02:06.500 --> 02:09.100
+Ya que tienes tu primer repositorio,
+
+02:09.100 --> 02:12.400
+entonces te darás cuenta que el primer
+archivo que vas a ver
+
+02:12.400 --> 02:16.000
+es el README, que de hecho se está
+desplegando aquí.
+
+02:16.000 --> 02:19.100
+Ahora puedo ir y agregar a un
+colaborador
+
+02:19.100 --> 02:21.000
+dentro de este
+repositorio
+
+02:21.000 --> 02:23.800
+para que podamos comenzar a trabajar en
+equipo.
+
+02:23.800 --> 02:26.800
+Esto lo hago en
+Settings
+
+02:27.700 --> 02:31.700
+y selecciono la categoría de colaboradores.
+
+02:31.700 --> 02:35.800
+Aquí debo tener presente que el
+colaborador que quiero invitar
+
+02:35.800 --> 02:38.400
+también ya tiene una cuenta de GitHub.
+
+02:38.400 --> 02:41.900
+Entonces, puedo seleccionar la opción de
+Agregar gente
+
+02:41.900 --> 02:44.500
+y agrega a los usuarios que tú quieras.
+
+02:44.500 --> 02:50.000
+En mi caso, voy a agregar a DatorMx,
+Miguel Torres.
+
+02:50.000 --> 02:52.600
+Lo agrego a este
+repositorio
+
+02:53.500 --> 02:58.600
+y yo no puedo considerar que Miguel es un
+colaborador de esto
+
+02:58.600 --> 03:01.500
+porque su invitación sigue pendiente.
+
+03:01.500 --> 03:05.700
+Necesito esperar a que él acepte esta
+invitación.
+
+03:05.700 --> 03:08.400
+Listo, solo refresqué mi página para darme
+cuenta
+
+03:08.400 --> 03:11.200
+que Miguel Torres ya es parte de este
+equipo
+
+03:11.200 --> 03:13.900
+y puede acceder a este
+repositorio.
+
+03:13.900 --> 03:16.900
+Ahora regresa a la sección de
+Code,
+
+03:16.900 --> 03:20.200
+que es básicamente la sección principal de
+tu repositorio,
+
+03:20.200 --> 03:23.100
+en donde puedes ver la misma pantalla que
+viste
+
+03:23.100 --> 03:25.000
+cuando lo
+creaste.
+
+03:25.000 --> 03:26.700
+Lo que debes observar
+ahora
+
+03:26.700 --> 03:30.200
+es que aquí está una rama llamada Main,
+
+03:30.200 --> 03:33.000
+igual que como nosotros hicimos con
+Git
+
+03:33.000 --> 03:35.200
+trabajando desde nuestra
+terminal,
+
+03:35.200 --> 03:37.700
+ahora esta rama principal es
+Main.
+
+03:37.700 --> 03:41.200
+Y aquí puedes ver que solo existe una sola
+rama.
+
+03:41.200 --> 03:44.100
+Naturalmente, si no hemos trabajado en el
+repositorio,
+
+03:44.100 --> 03:47.100
+es obvio que solo esta va a aparecer.
+
+03:47.100 --> 03:51.000
+Ahora, para poder hacer que nuestro
+repositorio sea local
+
+03:51.000 --> 03:53.500
+y podamos trabajar en nuestra
+máquina
+
+03:53.500 --> 03:56.000
+sin tener que depender de la
+web,
+
+03:56.000 --> 03:58.500
+selecciona el botón de
+Code.
+
+04:00.000 --> 04:02.300
+Para clonar tu
+repositorio,
+
+04:02.300 --> 04:04.500
+tú lo puedes hacer de tres
+maneras,
+
+04:04.500 --> 04:08.000
+la de HTTPS,
+SSH
+
+04:08.000 --> 04:11.200
+o por medio de la línea de comandos de GitHub.
+
+04:11.200 --> 04:16.200
+Ahora nosotros podemos utilizar HTTPS sin
+ningún problema.
+
+04:16.200 --> 04:22.000
+Copio la URL para copiar esta dirección.
+
+04:23.000 --> 04:34.000
+En tu terminal, lo que necesitas hacer es escribir el comando git
+clone y después de este comando, pegas la URL que copiaste de tu repositorio.
+
+04:34.000 --> 04:42.100
+Presiona Enter y aparece una leyenda
+que dice clonando a mi primer repositorio.
+
+04:42.200 --> 04:55.200
+Puedo darme cuenta de todo lo que descargo y ya que pasó todo este proceso, ahora yo puedo escribir LS y aquí aparece la carpeta de mi primer repo.
+
+04:55.300 --> 05:05.100
+El repositorio que tú tienes en GitHub automáticamente al ser clonado se vuelve una carpeta y dentro de esta carpeta, si yo me muevo a ella,
+
+05:05.200 --> 05:11.000
+puedo ver que está el archivo readme
+que originalmente fue creado en ese repositorio de GitHub.
+
+05:11.200 --> 05:17.000
+¿A poco no se siente fantástico crear
+y clonar tu primer repositorio desde GitHub?
+
+05:17.000 --> 05:21.000
+Ahora ya es momento de ir mezclando
+los conceptos entre Git y GitHub.
+
+05:21.200 --> 05:29.000
+Dado que yo ya tengo mi repositorio remoto
+en la nube, ya puedo descargarlo hacia mi entorno local
+
+05:29.000 --> 05:36.000
+y trabajar como he estado trabajando con
+Git sin ningún problema hasta volver a regresar los cambios a GitHub.
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/04-Lecturas recomendadas.txt" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/04-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..da366af47c936ccefde3cdbb4a35ea6e7fb9339e
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/04-Lecturas recomendadas.txt"
@@ -0,0 +1 @@
+https://github.com/platzi/git-github
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/04-Resumen.html" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/04-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..0b129e5023b51db914ca8b52542e0e2b2cc739f6
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/04-Resumen.html"
@@ -0,0 +1,124 @@
+
+
+
+
+
+
+ Creación y colaboración en repositorios de GitHub
+
+
+
+
+
+
Resumen
Crear y gestionar un repositorio en GitHub es una habilidad esencial para colaborar y mantener proyectos de software de forma ordenada. Aquí aprenderás cómo crear, configurar, invitar colaboradores y clonar un repositorio de manera efectiva.
+
¿Cómo crear un repositorio en GitHub?
+
Para empezar, accede a la pantalla principal de tu perfil en GitHub y selecciona el símbolo de “+”. Aquí, selecciona la opción “Nuevo repositorio”, lo que abrirá un formulario para configurarlo:
+
+
Propietario: Elige tu usuario actual como propietario del repositorio.
+
Nombre del repositorio: Puedes asignarle un nombre como “mi-primer-repo”. Este nombre puede adaptarse a tu usuario, permitiendo reutilizar nombres similares.
+
Descripción: Añade una breve descripción del proyecto para facilitar su identificación.
+
Visibilidad: Decide si el repositorio será público o privado según las necesidades del proyecto.
+
Inicialización: Puedes agregar un archivo README para documentar el repositorio desde el inicio. Aunque opcional, es una buena práctica.
+
+
Finalmente, selecciona el botón verde de “Crear repositorio” para completar este proceso. Al hacerlo, tendrás acceso directo a tu repositorio con el archivo README visible.
+
¿Cómo agregar un colaborador a un repositorio en GitHub?
+
Para trabajar en equipo, es fundamental añadir colaboradores. Esto se hace desde la sección de “Settings” del repositorio:
+
+
Dirígete a “Colaboradores” en la configuración.
+
Asegúrate de que el colaborador tenga una cuenta de GitHub.
+
Selecciona la opción de agregar usuarios y elige a quien quieras invitar.
+
+
Una vez enviada la invitación, deberás esperar que el colaborador la acepte para que pueda acceder al repositorio y trabajar en él.
+
¿Cómo clonar un repositorio en tu máquina local?
+
Clonar el repositorio te permite trabajar desde tu entorno local y sincronizar cambios con GitHub. Para ello:
+
+
Ve a la sección de “Code” dentro de tu repositorio.
+
Selecciona la opción HTTPS y copia la URL del repositorio.
+
En tu terminal, escribe git clone seguido de la URL copiada y presiona “enter”.
+
+
Este comando descargará el repositorio en tu máquina. Podrás ver todos los archivos en una carpeta con el nombre del repositorio y comenzar a trabajar de manera local.
+
¿Cómo integrar Git y GitHub para un flujo de trabajo colaborativo?
+
Una vez que el repositorio está clonado en tu entorno local, puedes editar archivos, guardar cambios y subirlos de nuevo a GitHub mediante Git. Al hacer esto, permites que todos los colaboradores se mantengan sincronizados y al día con el desarrollo del proyecto.
+
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/05-Precios y Planes de Productos de Github.mhtml" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/05-Precios y Planes de Productos de Github.mhtml"
new file mode 100644
index 0000000000000000000000000000000000000000..10200059de773ee98bf523ddbcc27a28875e3ce0
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/05-Precios y Planes de Productos de Github.mhtml"
@@ -0,0 +1,19999 @@
+From:
+Snapshot-Content-Location: https://platzi.com/cursos/gitgithub/productos-de-github-precios-planes-y-apps/
+Subject: Precios y Planes de Productos de Github
+Date: Sat, 8 Nov 2025 15:34:35 -0500
+MIME-Version: 1.0
+Content-Type: multipart/related;
+ type="text/html";
+ boundary="----MultipartBoundary--FjnbRnj6uUu5wv1Oc7rSCdGnpbsMFyZWXFyjLcLmUs----"
+
+
+------MultipartBoundary--FjnbRnj6uUu5wv1Oc7rSCdGnpbsMFyZWXFyjLcLmUs----
+Content-Type: text/html
+Content-ID:
+Content-Transfer-Encoding: quoted-printable
+Content-Location: https://platzi.com/cursos/gitgithub/productos-de-github-precios-planes-y-apps/
+
+Precios y Planes de Productos =
+de Github
Confirmar tu correo=
+
Enviamos un enlace de confirmaci=C3=B3n a tu correo =
+electr=C3=B3nico tomalabecker68@gmail.com
Ahora que ya vimos como poder crear un repositorio en Github y usar sus =
+repositorios, es momento de hablar acerca de los diferentes productos que v=
+eremos durante todo el curso y sus consideraciones, principalmente los cost=
+os de cada uno de los servicios que vamos a utilizar.
+
Recuerda que esta secci=C3=B3n es de gran importancia porque como progra=
+madores podemos ver todos estos servicios como una variedad de opciones en =
+donde podemos jugar como ni=C3=B1os chiquitos en la arena; sin embargo, com=
+o parte de alguna organizaci=C3=B3n debemos tener presente que los costos d=
+erivados de ello pueden jugar en nuestra contra si no sabemos como hacer pa=
+ra obtener un beneficio de todo esto, ten siempre presente la regla m=C3=A1=
+s importante de cualquier servicio que contrates.
+
Si un servicio o herramienta que est=C3=A1s utilizando no est=C3=A1 ayu=
+dando a tu organizaci=C3=B3n, entonces la est=C3=A1 perjudicando
+
Bueno, hora de dejar la clase de negocio y comenzar a ver el costo de lo=
+s diferentes productos.
+
Repositorios
+
Los repositorios de Github ya sean p=C3=BAblicos o privados son gratuito=
+s y sin un l=C3=ADmite en espec=C3=ADfico en la cantidad de cu=C3=A1ntos pu=
+edes tener, es decir, sin importar si se trata de una cuenta de pago o grat=
+uita podr=C3=A1s crear tantos repositorios como gustes, as=C3=AD que por es=
+te tema no es necesario preocuparte, esta no es una diferencia entre todos =
+los planes, tanto gratuitos como de pago.
+
Codespaces
+
=C2=A1Huy! Aqu=C3=AD la cosa se pone buena. Codespaces es una herramient=
+a que vamos a utilizar much=C3=ADsimo en este curso y que es muy importante=
+ tener presente que es de costo. =C2=BFQuieres un adelanto? Te recordar=C3=
+=A9 todo el tiempo jugar con esta herramienta y luego apagarla, pero bueno,=
+ es momento de ver los costos.
+
N=C3=BAcleos
Costo por hora
Tiempo de=
+ uso gratuito
2 n=C3=BAcleos
$0.18 =
+USD por hora
60 horas gratuitas
4 n=C3=BAcleos
$0.36 USD por hora
30 horas gratuitas
8 n=C3=
+=BAcleos
$0.72 USD por hora
15 horas gratuitas
16 n=C3=BAcleos
$1.44 USD por hora
No aplica
=
+
32 n=C3=BAcleos
$2.88 USD por hora
No aplica
+
En cu=C3=A1nto a almacenamiento tambi=C3=A9n hay un costo asociado a ell=
+o.
+
Categor=C3=ADa
Costo
Datos gratuitos<=
+/th>
Almacenamiento
$0.07 USD por mes
15 GB gratuitos mensuales
+
Lo =C3=BAnico que te puedo decir en esta categor=C3=ADa es que esas 30 h=
+oras de uso con 4 n=C3=BAcleos van a ser mucho m=C3=A1s que suficientes par=
+a este curso y jugar un rato m=C3=A1s, adem=C3=A1s, recuerda que cada mes s=
+e renuevan estos datos, as=C3=AD que si algo sucede simplemente tocar=C3=A1=
+ esperar.
+
Github web editor
+
=C2=A1Buenas noticias aqu=C3=AD! Al igual que los repositorios, esta car=
+acter=C3=ADstica est=C3=A1 presente en todos los planes de todos los nivele=
+s, sin costo en ning=C3=BAn escenario y sin l=C3=ADmite de uso, esencialmen=
+te se trata de una caracter=C3=ADstica que podemos aprovechar y aprender a =
+utilizar mucho si preocuparnos por el costo.
+
Github Actions
+
Github Actions es un tema de lo m=C3=A1s complicado, el costo de las Act=
+ions depende mucho del sistema operativo, la capacidad del agente, obviamen=
+te el hardware y muchas cosas m=C3=A1s; sin embargo, para los principiantes=
+ (y me incluyo en esta categor=C3=ADa porque ni de broma recuerdo todas las=
+ configuraciones) la mejor manera de evaluar y de guiarte es por medio del =
+consumo por minutos, en la siguiente tabla podr=C3=A1s ver una buena refere=
+ncia de los planes.
+
Plan
Consumo de minutos
Gratuito
2,000 minutos de ejecuci=C3=B3n
Team
3,000 minutos de ejecuci=C3=B3n
Enterprise<=
+/td>
50,000 minutos de ejecuci=C3=B3n
+
La verdad es que hay mucho que considerar en el tema de costos y benefic=
+ios de todas las herramientas y lo mejor es que dediques un tiempo a esto p=
+ara saber como aprovechar al m=C3=A1ximo los beneficios aqu=C3=AD solo menc=
+ionamos los productos que usaremos en el curso, sin embargo, hay muchas m=
+=C3=A1s consideraciones, lo ideal es que comiences por la p=C3=A1gina de re=
+ferencia por excelencia para aprender de todo lo necesario acerca de esto, =
+la puedes visitar aqu=C3=AD.
<=
+div>
=
+
+
+
Sigue disfrutando de P=
+latzi
=
+Agrega tu foto, nombre y n=C3=BAmero de tel=C3=A9fono para seguir viendo si=
+n costo las primeras clases
Usar SSH para interactuar con GitHub es una excelente forma de aumentar la seguridad y mejorar la comodidad en el manejo de repositorios. A continuación, te explicamos el paso a paso para generar y configurar tus llaves SSH en distintos sistemas operativos y cómo integrarlas en tu perfil de GitHub para mejorar la experiencia de clonación y autenticación.
+
¿Por qué es mejor usar SSH en lugar de HTTPS para GitHub?
+
+
Seguridad adicional: SSH permite autenticar la computadora específica que accede a los repositorios sin necesidad de ingresar una contraseña cada vez.
+
Comodidad: Evita la necesidad de escribir tu contraseña en cada operación con GitHub, agilizando el flujo de trabajo.
+
+
¿Cómo generar una llave SSH en Windows y Linux?
+
+
Instalar WSL si estás en Windows (opcional si usas Linux nativo).
+
Verificar que no tienes llaves previas: Ve al menú de “Code” en GitHub y verifica que la opción de SSH no tenga llaves configuradas.
+
Generar la llave SSH: En la terminal, usa el comando:
Esto clona el repositorio sin solicitar contraseña, aprovechando la autenticación SSH.
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/07-Lecturas recomendadas.txt" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/07-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..2f1b4b545af1c300c70656befa26e10fd97764a2
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/07-Lecturas recomendadas.txt"
@@ -0,0 +1,2 @@
+https://docs.github.com/es/authentication/connecting-to-github-with-ssh
+https://github.com/platzi/git-github
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/07-Resumen.html" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/07-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..2141385825b2057a0a9a743ea27e3c768a9341ea
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/07-Resumen.html"
@@ -0,0 +1,122 @@
+
+
+
+
+
+
+ Uso de Forks y Estrellas en Repositorios de GitHub
+
+
+
+
+
+
Resumen
Entender el uso de forks y estrellas en GitHub optimiza la gestión de proyectos y recursos al trabajar en esta plataforma. Aquí exploraremos cómo funcionan estos elementos y cómo pueden ayudarte a organizar tus repositorios en función de tus necesidades.
+
¿Qué es un fork y cómo se utiliza?
+
Un fork en GitHub es una copia de un repositorio alojado en la cuenta de otra persona y que puedes transferir a tu propia cuenta. Este proceso crea una réplica del repositorio en su estado actual, sin reflejar futuros cambios del original a menos que se sincronice manualmente. Esto permite:
+
+
Trabajar de manera independiente en un proyecto sin afectar el repositorio original.
+
Personalizar el contenido según tus necesidades sin modificar el repositorio fuente.
+
Crear una base para hacer contribuciones posteriores al repositorio original.
+
+
Para crear un fork, debes abrir el repositorio, seleccionar el botón de Fork y seguir los pasos para copiarlo en tu cuenta. Así, GitHub duplicará el repositorio, manteniendo el nombre y descripción del original. Puedes optar por copiar solo la rama principal (main) o todo el proyecto. Luego, desde tu cuenta, podrás modificar el contenido sin interferir con el repositorio original.
+
¿Qué beneficios aporta usar estrellas en GitHub?
+
Las estrellas en GitHub funcionan como un sistema de marcado para resaltar los repositorios que deseas tener a mano como referencia o favoritos. Son útiles para:
+
+
Crear un índice de repositorios de referencia o inspiración.
+
Acceder rápidamente a recursos clave desde tu perfil.
+
Seguir el desarrollo de proyectos importantes para tus intereses.
+
+
Al seleccionar la estrella en un repositorio, ésta se ilumina para indicar que has marcado este recurso. Puedes acceder a todos tus repositorios marcados desde la sección de “tus estrellas” en tu perfil. Aquí se listan los proyectos que has destacado, ayudándote a centralizar tus fuentes de consulta.
+
¿Cómo clonar un repositorio forkeado?
+
Después de realizar un fork, puedes clonar este repositorio a tu entorno local para trabajar de forma directa en tu equipo. Para hacerlo:
+
+
Ve a tu repositorio forkeado.
+
Selecciona el botón Code y copia la URL del proyecto en formato SSH.
+
Abre la terminal y usa el comando git clone .
+
+
De esta manera, tendrás una versión local del repositorio en la que podrás modificar y gestionar el código. Esta técnica de fork y clonación es útil para personalizar proyectos o experimentar sin afectar el original, ofreciendo flexibilidad para hacer cambios sin alterar el repositorio fuente.
+
¿Por qué usar forks en lugar de clonar directamente el repositorio original?
+
Hacer un fork en lugar de una clonación directa del repositorio original permite que trabajes de manera independiente. Puedes hacer ajustes sin el riesgo de cambiar el repositorio base, especialmente útil cuando el original es de terceros o si planeas realizar cambios extensivos. Además, el fork es una base ideal para hacer contribuciones futuras, ya que se puede sincronizar y enviar cambios al proyecto original a través de un proceso estructurado.
+
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/07-Uso de Forks y Estrellas en Repositorios de GitHub.mp4" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/07-Uso de Forks y Estrellas en Repositorios de GitHub.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..5f37ceef69402df797310df6d164708b8f5fbb82
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/07-Uso de Forks y Estrellas en Repositorios de GitHub.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f2d2de0ab5bb7584e211441934c9c2c1646709b4ece79e74eefa9457c7944b9
+size 52565667
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/07-master.zip" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/07-master.zip"
new file mode 100644
index 0000000000000000000000000000000000000000..c130fe3538def0b0e8a5dae35b2f116a18e9c4bc
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/07-master.zip"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8ae16a918272698d034ee6a3fd22df52c367e61fb37eae34b5e05daf592988ca
+size 15212
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/08-Lecturas recomendadas.txt" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/08-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..9a41c4ee5b81af56024179cd2648e89acb9be2a3
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/08-Lecturas recomendadas.txt"
@@ -0,0 +1,4 @@
+https://git-scm.com/docs/git-fetch
+https://git-scm.com/docs/git-push
+https://git-scm.com/docs/git-pull
+https://github.com/platzi/git-github
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/08-Resumen.html" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/08-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..7d8712ee996c9c0a09c55247cbc94af6eeaec57c
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/08-Resumen.html"
@@ -0,0 +1,128 @@
+
+
+
+
+
+
+ Uso de git pull, git push y git fetch en repositorios GitHub
+
+
+
+
+
+
Resumen
¿Cómo sincronizar tus repositorios con git pull, git push y git fetch?
+
La gestión de repositorios es una habilidad esencial en el desarrollo de software moderno. Git y GitHub permiten a los desarrolladores colaborar y sincronizar cambios de manera eficiente. Aquí te explicaremos cómo los comandos git pull, git push y git fetch juegan un papel crucial en este proceso, ayudándote a entender cuándo y cómo utilizarlos para mantener tus repositorios actualizados.
+
¿Cómo usar git pull y git push para mantener tus repositorios sincronizados?
+
El comando git pull se utiliza para actualizar tu repositorio local con los cambios que se han producido en la nube, específicamente en GitHub. Esta acción es esencial cuando deseas asegurarte de que tu entorno local refleje las últimas modificaciones realizadas en el repositorio compartido.
+
Por otro lado, git push tiene la función opuesta: permite subir tus cambios locales al repositorio en la nube. Esto es fundamental para colaborar con otros desarrolladores, garantizando que todos los cambios se integren en el proyecto general.
+
Script de ejemplo para git pull y git push
+
# Para verificar la rama activa y actualizar el repositorio local
+$ git branch # Verifica la rama activa
+$ git pull origin main # Jala los últimos cambios de la rama main en GitHub
+
+# Para subir cambios desde el repositorio local a la nube
+$ gitadd.# Prepara los archivos para el commit
+$ git commit -m"Descripción del cambio"# Realiza el commit
+$ git push origin main # Sube los cambios a GitHub
+
+
¿Qué es y cómo utilizar git fetch?
+
El comando git fetch es útil cuando deseas descargar los cambios sin aplicarlos inmediatamente. Difiere de git pull, ya que te permite evaluar primero los cambios antes de fusionarlos con tu rama local. Este enfoque resulta valioso cuando se espera una revisión antes de integrar los cambios en el entorno local.
+
Ejemplo práctico de git fetch
+
# Descargar cambios sin aplicarlos de inmediato
+$ git fetch origin # Jala los cambios de la rama origen
+
+# Comparar y evaluar diferencias entre ramas
+$ git log main..origin/main # Compara las diferencias entre la rama local y la remota
+
+# Una vez evaluados, fusionar cambios en la rama local
+$ git merge origin/main # Fusiona los cambios evaluados
+
+
¿Cómo elegir entre git pull y git fetch?
+
+
git pull: Rápido y directo, ideal cuando se confía en los cambios remotos y se necesita una actualización inmediata de la rama local.
+
git fetch: Más cauteloso, ofrece una etapa de evaluación antes de integrar los cambios, evitando sincronizaciones no deseadas.
+
+
Elige el comando que mejor se adapte a tu situación y flujo de trabajo. Recuerda siempre sincronizar tus cambios entre local y remoto para mantener la integridad del proyecto y facilitar la colaboración.
+
Con estos comandos como parte de tu arsenal, tendrás la habilidad de mantener tus proyectos bien organizados y listos para la colaboración. Sigue explorando y practicando en diferentes escenarios para reforzar estas habilidades esenciales en el manejo de Git y GitHub. ¡Adelante, y sigue aprendiendo!
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/08-Uso de git pull git push y git fetch en repositorios GitHub.mp4" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/08-Uso de git pull git push y git fetch en repositorios GitHub.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..3f639613bf2bb5dd1bdb5a03f00f7efb7a0776f8
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/08-Uso de git pull git push y git fetch en repositorios GitHub.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ed1d528078817ab59ef789c1c25951a41c896c3f4f11d68255ccfc122ed6050c
+size 79722212
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/08-Uso de git pull git push y git fetch en repositorios GitHub.vtt" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/08-Uso de git pull git push y git fetch en repositorios GitHub.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..950d2bb01e92398136dc2465737c920fe52e1f4e
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/08-Uso de git pull git push y git fetch en repositorios GitHub.vtt"
@@ -0,0 +1,750 @@
+WEBVTT
+
+00:00.000 --> 00:01.900
+Una vez que hemos comenzado a
+trabajar
+
+00:01.900 --> 00:04.400
+con la interacción entre GitHub y Git,
+
+00:04.400 --> 00:07.200
+va a ser casi obligatorio
+saber
+
+00:07.200 --> 00:10.800
+cómo jalar información de mi repositorio
+en la nube
+
+00:10.800 --> 00:14.300
+o cómo subir la información de mi
+repositorio local.
+
+00:14.300 --> 00:16.800
+Para eso existen estos tres comandos,
+
+00:16.800 --> 00:19.800
+git pull, git push y git
+fetch.
+
+00:19.800 --> 00:22.900
+Entonces, vamos a revisar para qué y en
+qué casos
+
+00:22.900 --> 00:25.300
+podemos utilizar cada uno de
+ellos.
+
+00:25.300 --> 00:28.400
+Esencialmente, el comando git
+pull
+
+00:28.400 --> 00:31.900
+es para jalar información actualizada del
+repositorio
+
+00:31.900 --> 00:34.400
+y actualizar mi repositorio
+local.
+
+00:34.400 --> 00:36.900
+Por el lado contrario, el comando git
+push
+
+00:36.900 --> 00:39.900
+es para subir mis cambios en el entorno
+local
+
+00:39.900 --> 00:43.600
+al entorno compartido, es decir, a GitHub
+o en la nube.
+
+00:43.600 --> 00:46.700
+Esencialmente, así funcionan estos dos
+comandos.
+
+00:46.700 --> 00:49.400
+Git fetch creo que se cuece por aparte.
+
+00:49.400 --> 00:52.900
+Vamos a ver un caso práctico en donde
+usamos cada uno de ellos
+
+00:52.900 --> 00:56.800
+y ver cómo los podemos aplicar en nuestras
+actividades diarias.
+
+00:56.800 --> 00:58.900
+Voy a arrancar desde mi
+terminal.
+
+00:58.900 --> 01:01.300
+Y antes de abrir cualquier entorno de trabajo,
+
+01:01.300 --> 01:03.900
+lo que yo suelo hacer siempre es
+verificar
+
+01:03.900 --> 01:05.500
+en qué rama me
+encuentro.
+
+01:05.500 --> 01:08.000
+Ya lo sé, lo podemos hacer desde VS
+Code
+
+01:08.000 --> 01:10.700
+o lo podemos hacer incluso desde otros medios.
+
+01:10.700 --> 01:13.500
+Sin embargo, creo que la costumbre siempre
+me gana.
+
+01:13.500 --> 01:16.200
+Lo primero que hago es verificar que estoy
+en main
+
+01:16.200 --> 01:18.900
+y después ya abro VS
+Code.
+
+01:20.400 --> 01:25.200
+Aquí, ya dentro de VS Code, voy a abrir
+readme.md
+
+01:25.200 --> 01:28.100
+y voy a seleccionar aquí primero un
+espacio
+
+01:28.100 --> 01:31.000
+para poder corregir esa pequeña
+advertencia que tenía
+
+01:31.000 --> 01:36.800
+y puedo escribir mi primera contribución
+local
+
+01:38.600 --> 01:40.000
+para
+GitHub.
+
+01:40.900 --> 01:43.400
+Ahora que ya tengo este cambio realizado,
+
+01:43.400 --> 01:46.000
+obviamente puedo ir a mi control de
+versiones
+
+01:46.000 --> 01:49.100
+y darme cuenta de estos
+cambios.
+
+01:49.100 --> 01:51.400
+También podría hacerlo desde mi terminal.
+
+01:51.400 --> 01:53.000
+Cualquiera de los dos
+métodos
+
+01:53.000 --> 01:55.800
+que te vaya empezando a acomodar
+más
+
+01:55.800 --> 01:57.800
+tienen el mismo
+resultado.
+
+01:57.800 --> 01:59.500
+Voy a utilizar VS
+Code
+
+01:59.500 --> 02:05.000
+y aquí voy a poner mi primer commit local.
+
+02:06.600 --> 02:10.400
+Listo. Visual Studio me dice que aquí en
+el botón
+
+02:10.400 --> 02:13.300
+aparece la leyenda sync
+changes,
+
+02:13.300 --> 02:16.400
+una flecha para arriba y un número uno.
+
+02:16.400 --> 02:19.900
+Esto significa que podría sincronizar mis
+cambios
+
+02:19.900 --> 02:20.900
+con la
+nube.
+
+02:20.900 --> 02:23.800
+Sin embargo, en lugar de presionar ese botón,
+
+02:23.800 --> 02:25.900
+puedo hacerlo también desde la terminal,
+
+02:25.900 --> 02:29.100
+en donde ahora puedo poner git
+status
+
+02:30.600 --> 02:33.800
+y me dice que no hay nada que hacer en un
+commit
+
+02:33.800 --> 02:36.900
+porque ya hice mis cambios desde Visual
+Studio Code.
+
+02:36.900 --> 02:40.300
+Es decir, al haber puesto el mensaje y el
+botón de commit,
+
+02:40.300 --> 02:42.700
+hice ese commit que
+necesitaba.
+
+02:42.700 --> 02:44.300
+Ahora aquí puedo
+escribir
+
+02:44.300 --> 02:51.800
+git push - u origin y
+main.
+
+02:53.200 --> 02:56.300
+Esto solamente lo tengo que hacer una
+ocasión
+
+02:56.300 --> 02:58.300
+porque quiero mandar a
+main,
+
+02:58.300 --> 03:01.200
+una rama que ya se encuentra en línea,
+
+03:01.200 --> 03:03.500
+toda la información recién ingresada.
+
+03:03.500 --> 03:06.700
+De hecho, solamente gracias a que
+main
+
+03:06.700 --> 03:09.100
+está ya creada en
+GitHub,
+
+03:09.100 --> 03:11.500
+podría escribir git
+push.
+
+03:11.500 --> 03:13.900
+Por ahora, el comando
+completo
+
+03:13.900 --> 03:15.400
+es más
+útil.
+
+03:16.700 --> 03:17.700
+Y
+listo.
+
+03:17.700 --> 03:19.400
+Después de esta
+leyenda,
+
+03:19.400 --> 03:22.400
+me dice que la rama main está
+lista
+
+03:22.400 --> 03:24.700
+en el modo remoto con
+main.
+
+03:24.700 --> 03:27.700
+Es decir, ambas ramas están sincronizadas.
+
+03:28.300 --> 03:31.700
+Me voy a mi repositorio y ya tenía la
+pestaña abierta.
+
+03:31.700 --> 03:33.800
+Necesito refrescar esta
+página
+
+03:33.800 --> 03:36.400
+para darme cuenta que ya está mi contribución.
+
+03:36.400 --> 03:38.900
+Aquí puedo ver los cambios
+realizados
+
+03:38.900 --> 03:42.100
+y ver cómo pude subir desde Visual Studio
+Code
+
+03:42.100 --> 03:43.500
+o desde mi
+terminal
+
+03:43.500 --> 03:46.100
+esas actualizaciones al repositorio.
+
+03:46.100 --> 03:47.800
+De esta manera,
+insisto,
+
+03:47.800 --> 03:50.500
+con el botón de sync changes o git push,
+
+03:50.500 --> 03:53.200
+podrás hacer exactamente lo
+mismo.
+
+03:53.200 --> 03:55.200
+Ahora vamos a hacer lo
+contrario.
+
+03:55.200 --> 03:57.800
+¿Qué pasa si mi repositorio tiene
+cambios
+
+03:57.800 --> 04:01.200
+que el repositorio local no ha
+recibido?
+
+04:01.200 --> 04:04.000
+Voy a seleccionar este pequeño icono de lápiz,
+
+04:04.000 --> 04:06.800
+crayón o de
+edición
+
+04:06.800 --> 04:08.400
+y voy a poner aquí
+
+04:08.400 --> 04:16.000
+un commit más desde GitHub.
+
+04:16.200 --> 04:21.000
+Aquí puedo ingresar mis cambios
+presionando el botón de commit changes.
+
+04:21.000 --> 04:29.900
+Si lo presionas, te va a aparecer una leyenda que diga
+qué commit message quieres poner y puedes agregar una descripción.
+
+04:30.000 --> 04:36.000
+La verdad es que no es necesaria esta descripción,
+pero sí es muy importante el commit message.
+
+04:37.200 --> 04:45.000
+También te aparece la opción de crear una rama main, de crear
+una rama adicional o de hacer el commit directamente en main.
+
+04:46.000 --> 04:48.000
+Por ahora, puedes hacer eso presionando el botón verde.
+
+04:50.800 --> 04:51.900
+Listo.
+
+04:53.000 --> 04:57.000
+Este cambio está ya realizado en mi primer repo.
+
+04:57.000 --> 05:04.000
+Lo puedo ver si regreso y aquí está, pero
+aún no está dentro de mi repositorio local.
+
+05:04.800 --> 05:07.000
+Para eso regreso a mi terminal.
+
+05:09.600 --> 05:14.100
+Limpio la terminal y voy a escribir simplemente git pull.
+
+05:14.100 --> 05:26.000
+Si escribo git pull, por naturaleza, git va a tomar los últimos cambios del repositorio de GitHub de la rama main, es decir, de la rama por defecto.
+
+05:26.100 --> 05:39.000
+Presiono enter y me aparece después de los
+avances de progreso, aquí, readme.md y dos cambios,
+
+05:39.000 --> 05:43.000
+es decir, que hubo un archivo modificado con dos inserciones.
+
+05:43.100 --> 05:53.000
+Ahora, si yo regreso a VS Code, en mi explorador
+de archivos, solo necesito refrescar esta parte
+
+05:53.000 --> 05:57.100
+y aquí está, un commit más desde GitHub.
+
+05:57.100 --> 05:59.900
+De esta manera es como podemos
+interactuar
+
+05:59.900 --> 06:01.800
+con estos dos
+comandos,
+
+06:01.800 --> 06:04.300
+tanto git push como git
+pull.
+
+06:04.300 --> 06:07.800
+Es necesario considerar un pequeñito detalle,
+
+06:07.800 --> 06:10.700
+no puedes hacer un git
+push
+
+06:10.700 --> 06:12.500
+si tu repositorio de
+GitHub
+
+06:12.500 --> 06:16.100
+no está sincronizado con el repositorio local.
+
+06:16.100 --> 06:19.700
+Es decir, tendrías que primero hacer un
+git pull
+
+06:19.700 --> 06:23.300
+para mantener tu repositorio local
+actualizado
+
+06:23.300 --> 06:26.500
+y después poder subir tus cambios propios.
+
+06:26.500 --> 06:30.200
+Ahora es momento de ver el tercer comando,
+git fetch.
+
+06:30.200 --> 06:32.600
+Para eso lo que voy a hacer es en readme,
+
+06:32.600 --> 06:36.400
+de nuevo dentro de mi repositorio en web,
+
+06:36.400 --> 06:38.900
+voy a hacer otra
+actualización.
+
+06:43.600 --> 06:46.800
+Con estos cambios voy a de nuevo
+ingresarlos
+
+06:46.800 --> 06:49.100
+en mi repositorio desde
+GitHub
+
+06:49.100 --> 06:51.400
+sin tocar el repositorio
+local.
+
+06:51.400 --> 06:55.500
+Recuerda utilizar la rama main como la
+rama más constante
+
+06:55.500 --> 06:57.700
+y poner el mensaje que tú
+quieras.
+
+06:57.700 --> 06:59.400
+Podemos poner
+aquí,
+
+06:59.400 --> 07:04.400
+aprendiendo git fetch, por
+ejemplo.
+
+07:04.900 --> 07:07.700
+Presiona el botón de commit changes.
+
+07:08.700 --> 07:11.200
+Aquí está, una actualización
+más.
+
+07:11.200 --> 07:13.200
+Regreso a la portada de mi
+repositorio
+
+07:13.200 --> 07:14.900
+y veo que ahí
+está.
+
+07:14.900 --> 07:17.700
+Ahora me vuelvo a mi
+terminal.
+
+07:17.700 --> 07:21.200
+Escribo git
+status.
+
+07:22.000 --> 07:24.400
+Me doy cuenta que en mi
+terminal
+
+07:24.400 --> 07:27.900
+no hay ningún cambio que yo tenga que
+actualizar
+
+07:27.900 --> 07:30.900
+o ver reflejado en mi repositorio remoto.
+
+07:30.900 --> 07:33.700
+Aquí escribiré ahora el
+comando
+
+07:33.700 --> 07:37.700
+git fetch
+origin.
+
+07:37.700 --> 07:40.100
+Es así como lo tenemos que escribir.
+
+07:40.100 --> 07:44.200
+Significa que vamos a utilizar la rama de
+nuevo,
+
+07:44.200 --> 07:47.700
+por defecto, o la rama de
+origen,
+
+07:47.700 --> 07:49.400
+para jalar los
+cambios.
+
+07:49.400 --> 07:53.700
+Pero, ojo, la diferencia entre git pull y
+git fetch
+
+07:53.700 --> 07:56.900
+es que fetch va a jalar los cambios,
+
+07:56.900 --> 08:00.400
+pero no los va a fusionar
+inmediatamente
+
+08:00.400 --> 08:01.900
+con mi rama
+main.
+
+08:01.900 --> 08:06.400
+Es como para ver si sí quiero hacer esos
+cambios primero.
+
+08:06.400 --> 08:09.900
+De esta manera, yo puedo recibir los cambios,
+
+08:09.900 --> 08:13.200
+evaluar si me conviene o me
+interesa
+
+08:13.200 --> 08:16.400
+tener esos cambios dentro de mi
+repositorio local
+
+08:16.400 --> 08:18.400
+y después
+aceptar.
+
+08:18.400 --> 08:20.400
+Vamos a presionar
+enter
+
+08:20.400 --> 08:21.900
+y tengo los
+cambios.
+
+08:21.900 --> 08:24.400
+Aquí me aparece que estoy
+utilizando
+
+08:24.400 --> 08:26.400
+los cambios desde mi primer
+repo,
+
+08:26.400 --> 08:28.400
+y origin
+main.
+
+08:28.400 --> 08:31.400
+Limpio mi
+terminal
+
+08:31.400 --> 08:34.400
+y al escribir git
+branch,
+
+08:34.400 --> 08:39.400
+me voy a dar cuenta que aún sigo dentro de
+main.
+
+08:39.400 --> 08:41.400
+Es decir, no se creó una nueva rama,
+
+08:41.400 --> 08:43.900
+no se creó nada
+absolutamente.
+
+08:43.900 --> 08:46.400
+Simplemente jalé los
+cambios
+
+08:46.400 --> 08:48.900
+y los puedo ver antes de
+fusionar.
+
+08:48.900 --> 08:51.900
+Para poder ver los cambios obtenidos,
+
+08:51.900 --> 08:54.900
+vamos a utilizar a nuestro queridísimo
+comando
+
+08:54.900 --> 08:56.400
+de git
+log.
+
+08:56.400 --> 08:58.400
+Y lo que vamos a escribir
+es
+
+08:58.400 --> 09:00.400
+git log
+main
+
+09:00.400 --> 09:02.400
+puntito,
+puntito,
+
+09:02.400 --> 09:05.400
+origin diagonal
+main.
+
+09:05.400 --> 09:07.900
+Es decir, vamos a hacer un
+registro
+
+09:07.900 --> 09:09.900
+de mi rama local
+main
+
+09:09.900 --> 09:13.400
+comparada con origin
+main.
+
+09:13.400 --> 09:15.400
+Presiona
+enter.
+
+09:16.400 --> 09:19.400
+Y aquí está el commit que hice desde
+web
+
+09:19.400 --> 09:21.400
+aprendiendo git
+fetch.
+
+09:21.400 --> 09:23.400
+De nuevo, ¿recuerdas que hemos
+mencionado
+
+09:23.400 --> 09:26.400
+la enorme importancia de poner
+mensajes
+
+09:26.400 --> 09:30.400
+muy explicativos dentro de nuestros
+commits?
+
+09:30.400 --> 09:32.400
+Aquí voy a poder saber
+eso.
+
+09:32.400 --> 09:35.400
+Ver cuál es el commit
+realizado
+
+09:35.400 --> 09:38.900
+de manera remota en nuestro repositorio en
+GitHub,
+
+09:38.900 --> 09:41.900
+pero ver si me interesa o no tenerlo.
+
+09:41.900 --> 09:45.400
+Si yo sé que ese contenido sí me interesa,
+
+09:45.400 --> 09:48.900
+entonces puedo sí hacer una fusión de ramas.
+
+09:48.900 --> 09:51.900
+Es decir, ahora escribir git
+merge
+
+09:51.900 --> 09:54.900
+y utilizar origin
+main
+
+09:54.900 --> 09:58.900
+para fusionarlo con mi rama main local.
+
+09:58.900 --> 10:00.900
+Presiono enter
+aquí
+
+10:01.900 --> 10:05.400
+y hace exactamente lo mismo que el comando
+de git pull.
+
+10:05.400 --> 10:07.900
+Es decir, ahora sí fusiona los
+cambios
+
+10:07.900 --> 10:10.900
+de la rama remota con mi rama local.
+
+10:10.900 --> 10:14.900
+Como puedes ver, git fetch suena un poco
+más burocrático,
+
+10:14.900 --> 10:17.900
+pero es una forma de ser prevenidos,
+
+10:17.900 --> 10:21.400
+darnos cuenta si queremos dar el paso de
+sincronizar o no.
+
+10:21.400 --> 10:24.400
+Por el otro lado, gracias a que git
+pull
+
+10:24.400 --> 10:27.400
+hace esos cambios de manera inmediata,
+
+10:27.400 --> 10:31.400
+puede parecer mucho más rápido y cómodo
+para todos nosotros.
+
+10:31.400 --> 10:33.400
+De hecho, en un escenario
+real,
+
+10:33.400 --> 10:36.900
+es mucho más rápido que tú utilices un git
+pull,
+
+10:36.900 --> 10:40.900
+sincronices tus cambios, veas qué
+modificaciones necesitas
+
+10:40.900 --> 10:43.900
+y después hagas un push para
+sincronizar
+
+10:43.900 --> 10:50.000
+tanto los cambios recibidos como el aporte
+que tú hayas hecho en tu repositorio dentro de GitHub.
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/09-Creaci\303\263n de Plantillas de Issues en GitHub.mp4" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/09-Creaci\303\263n de Plantillas de Issues en GitHub.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..04841aaab5ad0dd78f92c1c0e8b993ab97b0e0ad
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/09-Creaci\303\263n de Plantillas de Issues en GitHub.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d5af847418e1628d2d67d59d537ae46c3dc1ca77d25b4786d6f3a912d425fc7b
+size 61768358
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/09-Creaci\303\263n de Plantillas de Issues en GitHub.vtt" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/09-Creaci\303\263n de Plantillas de Issues en GitHub.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..0561a779b1d4704f995db42e674763c468948735
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/09-Creaci\303\263n de Plantillas de Issues en GitHub.vtt"
@@ -0,0 +1,514 @@
+WEBVTT
+
+00:00.000 --> 00:03.760
+Una de las herramientas de mejor uso
+dentro de GitHub
+
+00:03.760 --> 00:05.480
+son los
+issues.
+
+00:05.480 --> 00:09.040
+Un issue me permite establecer alguna
+clarificación
+
+00:09.040 --> 00:11.640
+de un defecto dentro de mi repositorio.
+
+00:11.640 --> 00:14.560
+Estos defectos pueden ser tan simples como
+un error
+
+00:14.560 --> 00:17.360
+al momento de escribir en la
+documentación
+
+00:17.360 --> 00:20.880
+en donde me faltó algún acento o un signo
+de puntuación,
+
+00:20.880 --> 00:25.000
+o tan complejos como una falla en cómo se
+espera
+
+00:25.000 --> 00:27.120
+que el repositorio o la
+solución
+
+00:27.120 --> 00:29.560
+estén funcionando de la manera esperada.
+
+00:29.560 --> 00:32.600
+Esto quiere decir, gracias a los issues,
+
+00:32.600 --> 00:35.240
+yo le puedo hacer saber al
+autor
+
+00:35.240 --> 00:38.480
+que ese es un problema que puede ser
+solucionado.
+
+00:38.480 --> 00:42.760
+Ya dependerá naturalmente de mí si quiero
+contribuir a solucionarlo
+
+00:42.760 --> 00:46.360
+o solo mostrar que ahí hay un tema que
+está funcionando
+
+00:46.360 --> 00:48.560
+de una forma diferente a la esperada.
+
+00:48.560 --> 00:53.520
+Dentro del primer repositorio que yo ya
+creé en mi cuenta de GitHub,
+
+00:53.520 --> 00:56.360
+puedo seleccionar la categoría de issues.
+
+00:56.360 --> 00:59.760
+Y aquí es como cualquier persona, no solo yo,
+
+00:59.760 --> 01:02.160
+pueden empezar a mencionar los
+detalles
+
+01:02.160 --> 01:05.280
+que pueden ser mejorables en mi repositorio.
+
+01:05.280 --> 01:08.960
+Es decir, si tú seleccionas el botón de
+nuevo issue,
+
+01:08.960 --> 01:12.560
+te va a aparecer un formulario que diga
+qué es lo que está sucediendo.
+
+01:12.560 --> 01:16.960
+Aquí puedo poner, no hay más documentos.
+
+01:19.160 --> 01:21.160
+Y después poner una
+descripción.
+
+01:23.360 --> 01:25.760
+Tanto el título como la
+descripción
+
+01:25.760 --> 01:29.360
+son los campos más importantes dentro de
+un issue.
+
+01:29.360 --> 01:33.360
+Sin embargo, puedo poner algunos elementos
+adicionales
+
+01:33.360 --> 01:35.160
+en esta tabla de la
+derecha,
+
+01:35.160 --> 01:37.960
+que es asignarle esta tarea a alguien más,
+
+01:37.960 --> 01:40.560
+poner etiquetas y cosas por el estilo.
+
+01:40.560 --> 01:43.760
+Sin embargo, de esta forma muy básica,
+
+01:43.760 --> 01:46.160
+yo ya puedo ingresar un nuevo
+issue
+
+01:46.160 --> 01:50.160
+para contribuir a que ese repositorio sea
+mejorado.
+
+01:50.160 --> 01:54.560
+Ahora verás que hay un número uno en tu
+lista de issues
+
+01:54.560 --> 01:57.760
+y estos issues ya están aquí
+mostrando
+
+01:57.760 --> 02:01.560
+cuál puede ser la conversación que se
+lleve a cabo
+
+02:01.560 --> 02:04.360
+basándome en el comentario original.
+
+02:04.360 --> 02:08.760
+Ahora, yo levanté un issue dentro de mi
+propio repositorio
+
+02:08.760 --> 02:10.560
+para fines
+demostrativos.
+
+02:10.560 --> 02:14.560
+Lo ideal es esperar que sean otras
+personas quienes vengan
+
+02:14.560 --> 02:17.560
+y me digan qué es lo que yo puedo
+mejorar
+
+02:17.560 --> 02:19.560
+dentro de mi
+repositorio.
+
+02:19.560 --> 02:22.760
+Para hacerles la vida un poco más fácil a
+esas personas,
+
+02:22.760 --> 02:25.360
+yo puedo crear una plantilla de
+issues
+
+02:25.360 --> 02:28.160
+en donde pongo un formulario para que me
+expliquen
+
+02:28.160 --> 02:29.560
+qué fue lo que
+pasó.
+
+02:29.560 --> 02:32.160
+Y eso es lo que haremos a continuación.
+
+02:32.160 --> 02:36.560
+Ubicándote en la dirección de mi primer
+repo en tu terminal,
+
+02:36.560 --> 02:39.160
+escribe code, espacio y
+punto,
+
+02:39.160 --> 02:41.160
+y se va a abrir Visual Studio
+Code
+
+02:41.160 --> 02:43.160
+para trabajar en este
+repositorio
+
+02:43.160 --> 02:46.160
+que por ahora tiene solo el archivo README.
+
+02:46.160 --> 02:48.760
+Aquí vamos a crear una
+carpeta
+
+02:48.760 --> 02:52.560
+que se va a
+llamar.github.
+
+02:52.560 --> 02:55.560
+Es importante poner ese punto en esa
+carpeta
+
+02:55.560 --> 02:58.160
+para que GitHub lo
+entienda.
+
+02:58.160 --> 03:00.160
+Dentro de esta
+carpeta,
+
+03:00.160 --> 03:03.160
+vamos a crear otra nueva
+carpeta
+
+03:03.160 --> 03:05.560
+que se va a llamar en
+mayúsculas
+
+03:05.560 --> 03:08.560
+issue-template.
+
+03:09.960 --> 03:10.960
+Así.
+
+03:10.960 --> 03:13.360
+Tengo ya dos carpetas
+creadas.
+
+03:13.360 --> 03:16.360
+En la segunda, voy a crear un nuevo
+archivo
+
+03:16.360 --> 03:17.760
+que se va a
+llamar
+
+03:17.760 --> 03:22.760
+bug, ahora sí con minúsculas, report.md.
+
+03:22.760 --> 03:26.160
+La extensión md es igual que la del README,
+
+03:26.160 --> 03:28.960
+de markdown o de
+documentación.
+
+03:28.960 --> 03:30.760
+Aquí lo que necesitas
+hacer
+
+03:30.760 --> 03:33.760
+es copiar el contenido del archivo que se
+encuentra
+
+03:33.760 --> 03:36.160
+dentro de los recursos de esta
+clase
+
+03:36.160 --> 03:39.160
+y colocarlo dentro del
+texto.
+
+03:39.160 --> 03:42.160
+Es decir, ya tengo un bug
+report
+
+03:42.160 --> 03:44.360
+con una pequeña
+descripción
+
+03:44.360 --> 03:47.960
+que me permite también saber qué es lo que
+está causando
+
+03:47.960 --> 03:50.560
+el problema y cosas por el
+estilo.
+
+03:50.560 --> 03:53.360
+Todas estas secciones van a
+permitir
+
+03:53.360 --> 03:56.560
+que las personas que quieran levantar un
+issue contigo
+
+03:56.560 --> 03:59.760
+tengan mayor claridad de qué es lo que
+necesitas tú
+
+03:59.760 --> 04:02.560
+para poder reproducir esos
+errores.
+
+04:02.560 --> 04:04.360
+Con estos cambios
+guardados
+
+04:04.360 --> 04:07.160
+y mi enorme experiencia en Visual Studio Code,
+
+04:07.160 --> 04:11.360
+ya me podré dar cuenta que el archivo
+cambió a color verde,
+
+04:11.360 --> 04:12.960
+así como las nuevas
+carpetas
+
+04:12.960 --> 04:15.360
+indicándome que hay cambios
+pendientes
+
+04:15.360 --> 04:17.160
+en mi control de
+versiones.
+
+04:17.160 --> 04:19.360
+Voy justo a esta
+sección
+
+04:19.360 --> 04:22.360
+y esta categoría de
+changes
+
+04:22.360 --> 04:26.160
+me dice que bug report está ya listo para
+ser ingresado.
+
+04:26.160 --> 04:31.160
+Voy a poner aquí bug report agregado.
+
+04:32.160 --> 04:33.160
+Commit.
+
+04:34.960 --> 04:37.960
+Y me aparece la opción de sincronizar los
+cambios
+
+04:37.960 --> 04:39.760
+con una flechita hacia
+arriba.
+
+04:39.760 --> 04:41.560
+La flecha hacia arriba
+significa
+
+04:41.560 --> 04:43.360
+que lo voy a subir a la
+nube,
+
+04:43.360 --> 04:45.360
+a mis repositorios de
+GitHub.
+
+04:45.360 --> 04:46.960
+Selecciona ese
+botón.
+
+04:47.760 --> 04:49.360
+Aparece una ventana que
+dice
+
+04:49.360 --> 04:53.160
+que se van a establecer los comandos de
+pull y push,
+
+04:53.160 --> 04:54.960
+porque es la primera vez que lo hago.
+
+04:54.960 --> 04:56.360
+Selecciono
+OK.
+
+04:57.760 --> 05:00.360
+Y espero la sincronización de mis cambios.
+
+05:00.360 --> 05:04.760
+Si el proceso terminó y mi botón de commit
+ya se inhabilitó,
+
+05:04.760 --> 05:07.960
+puedo regresar al repositorio de GitHub.
+
+05:07.960 --> 05:10.960
+Ahora voy a ir a la categoría de code.
+
+05:10.960 --> 05:15.760
+Y ver que ya está GitHub e Issue Template.
+
+05:15.760 --> 05:18.360
+Aquí está el archivo de
+Markdown.
+
+05:18.360 --> 05:23.360
+Todo este proceso fue para que ahora yo
+regrese a Issues.
+
+05:23.360 --> 05:26.360
+Y si alguien quiere levantar un nuevo
+issue
+
+05:26.360 --> 05:28.160
+dentro de mi
+repositorio,
+
+05:28.160 --> 05:31.160
+aparece la sección de bug
+report.
+
+05:31.160 --> 05:35.560
+Es decir, mi usuario podrá seleccionar el
+botón de iniciar
+
+05:35.560 --> 05:37.960
+y la plantilla que
+utilizamos
+
+05:37.960 --> 05:41.360
+para poder poner un issue más
+clarificado
+
+05:41.360 --> 05:43.160
+ahora se muestra
+aquí.
+
+05:43.160 --> 05:45.560
+Me dice que puedo poner dentro del
+título
+
+05:45.560 --> 05:47.160
+una descripción
+breve
+
+05:47.160 --> 05:49.360
+y todo lo que el usuario debe de
+llenar
+
+05:49.360 --> 05:51.160
+para que me dé mejor
+claridad
+
+05:51.160 --> 05:54.360
+de la reproducción del error que él está
+encontrando.
+
+05:54.360 --> 05:56.560
+Si de por sí la funcionalidad de los
+issues
+
+05:56.560 --> 05:58.160
+es bastante
+interesante,
+
+05:58.160 --> 06:00.360
+agregarles plantillas a
+estos
+
+06:00.360 --> 06:03.160
+hace que la experiencia sea mucho
+mejor
+
+06:03.160 --> 06:07.160
+para quienes quieran contribuir a la
+mejora de tus repositorios.
+
+06:07.160 --> 06:10.360
+Acabamos de crear la plantilla bug report.
+
+06:10.360 --> 06:12.960
+¿Qué te parece si creas la plantilla,
+no lo sé,
+
+06:12.960 --> 06:17.960
+document report o alguna plantilla como
+mejores prácticas?
+
+06:17.960 --> 06:19.960
+Cualquiera de todos estos
+escenarios
+
+06:19.960 --> 06:22.160
+van a funcionar para que tus
+usuarios
+
+06:22.160 --> 06:27.360
+puedan crear issues de acuerdo al caso más
+adecuado posible.
+
+06:27.360 --> 06:30.360
+De esta forma, tú le das muchas más
+comodidades
+
+06:30.360 --> 06:34.160
+a tus usuarios de contribuir a las mejoras
+de tus repositorios
+
+06:34.160 --> 06:37.160
+y tú tienes mejor claridad de cómo
+mejorar
+
+06:37.160 --> 07:04.160
+todos los códigos que estás ingresando en
+este mismo repositorio.
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/09-Lecturas recomendadas.txt" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/09-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..4d41a1618e7ef9c20d32ab54d16a18d130737d60
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/09-Lecturas recomendadas.txt"
@@ -0,0 +1,2 @@
+https://docs.github.com/es/issues/tracking-your-work-with-issues/about-issues
+https://github.com/platzi/git-github
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/09-Resumen.html" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/09-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..f07c700e95e53569ca9e29088cf98a1a76a0cbbc
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/09-Resumen.html"
@@ -0,0 +1,140 @@
+
+
+
+
+
+
+ Creación de Plantillas de Issues en GitHub
+
+
+
+
+
+
Resumen
Usar los Issues de GitHub permite gestionar y documentar problemas en un repositorio, desde errores simples en la redacción hasta defectos complejos en la funcionalidad. Con una interfaz intuitiva, permite que cualquier usuario señale y describa aspectos mejorables, y con plantillas de Issues, mejora la claridad y colaboración en el proceso.
+
¿Qué es un Issue en GitHub?
+
Un Issue es una forma de señalar problemas o sugerencias dentro de un repositorio. Puede ser usado para:
+
+
Notificar errores en la documentación, como faltas de ortografía.
+
Reportar problemas en el funcionamiento esperado del código.
+
Informar mejoras o cambios necesarios.
+
+
Los Issues permiten una comunicación bidireccional entre los colaboradores y el creador del repositorio, lo que facilita la resolución de problemas.
+
¿Cómo crear un nuevo Issue?
+
+
En el repositorio de GitHub, selecciona la pestaña Issues.
+
Haz clic en New Issue y describe el problema en dos campos principales:
+
+
Título: Una breve descripción.
+
Descripción: Detalles del problema, pasos para reproducirlo, etc.
+
+
+
+
Es posible agregar elementos adicionales, como asignar el Issue a otra persona o etiquetarlo.
+
¿Cómo crear una plantilla de Issues?
+
Para facilitar el proceso a otros colaboradores, es útil crear plantillas de Issues. Para hacerlo:
+
+
Desde el repositorio, abre Visual Studio Code con el comando code ..
+
Crea una carpeta llamada .github y dentro otra carpeta llamada ISSUE_TEMPLATE.
+
Dentro de ISSUE_TEMPLATE, crea un archivo Markdown (por ejemplo, bug_report.md).
+
Copia la estructura de la plantilla, que usualmente incluye secciones como descripción, pasos para reproducir el error y detalles adicionales.
+
+
Con esta plantilla, los colaboradores tendrán un formato estándar para reportar problemas, lo que ayuda a una mejor gestión y resolución.
+
¿Cómo sincronizar los cambios en GitHub?
+
+
Una vez creada la plantilla, verifica que los archivos cambiados estén marcados en verde en Visual Studio Code.
+
Realiza un commit (por ejemplo, “Bug Report agregado”).
+
Sincroniza con el repositorio de GitHub mediante el botón de flecha hacia arriba (push).
+
En GitHub, verifica que la plantilla esté disponible en la sección de Issues.
+
+
¿Qué ventajas tiene una plantilla de Issues?
+
Las plantillas simplifican el proceso de documentación de problemas y mejoran la comunicación al estandarizar la información que se solicita a los colaboradores. Esto ayuda a identificar los problemas de forma precisa y rápida.
+
¿Cómo personalizar las plantillas de Issues para casos específicos?
+
Además de la plantilla básica para bugs, puedes crear plantillas personalizadas como:
+
+
Document Report: Para señalar errores en la documentación.
+
Mejores prácticas: Para sugerir mejoras en la estructura del código.
+
+
Estas plantillas permiten a los colaboradores elegir el tipo de Issue que mejor se adapta al problema y agilizan la gestión del repositorio.
+
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/10-Lecturas recomendadas.txt" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/10-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..846244f3d654896f2766314b9fe9a44b899c09f0
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/10-Lecturas recomendadas.txt"
@@ -0,0 +1,3 @@
+https://docs.github.com/es/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/about-pull-requests
+https://docs.github.com/es/pull-requests
+https://github.com/platzi/git-github
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/10-Resumen.html" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/10-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..3947a9365eadbc49ee03c8f5f7a7b371f5d0bf35
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/10-Resumen.html"
@@ -0,0 +1,123 @@
+
+
+
+
+
+
+ Uso de Pull Requests en GitHub para Colaboración Efectiva
+
+
+
+
+
+
Resumen
Colaborar en GitHub requiere evitar modificar directamente la rama principal, lo que podría causar conflictos con el trabajo de otros compañeros. En su lugar, trabajar en ramas individuales y fusionarlas mediante Pull Requests (PR) es clave para un flujo de trabajo colaborativo y seguro.
+
¿Por qué evitar cambios directos en la rama principal?
+
Realizar cambios directamente en la rama principal (main) puede sobrescribir el trabajo no sincronizado de otros colaboradores. Este error común se evita al:
+
+
Crear una rama separada para cada contribuyente.
+
Fusionar cambios mediante una revisión en el Pull Request, antes de unirlos a la rama principal.
+
+
¿Cómo funciona un Pull Request?
+
+
Crear una Rama Nueva: Al iniciar cambios, crea una rama local específica. Por ejemplo, developer01.
+
Subir la Rama a GitHub: Usa git push -u origin para subir tu rama.
+
Notificar al Equipo: Al crear un Pull Request, notificas al equipo sobre tus cambios, lo que permite una revisión colaborativa (Code Review).
+
+
¿Qué papel juega la revisión de código?
+
El Code Review en los Pull Requests permite:
+
+
Evaluar y comentar los cambios antes de fusionarlos.
+
Aumentar la calidad y la visibilidad de los cambios propuestos.
+
+
Aunque puede ser intimidante al principio, esta práctica asegura transparencia y mejora continua en el equipo.
+
¿Cómo se fusiona un Pull Request?
+
+
Comparación y Revisión: Una vez que el equipo revisa los cambios y los aprueba, GitHub facilita la fusión con la rama principal.
+
Resolver Conflictos: GitHub verifica automáticamente conflictos potenciales, mostrando una marca verde si está listo para fusionarse sin problemas.
+
Eliminar la Rama: Tras la fusión, se elimina la rama para mantener el repositorio ordenado y listo para nuevas tareas.
+
+
¿Cómo puedo practicar Pull Requests de forma efectiva?
+
Para mejorar, colabora con un amigo o colega, practicando la creación y revisión de Pull Requests. Esta interacción entre ramas te ayudará a familiarizarte y a fluir con confianza en el proceso de colaboración en GitHub.
+
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/10-Uso de Pull Requests en GitHub para Colaboraci\303\263n Efectiva.mp4" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/10-Uso de Pull Requests en GitHub para Colaboraci\303\263n Efectiva.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..3a38ef0e222791bcaba3407a417c5f2f3c32272c
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/10-Uso de Pull Requests en GitHub para Colaboraci\303\263n Efectiva.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dd739b65c4c2c7eeeb904fd0bf104b6ee92e3bf23c741624ded4daecfd72ae03
+size 70558941
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/10-Uso de Pull Requests en GitHub para Colaboraci\303\263n Efectiva.vtt" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/10-Uso de Pull Requests en GitHub para Colaboraci\303\263n Efectiva.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..f8147b2a6fb3af9e581131f71afbce5f351c0fd9
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/10-Uso de Pull Requests en GitHub para Colaboraci\303\263n Efectiva.vtt"
@@ -0,0 +1,594 @@
+WEBVTT
+
+00:00.000 --> 00:05.160
+Uno de los retos más interesantes al
+trabajar de manera colaborativa en GitHub
+
+00:05.160 --> 00:12.000
+es tratar de evitar poner tu trabajo sobre
+el trabajo de los demás en la rama de main.
+
+00:12.000 --> 00:15.320
+Cuando tú quieres subir tus cambios,
+puedes hacerlo,
+
+00:15.320 --> 00:20.640
+bueno, puedes, pero no debes hacerlo
+directamente en main,
+
+00:20.640 --> 00:28.040
+porque sin ninguna intención podrías
+borrar algunos cambios no sincronizados,
+
+00:28.040 --> 00:30.720
+causando un pequeño problema en tu equipo.
+
+00:30.720 --> 00:35.520
+Para evitar eso, lo ideal es que cada
+quien trabaje en sus ramas
+
+00:35.520 --> 00:42.680
+y después contribuyan con una revisión
+previa de estas ramas hacia la rama principal.
+
+00:42.680 --> 00:47.880
+Para solucionar esto es que vamos a
+comenzar a utilizar los pull requests.
+
+00:47.880 --> 00:51.960
+Los pull requests me permiten fusionar los
+cambios de una rama local
+
+00:51.960 --> 00:55.200
+o de una rama externa con la rama principal.
+
+00:55.200 --> 00:56.560
+¿Cómo
+funciona?
+
+00:56.560 --> 00:58.480
+Yo voy a crear unos
+cambios.
+
+00:58.480 --> 01:03.280
+Voy a crear mi rama Amin Epinoza, cambio
+584.
+
+01:03.280 --> 01:09.320
+Con estos cambios y en esta rama, puedo
+subir mi rama local a GitHub.
+
+01:09.320 --> 01:11.840
+Creo un pull
+request.
+
+01:11.840 --> 01:17.560
+Esto significa que le estoy notificando a
+todo mi equipo de esos cambios realizados.
+
+01:17.560 --> 01:23.880
+Cualquier persona dentro de mi equipo
+puede entrar y revisar esos cambios.
+
+01:23.880 --> 01:26.960
+A este proceso se le llama Code Review.
+
+01:26.960 --> 01:32.480
+Y debo confesarlo, al principio puede que
+nos dé a todos un poco de pena
+
+01:32.480 --> 01:35.560
+saber que todos pueden evaluar nuestro código,
+
+01:35.560 --> 01:39.680
+pero es la mejor manera de saber que todos
+están conscientes
+
+01:39.680 --> 01:44.960
+de lo que yo estoy proponiendo como
+cambios o actualizaciones en el proyecto.
+
+01:44.960 --> 01:48.160
+Una vez que alguien o varias personas del
+equipo
+
+01:48.160 --> 01:52.240
+hayan aprobado estos cambios mediante este
+Code Review,
+
+01:52.240 --> 01:58.000
+entonces estos cambios en esta rama se
+fusionarán con la rama de main
+
+01:58.000 --> 02:01.280
+una vez que el pull request se haya cerrado.
+
+02:01.280 --> 02:06.000
+Me encuentro dentro de VS Code trabajando
+con el archivo de Readme
+
+02:06.000 --> 02:08.080
+y en la rama
+principal.
+
+02:08.080 --> 02:13.080
+Antes de avanzar, y esto es muy importante
+que lo tengamos presente
+
+02:13.080 --> 02:16.800
+para que se vuelva un hábito en nuestro
+trabajo,
+
+02:16.800 --> 02:19.960
+debo crear la rama que voy a utilizar.
+
+02:19.960 --> 02:22.680
+Damos clic en
+Main,
+
+02:22.680 --> 02:24.680
+crear nueva
+rama,
+
+02:25.960 --> 02:29.480
+y voy a ponerla como
+Developer01.
+
+02:31.160 --> 02:36.080
+Ya que Developer01 es la rama en la que
+voy a estar trabajando,
+
+02:36.080 --> 02:38.080
+entonces puedo
+poner
+
+02:39.680 --> 02:43.080
+cambios desde mi rama
+local
+
+02:43.080 --> 02:47.280
+llamada
+Developer01.
+
+02:47.280 --> 02:51.480
+Estos cambios ahora están reflejados solo
+en esta rama,
+
+02:51.480 --> 02:54.480
+en Developer y en mi entorno
+local.
+
+02:54.480 --> 02:59.480
+Voy a abrir mi terminal y primero escribir
+git branch
+
+02:59.480 --> 03:04.280
+para confirmar que estoy dentro de
+Developer01.
+
+03:04.280 --> 03:06.680
+Si escribo git
+status,
+
+03:08.680 --> 03:12.080
+podré ver reflejado el cambio que acabo de
+hacer.
+
+03:13.080 --> 03:15.080
+Escribo git
+add
+
+03:15.080 --> 03:17.880
+y git
+commit.
+
+03:20.480 --> 03:25.480
+Cambios desde
+Developer01.
+
+03:28.680 --> 03:33.280
+Listo, mis cambios han sido ingresados en
+mi rama local.
+
+03:33.280 --> 03:37.280
+Ahora debo de llevar esta rama local a GitHub.
+
+03:37.280 --> 03:40.680
+Y para hacerlo, puedo escribir git push,
+
+03:40.680 --> 03:42.880
+que es un comando que ya
+conocemos,
+
+03:42.880 --> 03:46.880
+con el guión u
+origin.
+
+03:46.880 --> 03:49.080
+Pero ahora, en lugar de
+main,
+
+03:49.080 --> 03:52.880
+voy a escribir la rama que quiero subir a
+GitHub,
+
+03:52.880 --> 03:56.880
+es decir,
+Developer01.
+
+03:57.480 --> 03:59.280
+Es más, antes de
+avanzar,
+
+03:59.280 --> 04:01.480
+vamos a ver qué
+pasa
+
+04:01.480 --> 04:05.080
+si quito todo esto y escribo solo git push.
+
+04:05.080 --> 04:10.680
+El mismo comando me dice que esa rama no
+está aún en la nube,
+
+04:10.680 --> 04:15.880
+y me pide escribir el comando git push set
+upstream
+
+04:15.880 --> 04:18.280
+origin
+developer01.
+
+04:18.280 --> 04:23.680
+Set upstream lo podemos compactar con
+guión u
+
+04:24.080 --> 04:30.080
+origin
+developer01.
+
+04:30.080 --> 04:32.080
+La verdad es que al
+principio,
+
+04:32.080 --> 04:35.080
+cuando comienzas a trabajar con tus ramas
+locales,
+
+04:35.080 --> 04:39.280
+es muy común que se te olvide escribir el
+origin de la nueva rama.
+
+04:39.280 --> 04:41.280
+A todos nos
+pasa.
+
+04:41.280 --> 04:43.680
+Mis cambios se han
+actualizado,
+
+04:43.680 --> 04:45.480
+y mejor
+todavía,
+
+04:45.480 --> 04:48.480
+git me dice que ya que se subieron los
+cambios,
+
+04:48.480 --> 04:53.480
+lo ideal sería crear un pull request para
+developer en GitHub
+
+04:53.480 --> 04:56.880
+visitando, y hasta me da el
+link.
+
+04:56.880 --> 04:59.280
+Voy a ir a mi portal de
+GitHub,
+
+04:59.280 --> 05:03.080
+y en mi repositorio ya me aparece este
+enorme mensaje
+
+05:03.080 --> 05:07.880
+que dice que developer01 tiene algunos
+cambios actualizados
+
+05:07.880 --> 05:09.680
+hace dos
+segundos.
+
+05:09.680 --> 05:13.280
+No he refrescado la página, por eso salen
+esos segundos.
+
+05:13.280 --> 05:16.680
+Ahora, lo que yo puedo hacer es ver que
+aquí en main
+
+05:16.680 --> 05:20.280
+todavía no se ve reflejada la rama de
+developer.
+
+05:20.280 --> 05:23.280
+Si quisieras, solamente actualiza un poco,
+
+05:24.480 --> 05:27.080
+y aquí te vas a dar cuenta que ya aparecen
+dos ramas,
+
+05:27.080 --> 05:30.080
+y por ahí anda
+developer01.
+
+05:30.080 --> 05:37.280
+Vamos a presionar el botón de comparar y
+pull request.
+
+05:37.280 --> 05:39.480
+En el título puedo
+poner,
+
+05:39.480 --> 05:44.680
+agregue un cambio a
+Readme.
+
+05:45.280 --> 05:48.880
+En la descripción debería de ser tan
+detallado
+
+05:48.880 --> 05:53.080
+como me sea posible con todo lo que hice
+en esta actualización.
+
+05:53.080 --> 05:57.880
+Simplemente voy a poner aquí solo un
+cambio más,
+
+05:57.880 --> 06:01.080
+pero recuerda poner la mayor cantidad de
+detalles
+
+06:01.080 --> 06:03.280
+posibles en esta
+parte.
+
+06:03.280 --> 06:06.280
+Creo un pull
+request.
+
+06:07.880 --> 06:11.080
+Git en automático va a empezar a
+trabajar
+
+06:11.080 --> 06:13.480
+dentro del portal de
+GitHub
+
+06:13.480 --> 06:16.480
+para revisar que no haya ningún
+conflicto
+
+06:16.480 --> 06:18.880
+y que no haya ningún
+problema.
+
+06:18.880 --> 06:21.080
+Me aparece una bella palomita
+verde
+
+06:21.080 --> 06:24.280
+diciendo que esta rama no tiene
+conflictos
+
+06:24.280 --> 06:26.680
+y que se podría
+fusionar.
+
+06:26.680 --> 06:28.880
+En este momento solo me resta
+esperar
+
+06:28.880 --> 06:31.280
+a la revisión del código o Code
+Review
+
+06:31.280 --> 06:33.080
+por parte de mis
+compañeros.
+
+06:33.080 --> 06:35.080
+Puedo moverme un poquito hacia
+arriba
+
+06:35.080 --> 06:40.080
+y darme cuenta que Miguel ya puso
+comenzando a revisar.
+
+06:40.080 --> 06:42.480
+Así que solo es cosa de
+esperar
+
+06:42.480 --> 06:44.880
+a que Miguel apruebe todos mis
+cambios
+
+06:44.880 --> 06:48.280
+y así se pueda cerrar este pull request.
+
+06:48.280 --> 06:52.680
+Mi pull request fue exitosamente fusionado
+y cerrado.
+
+06:52.680 --> 06:54.480
+Voy a desplazarme un poco hacia
+arriba
+
+06:54.480 --> 06:58.680
+y aquí este iconito morado dice todo está
+fusionado.
+
+06:58.680 --> 07:00.280
+Hay una parte
+importante.
+
+07:00.280 --> 07:02.080
+Como cereza en el
+pastel,
+
+07:02.080 --> 07:04.680
+desplázate de nuevo hacia
+abajo
+
+07:04.680 --> 07:07.880
+y selecciona el botón Eliminar rama.
+
+07:07.880 --> 07:10.680
+Developer 01 cumplió su
+objetivo,
+
+07:10.680 --> 07:13.680
+ya no necesitamos que esa rama siga
+existiendo.
+
+07:13.680 --> 07:15.680
+Le pongo Delete
+branch
+
+07:15.680 --> 07:20.080
+y yo me encargué de eliminar mi propia rama.
+
+07:20.080 --> 07:22.280
+De esta forma podría volver a
+crear
+
+07:22.280 --> 07:25.280
+Developer 01 para hacer una nueva
+tarea
+
+07:25.280 --> 07:27.480
+o alguna actividad
+diferente.
+
+07:27.480 --> 07:30.880
+Ahora, si yo me regreso a la parte
+principal
+
+07:30.880 --> 07:32.480
+de mi
+repositorio,
+
+07:32.480 --> 07:35.080
+ya no hay pull request
+activos,
+
+07:35.080 --> 07:37.480
+ya solo hay una
+rama
+
+07:37.480 --> 07:41.080
+y Miguel aquí muestra que
+fusionó
+
+07:41.080 --> 07:44.480
+el pull request de Developer
+01.
+
+07:44.480 --> 07:49.080
+Es decir, ahora ya están mis cambios
+dentro de main.
+
+07:49.080 --> 07:51.480
+Ahora que ya sabemos que todo está
+funcionando,
+
+07:51.480 --> 07:53.880
+ahora que ya sabemos la estrecha
+relación
+
+07:53.880 --> 07:55.680
+que hay entre Git y
+GitHub,
+
+07:55.680 --> 07:57.680
+es momento de comenzar a
+practicar.
+
+07:57.680 --> 08:00.080
+Una de las cosas que yo te
+recomendaría
+
+08:00.080 --> 08:01.880
+es que busques a un
+amigo
+
+08:01.880 --> 08:03.480
+que esté trabajando en tu
+equipo
+
+08:03.480 --> 08:05.480
+o con quien tengas una estrecha
+relación
+
+08:05.480 --> 08:07.480
+y practiquen los pull
+requests
+
+08:07.480 --> 08:09.280
+y la interacción entre las
+ramas.
+
+08:09.280 --> 08:11.480
+Búscate a quien más confianza le tengas,
+
+08:11.480 --> 08:14.080
+porque si no, puede rechazar tus
+comentarios
+
+08:14.080 --> 08:15.680
+dentro de los pull
+requests.
+
+08:15.680 --> 08:16.880
+No, en
+serio.
+
+08:16.880 --> 08:19.080
+Lo importante aquí es que
+practiques
+
+08:19.080 --> 08:22.080
+un poco entre esa interacción de ramas,
+
+08:22.080 --> 08:24.480
+porque es un ejercicio que al
+principio
+
+08:24.480 --> 08:27.080
+podría parecer un poco
+complicado,
+
+08:27.080 --> 08:29.480
+pero después fluirá de manera
+natural
+
+08:29.480 --> 08:30.880
+en todo tu
+equipo.
+
+08:30.880 --> 08:32.680
+De esta manera ya podrás
+saber
+
+08:32.680 --> 08:35.480
+cómo interactuar entre ambas
+herramientas
+
+08:35.480 --> 08:38.080
+para poder hacer que tu repositorio
+presente
+
+08:38.080 --> 08:41.000
+los últimos cambios dentro
+de tus proyectos de software.
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/11-Quiz.mhtml" "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/11-Quiz.mhtml"
new file mode 100644
index 0000000000000000000000000000000000000000..4536848b691d58cd37dd7f7920df692a7f06ec0b
--- /dev/null
+++ "b/Curso de Git y GitHub/02-Introducci\303\263n a GitHub/11-Quiz.mhtml"
@@ -0,0 +1,13243 @@
+From:
+Snapshot-Content-Location: https://platzi.com/clases/quiz/21259/
+Subject:
+Date: Sat, 8 Nov 2025 15:36:17 -0500
+MIME-Version: 1.0
+Content-Type: multipart/related;
+ type="text/html";
+ boundary="----MultipartBoundary--fkKXacQypxYsUDuvVxlP3oFaLUtrgmSY8WLy29mku0----"
+
+
+------MultipartBoundary--fkKXacQypxYsUDuvVxlP3oFaLUtrgmSY8WLy29mku0----
+Content-Type: text/html
+Content-ID:
+Content-Transfer-Encoding: quoted-printable
+Content-Location: https://platzi.com/clases/quiz/21259/
+
+
+ =20
+
+ =20
+
+
+
+
+
+
+
+
+
+
+
+ =20
+
+ =20
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ =20
+ =20
+ =20
+
+ =20
+
+ =20
+
+
+ =20
+
+ =20
+
+
+
+ =20
+
+
+ =20
+ =20
+ =20
+
+
+
Las herramientas colaborativas en GitHub han evolucionado, haciendo posible una organización eficaz y centralizada del trabajo en equipo sin la necesidad de mensajes o correos constantes. GitHub Projects destaca como una herramienta clave que permite gestionar tareas, fechas y recursos dentro de un solo espacio.
+
¿Cómo ayuda GitHub Projects en la organización de proyectos?
+
GitHub Projects facilita la organización de actividades dentro de equipos, permitiendo asignar tareas y priorizarlas según su urgencia. La herramienta cuenta con plantillas para diferentes tipos de proyectos, como la de Team Planning (planificación en equipo), que organiza tareas en un tablero Kanban con tres columnas: “Por hacer”, “En progreso” y “Hechas”.
+
¿Cómo crear y gestionar tareas en GitHub Projects?
+
Para crear una tarea en un proyecto de GitHub:
+
+
Accede a “Projects” en tu perfil y selecciona New Project.
+
Elige la plantilla que mejor se adapte al tipo de proyecto.
+
Crea una nueva actividad, por ejemplo, “Actualizar proyecto HTML”. Esto permitirá que todos en el equipo sepan qué tareas están pendientes.
+
+
Además, puedes definir prioridades, tamaños y tiempos estimados para cada tarea, basándote en metodologías ágiles, lo cual ayuda a coordinar el esfuerzo del equipo y optimizar el rendimiento en cada iteración.
+
¿Cómo asignar tareas y gestionar las responsabilidades del equipo?
+
Dentro de GitHub Projects, es posible asignar tareas a miembros del equipo, mostrando claramente las responsabilidades de cada persona. Cada tarea puede vincularse a un repositorio específico seleccionando la opción Convertir a un issue, lo que permite una relación directa entre la actividad y el código. Esta vinculación muestra un número identificador, útil para nombrar ramas en el repositorio y facilitar la organización.
+
¿Cómo gestionar múltiples proyectos y tareas personales?
+
Para aquellos que participan en varios proyectos o trabajan como freelancers, GitHub Projects es una solución que permite centralizar actividades y manejar múltiples repositorios. Al seleccionar la pestaña My Items, se filtran todas las tareas asignadas a ti, ayudándote a enfocarte sin distracciones.
+
¿Cuál es la importancia de estimar tiempos en GitHub Projects?
+
Aprender a estimar tiempos de manera precisa es esencial para el trabajo en equipo. GitHub Projects permite practicar la estimación del tiempo y la carga de trabajo en cada tarea, lo que ayuda a los desarrolladores a mejorar en la gestión de su propio tiempo y a contribuir de manera eficiente al equipo, evitando interrupciones.
+
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/02-Automatizaci\303\263n de flujos de trabajo en GitHub Projects.mp4" "b/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/02-Automatizaci\303\263n de flujos de trabajo en GitHub Projects.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..788f68bdbd33f88528c83c9a676625af8c2cfdc6
--- /dev/null
+++ "b/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/02-Automatizaci\303\263n de flujos de trabajo en GitHub Projects.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e78d1e8244a19bd44e6f36ccb075851a5549222427a143c873333c23e9f802d5
+size 78435874
diff --git "a/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/02-Automatizaci\303\263n de flujos de trabajo en GitHub Projects.vtt" "b/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/02-Automatizaci\303\263n de flujos de trabajo en GitHub Projects.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..c0a7a9d2c2b1a916ad0ff77e2613ab725a29e5f4
--- /dev/null
+++ "b/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/02-Automatizaci\303\263n de flujos de trabajo en GitHub Projects.vtt"
@@ -0,0 +1,676 @@
+WEBVTT
+
+00:00.000 --> 00:04.320
+Una de las cosas más importantes al hablar
+de llevar un proyecto de software
+
+00:04.320 --> 00:08.080
+es naturalmente ser productivos y ser rápidos.
+
+00:08.080 --> 00:11.840
+Si te pones a evaluar todo lo que acabamos
+de ver de projects,
+
+00:11.840 --> 00:15.360
+puede ser que sea invertir tiempo en
+burocracia
+
+00:15.360 --> 00:19.400
+que a lo mejor no se vea reflejado en el
+avance del proyecto.
+
+00:19.400 --> 00:22.760
+Sin embargo, podemos ahorrar muchos de
+estos pasos
+
+00:22.760 --> 00:25.920
+automatizando el flujo de trabajo de los
+proyects
+
+00:25.920 --> 00:28.080
+dentro de las actividades que
+hacemos
+
+00:28.080 --> 00:32.000
+en lo que creo que a todos más nos gusta,
+que es el código.
+
+00:32.000 --> 00:34.840
+Vamos a ver cómo automatizar y
+medir
+
+00:34.840 --> 00:37.680
+muchas de estas actividades dentro de
+GitHub Projects
+
+00:37.680 --> 00:42.760
+para poder ver el desempeño que tenemos
+como personas y como equipo.
+
+00:43.520 --> 00:47.120
+Comienza por mostrar tu repositorio de
+trabajo en GitHub.
+
+00:47.120 --> 00:50.400
+Y aquí vas a tener también, al igual que
+en tu perfil,
+
+00:50.400 --> 00:52.400
+la categoría de
+Projects.
+
+00:52.400 --> 00:54.400
+Selecciona esta
+categoría.
+
+00:55.400 --> 01:01.000
+Vas a darte cuenta que en tu
+repositorio no hay un proyecto vinculado.
+
+01:01.000 --> 01:03.000
+Y esto se puede solucionar muy fácil.
+
+01:03.100 --> 01:08.000
+Selecciona la opción de Enlaza un proyecto
+y te va a aparecer aquí esta opción.
+
+01:08.040 --> 01:12.000
+De hecho, aparece AminEspinoza10,
+Proyecto sin título.
+
+01:12.060 --> 01:15.000
+Esto lo tenemos que corregir antes de avanzar.
+
+01:15.000 --> 01:24.100
+Significa que puedo ir a AminEspinoza10,
+proyectos y aquí está el proyecto sin título de AminEspinoza.
+
+01:24.800 --> 01:33.000
+Voy a seleccionar el ícono de Editar
+y le voy a poner Mi proyecto individual.
+
+01:36.000 --> 01:43.840
+También podría agregar una descripción y hasta un Readme
+que explique qué es lo que este proyecto está haciendo
+
+01:43.840 --> 01:47.800
+y cuáles son las actividades principales del mismo.
+
+01:48.000 --> 01:52.000
+También puedes incluso hacer una copia
+o hasta eliminar el proyecto.
+
+01:53.000 --> 01:59.000
+Me voy a subir y antes de cambiar de sección,
+busca el botón de aquí, Guardar cambios.
+
+02:00.100 --> 02:07.400
+Tus cambios han sido guardados, así que puedes
+regresar a Settings y aparece como Mi proyecto individual.
+
+02:08.000 --> 02:13.000
+De nuevo, puedes regresar ahora sí a tu repositorio
+
+02:18.000 --> 02:26.000
+y en este repositorio, retomar la actividad de proyectos
+y enlazar un proyecto que sea con el nombre adecuado,
+
+02:26.000 --> 02:28.600
+Mi proyecto individual.
+
+02:29.000 --> 02:39.000
+Una vez que hayas tenido la palomita de enlace, ahora
+Mi proyecto individual está vinculado a este repositorio.
+
+02:40.000 --> 02:47.000
+De esta forma puedo comenzar a vincular actividades sin problema
+y para ello necesito seleccionar Mi proyecto individual.
+
+02:47.000 --> 02:50.800
+Y podrás ver las actividades que estás haciendo.
+
+02:50.800 --> 02:58.000
+Vamos a decir que actualizar Mi proyecto HTML
+ya está en progreso y crear un par de actividades más.
+
+02:58.100 --> 03:09.000
+Actualizar archivo CSS
+y también actualizar archivo JavaScript.
+
+03:10.000 --> 03:14.000
+Estas actividades son las actividades
+que tengo pendientes por hacer.
+
+03:14.000 --> 03:25.800
+Puedo decir que la tarea de HTML ya está marcada como
+hecha y que actualizar archivo CSS es mi próxima tarea en progreso.
+
+03:26.000 --> 03:31.000
+Ahora que yo tengo diferentes estatus de
+actividades en todo lo que tengo pendiente,
+
+03:31.000 --> 03:36.800
+puedo seleccionar aquí arriba
+a la derecha la gráfica que dice Insights.
+
+03:37.000 --> 03:44.000
+Si vas a esta sección, vas a poder ver
+una gráfica de status que te describa cuántas son las actividades
+
+03:44.000 --> 03:49.800
+que están en progreso, pendientes por
+hacer y ya hechas.
+
+03:49.800 --> 03:53.800
+Así puedes medir la eficacia de todas las
+actividades
+
+03:53.800 --> 03:57.800
+o también ubicar a quienes suelen
+olvidarse
+
+03:57.800 --> 04:01.800
+el cambio de status de todas estas
+actividades.
+
+04:01.800 --> 04:04.800
+Yo soy uno de esos y por eso es que
+trabajo con los issues
+
+04:04.800 --> 04:09.800
+lo haga de manera automática y eso es muy
+fácil de configurar.
+
+04:09.800 --> 04:12.800
+Si quieres que no se te olvide actualizar
+los estados,
+
+04:12.800 --> 04:15.800
+selecciona estos tres
+puntos.
+
+04:15.800 --> 04:18.800
+La categoría de
+Workflows
+
+04:18.800 --> 04:21.800
+y aquí están los flujos de
+trabajo
+
+04:21.800 --> 04:26.800
+que te dicen qué sucede cada vez que una
+acción sucede.
+
+04:26.800 --> 04:29.800
+Por ejemplo, en la categoría de Item cerrado,
+
+04:29.800 --> 04:33.800
+lo primero que aparece es que cuando un
+ítem fue cerrado
+
+04:33.800 --> 04:36.800
+es decir, un issue o un pull request,
+
+04:36.800 --> 04:41.800
+el valor de la actividad será cambiado
+automáticamente a hecho.
+
+04:41.800 --> 04:43.800
+Si quieres alterar este comportamiento,
+
+04:43.800 --> 04:46.800
+puedes seleccionar la opción de
+Editar
+
+04:46.800 --> 04:50.800
+y aquí escoger una de las dos categorías.
+
+04:50.800 --> 04:53.800
+También puedes cambiar el status de la
+tarea
+
+04:53.800 --> 04:56.800
+a que solo se mantenga en
+progreso
+
+04:56.800 --> 05:00.800
+o como está por defecto y en ya hecho.
+
+05:00.800 --> 05:04.800
+Guarda tus cambios seleccionando el botón
+verde
+
+05:04.800 --> 05:08.800
+y puedes así habilitar cada uno de los
+flujos que hay aquí.
+
+05:08.800 --> 05:11.800
+Por ejemplo, en el Code Review aprobado,
+
+05:11.800 --> 05:14.800
+básicamente es la
+antesala
+
+05:14.800 --> 05:17.800
+de poder mezclar o fusionar un pull request.
+
+05:17.800 --> 05:19.800
+Aquí puedes seleccionar la
+opción
+
+05:19.800 --> 05:23.800
+de que cuando un pull request sea aprobado,
+
+05:23.800 --> 05:25.800
+entonces
+editas
+
+05:25.800 --> 05:30.800
+y el status de la tarea puede cambiar a hecho.
+
+05:30.800 --> 05:33.800
+Guardas tus cambios y de esta
+forma
+
+05:33.800 --> 05:36.800
+ya no tendrás que recordar regresar a tus
+columnas
+
+05:36.800 --> 05:39.800
+y cambiar la actividad de tus tareas.
+
+05:39.800 --> 05:42.800
+Estas podrán cambiarse de manera automática.
+
+05:42.800 --> 05:44.800
+Con mi configuración ya
+realizada,
+
+05:44.800 --> 05:47.800
+es momento de verificar que ahora
+sí
+
+05:47.800 --> 05:49.800
+este flujo se
+automatice.
+
+05:49.800 --> 05:52.800
+Voy a regresar a mi lista de actividades.
+
+05:52.800 --> 05:57.800
+Selecciona la actividad de actualizar
+archivo CSS.
+
+05:57.800 --> 05:59.800
+Selecciona los tres
+puntos,
+
+05:59.800 --> 06:02.800
+conviértelo en un
+issue
+
+06:02.800 --> 06:06.800
+y selecciona el repositorio en el que
+estás trabajando.
+
+06:06.800 --> 06:08.800
+Esto ya está en color
+verde.
+
+06:08.800 --> 06:12.800
+Ya hay un issue creado a partir de esta
+actividad.
+
+06:12.800 --> 06:14.800
+Selecciona la
+actividad
+
+06:14.800 --> 06:17.800
+y por aquí después del
+Open
+
+06:17.800 --> 06:20.800
+está tu nombre de usuario y tu repositorio.
+
+06:20.800 --> 06:25.800
+Puedes ir de manera rápida a este
+repositorio así.
+
+06:25.800 --> 06:28.800
+Ya que estás en el repositorio, recuerda,
+
+06:28.800 --> 06:32.800
+lo primero y más importante es crear una
+nueva rama.
+
+06:32.800 --> 06:35.800
+Selecciona la categoría de
+ramas,
+
+06:35.800 --> 06:38.800
+presiona el botón de New
+Branch
+
+06:38.800 --> 06:42.800
+y aquí le vamos a poner a min diagonal
+17
+
+06:42.800 --> 06:45.800
+si no recuerdo mal el nombre de mi
+actividad
+
+06:45.800 --> 06:47.800
+porque alcancé a
+verlo.
+
+06:47.800 --> 06:50.800
+Ya que tengo mi rama, regreso al
+código
+
+06:50.800 --> 06:53.800
+y aquí puedo agregar un nuevo archivo,
+
+06:53.800 --> 06:57.800
+no sin antes, naturalmente cambiará a min 17.
+
+06:59.800 --> 07:02.800
+Listo, a min 17 ya es mi rama de trabajo,
+
+07:02.800 --> 07:04.800
+agrego un
+archivo
+
+07:06.800 --> 07:11.800
+que se va a llamar
+style.css
+
+07:11.800 --> 07:13.800
+y dentro de style por
+ahora
+
+07:13.800 --> 07:15.800
+solamente voy a poner un comentario que
+diga
+
+07:15.800 --> 07:20.800
+aquí irá toda mi hoja de
+estilos.
+
+07:25.800 --> 07:29.800
+Guardo los comentarios, guardo los
+cambios
+
+07:29.800 --> 07:34.800
+y con el create style.css verifico que mi
+rama
+
+07:34.800 --> 07:38.800
+sí sea a min diagonal
+17.
+
+07:39.800 --> 07:41.800
+Guardo los
+cambios
+
+07:41.800 --> 07:44.800
+y regreso a la portada de mi
+proyecto
+
+07:44.800 --> 07:47.800
+en donde me dice que ya hay una
+actualización
+
+07:47.800 --> 07:51.800
+en esta rama y que tengo que crear un pull
+request.
+
+07:51.800 --> 07:57.800
+Dentro de mi pull request pongo create style.
+css
+
+07:57.800 --> 08:01.800
+y una parte muy importante dentro de la
+descripción
+
+08:01.800 --> 08:05.800
+de este proyecto o de este pull
+request
+
+08:05.800 --> 08:08.800
+es que tengo que escribir primero lo que hice.
+
+08:08.800 --> 08:13.800
+Agregue el archivo
+CSS
+
+08:13.800 --> 08:18.800
+y después voy a escribir la palabra closes,
+
+08:18.800 --> 08:22.800
+un signo de numeral o un
+gatito
+
+08:22.800 --> 08:25.800
+y seleccionar el issue que estoy creando.
+
+08:25.800 --> 08:28.800
+Actualizar archivo
+CSS
+
+08:28.800 --> 08:30.800
+o de hecho el issue que ya tengo
+creado
+
+08:30.800 --> 08:32.800
+y que quiero
+solucionar.
+
+08:32.800 --> 08:36.800
+Cuando haces esto creas el pull
+request
+
+08:36.800 --> 08:40.800
+y te vas a dar cuenta que hay un
+enlace
+
+08:40.800 --> 08:43.800
+directo hacia ese
+issue.
+
+08:43.800 --> 08:46.800
+Además de que si te desplazas un poco
+hacia abajo
+
+08:46.800 --> 08:49.800
+dentro de la categoría de
+development
+
+08:49.800 --> 08:51.800
+está el issue
+asociado.
+
+08:51.800 --> 08:54.800
+Actualizar archivo
+CSS
+
+08:54.800 --> 08:56.800
+es lo único para lo que
+sirve
+
+08:56.800 --> 08:59.800
+esta palabra mágica de
+closes.
+
+08:59.800 --> 09:01.800
+Esperaré a que Miguel, mi compañero,
+
+09:01.800 --> 09:04.800
+me apruebe este pull
+request.
+
+09:04.800 --> 09:09.800
+Después de como 5 horas de extensa
+revisión de Miguel
+
+09:09.800 --> 09:13.800
+este pull request ya fue fusionado y cerrado.
+
+09:13.800 --> 09:15.800
+Puedo eliminar la
+rama
+
+09:15.800 --> 09:17.800
+y antes de hacerlo puedo darme
+cuenta
+
+09:17.800 --> 09:20.800
+que en la categoría de
+development
+
+09:20.800 --> 09:23.800
+el issue también ya está
+cerrado.
+
+09:23.800 --> 09:25.800
+Elimino mi
+rama.
+
+09:25.800 --> 09:27.800
+Me desplazo hacia
+arriba
+
+09:27.800 --> 09:30.800
+y ve en la sección de
+issues
+
+09:30.800 --> 09:32.800
+que ya no hay un issue
+abierto.
+
+09:32.800 --> 09:34.800
+Si te vas a
+projects,
+
+09:34.800 --> 09:36.800
+mi proyecto
+individual,
+
+09:36.800 --> 09:39.800
+verás que también la actividad que
+tenías
+
+09:39.800 --> 09:42.800
+de crear el archivo
+CSS
+
+09:42.800 --> 09:45.800
+ya pasó de in progress a
+done.
+
+09:45.800 --> 09:48.800
+Ahora que vimos que este flujo se puede
+automatizar
+
+09:48.800 --> 09:50.800
+tú ya no tienes que
+preocuparte
+
+09:50.800 --> 09:52.800
+por actualizar el estado de tus tareas.
+
+09:52.800 --> 09:54.800
+Es mucho más cómodo
+permitir
+
+09:54.800 --> 09:57.800
+que un flujo automatizado se encargue de eso.
+
+09:57.800 --> 09:59.800
+Hay que mencionar que en el
+escenario
+
+09:59.800 --> 10:01.800
+que acabamos de
+ver
+
+10:01.800 --> 10:03.800
+todo lo hicimos desde
+GitHub.
+
+10:03.800 --> 10:06.800
+Cuando toda esa gestión de la nueva rama,
+
+10:06.800 --> 10:09.800
+subir tus cambios y actualizar este
+archivo
+
+10:09.800 --> 10:11.800
+pudiste hacerlo desde la
+terminal
+
+10:11.800 --> 10:14.800
+o desde VS Code sin ningún problema.
+
+10:14.800 --> 10:16.800
+Para fines de
+aprendizaje
+
+10:16.800 --> 10:18.800
+funciona hacerlo desde
+web.
+
+10:18.800 --> 10:20.800
+En un escenario
+real
+
+10:20.800 --> 10:22.800
+siempre será utilizando
+cualquiera
+
+10:22.800 --> 10:24.800
+de estas otras dos
+herramientas.
+
+10:24.800 --> 10:26.800
+También considera que los
+workflows
+
+10:26.800 --> 10:28.800
+son el primer paso para
+automatizar
+
+10:28.800 --> 10:30.800
+muchas más
+tareas.
+
+10:30.800 --> 10:33.800
+Tienen extensiones que pueden mandar un
+mensaje
+
+10:33.800 --> 10:36.800
+cuando el pull request haya sido
+cerrado
+
+10:36.800 --> 10:38.800
+a tu Slack, a tu
+Teams
+
+10:38.800 --> 10:41.800
+o por un correo electrónico a todo tu
+equipo
+
+10:41.800 --> 10:44.800
+notificándoles que tu actividad está
+concluida.
+
+10:44.800 --> 10:46.800
+De esa forma puedes
+expandir
+
+10:46.800 --> 10:48.800
+mucho más la
+funcionalidad
+
+10:48.800 --> 10:52.000
+de todo lo que puedes
+automatizar desde GitHub.
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/02-Lecturas recomendadas.txt" "b/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/02-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..6284f712c402efb6b9af0d7704fb7b20f514d3f7
--- /dev/null
+++ "b/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/02-Lecturas recomendadas.txt"
@@ -0,0 +1,3 @@
+https://github.com/platzi/git-github
+https://docs.github.com/en/issues/planning-and-tracking-with-projects
+https://github.com/features/issues
diff --git "a/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/02-Resumen.html" "b/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/02-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..a50d0a473208f00fe0294e9758c2a15298d5d742
--- /dev/null
+++ "b/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/02-Resumen.html"
@@ -0,0 +1,128 @@
+
+
+
+
+
+
+ Automatización de flujos de trabajo en GitHub Projects
+
+
+
+
+
+
Resumen
Automatizar tareas en proyectos de software es esencial para ahorrar tiempo y mejorar la productividad. Con GitHub Projects, puedes configurar flujos de trabajo automáticos que simplifican la gestión y seguimiento de actividades, permitiendo un enfoque directo en el código.
+
¿Cómo vincular y personalizar un proyecto en GitHub?
+
+
Accede a tu repositorio en GitHub y selecciona la categoría de “Projects.”
+
Si no tienes un proyecto vinculado, selecciona la opción “Enlazar a un proyecto.”
+
Edita el proyecto sin título agregando un nombre relevante, como “Mi proyecto individual,” y, opcionalmente, una descripción y un README.
+
Guarda los cambios y regresa al repositorio para enlazar este proyecto.
+
+
¿Cómo gestionar y actualizar actividades dentro del proyecto?
+
+
Dentro de tu proyecto vinculado, crea actividades como “Actualizar archivo HTML,” “Actualizar archivo CSS,” o “Actualizar archivo JavaScript.”
+
Marca el estado de cada tarea: en progreso, pendiente o completada.
+
Usa la sección “Insights” para ver un gráfico del estado de las actividades y medir la eficacia del equipo.
+
+
¿Cómo automatizar los cambios de estado en actividades?
+
+
Entra en los flujos de trabajo (Workflows) seleccionando los tres puntos en la esquina superior de tu proyecto.
+
Configura las reglas, por ejemplo, para que un issue o pull request cerrado cambie automáticamente el estado de la actividad a “Hecho.”
+
Personaliza otros workflows como el cambio de estado cuando un pull request es aprobado, asegurando que la automatización se adapte a tus necesidades.
+
+
¿Cómo crear y enlazar un issue desde una actividad?
+
+
Selecciona una actividad como “Actualizar archivo CSS,” presiona los tres puntos y conviértela en un issue en el repositorio.
+
Crea una nueva rama desde la sección de ramas, nómbrala de forma clara, y agrega los cambios necesarios en el archivo, por ejemplo, un nuevo archivo style.css.
+
Guarda los cambios, crea un pull request y describe los cambios. Usa la palabra clave closes seguido del número de issue para que GitHub lo cierre automáticamente cuando se apruebe el pull request.
+
+
¿Qué ventajas ofrece el flujo automatizado en GitHub?
+
Con esta automatización:
+
+
El estado de las tareas se actualiza solo, sin necesidad de hacerlo manualmente.
+
Los workflows pueden expandirse para notificar por Slack, Teams o correo electrónico cada vez que un pull request se cierra, facilitando la comunicación y el seguimiento en equipo.
+
GitHub Projects, junto con estas integraciones, permite un flujo de trabajo robusto y ágil.
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/03-Recursos Esenciales de Markdown para Documentaci\303\263n Efectiva.mhtml" "b/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/03-Recursos Esenciales de Markdown para Documentaci\303\263n Efectiva.mhtml"
new file mode 100644
index 0000000000000000000000000000000000000000..eddc6677cfbc2241cb0f6b18001dc0d4a7df411e
--- /dev/null
+++ "b/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/03-Recursos Esenciales de Markdown para Documentaci\303\263n Efectiva.mhtml"
@@ -0,0 +1,26233 @@
+From:
+Snapshot-Content-Location: https://platzi.com/cursos/gitgithub/documentacion-en-github-con-markdown/
+Subject: =?utf-8?Q?Recursos=20Esenciales=20de=20Markdown=20para=20Documentaci=C3?=
+ =?utf-8?Q?=B3n=20Efectiva?=
+Date: Sat, 8 Nov 2025 15:37:13 -0500
+MIME-Version: 1.0
+Content-Type: multipart/related;
+ type="text/html";
+ boundary="----MultipartBoundary--Ie8RpUZ0gbWjZkjHZdhlSjc0N23npxy1t2L4lzBwJT----"
+
+
+------MultipartBoundary--Ie8RpUZ0gbWjZkjHZdhlSjc0N23npxy1t2L4lzBwJT----
+Content-Type: text/html
+Content-ID:
+Content-Transfer-Encoding: quoted-printable
+Content-Location: https://platzi.com/cursos/gitgithub/documentacion-en-github-con-markdown/
+
+Recursos Esenciales de Markdow=
+n para Documentaci=C3=B3n Efectiva
Herramientas =C3=BAtiles para documentaci=C3=B3n con Markdow=
+n
+
En las clases anteriores has visto la relevancia de trabajar con Markdow=
+n y lo mucho que este lenguaje te puede ayudar para crear una gran document=
+aci=C3=B3n. En esta clase lo que veremos son algunos de los much=C3=ADsimos=
+ recursos que puedes utilizar para poder escribir de una gran manera utiliz=
+ando Markdown de la mejor manera posible. =C2=A1Comencemos!
Simplemente, la mejor referencia para conocer todo lo que se puede hacer=
+ con Markdown dentro de los documentos, aqu=C3=AD puedes comenzar a leer mu=
+cho.
+
+
Mi primera sugerencia es irte a la opci=C3=B3n de Cheat Sheet, en esta secci=C3=B3n podr=C3=A1s enco=
+ntrar todo lo que puedes hacer, desde la sintaxis b=C3=A1sica hasta la exte=
+ndida. Lo mejor que puedes hacer comenzar a practicar aqu=C3=AD con esto, l=
+a verdad es que si sabes usar estas caracter=C3=ADsticas ya est=C3=A1s domi=
+nando el 90% de todo el trabajo.
+
Tambi=C3=A9n considera que Markdown es compatible con algunas funciones =
+de html como </img>, lo que te permitir=C3=ADa jugar=
+ un poco m=C3=A1s con el dise=C3=B1o de tu documento.
+
Si tienes un poco m=C3=A1s de tiempo libre estar=C3=ADa fenomenal visita=
+r la secci=C3=B3n de Get Started en donde el sitio explica=
+ como funciona Markdown lo que es una lectura muy buena para aprender un po=
+co m=C3=A1s. =C2=A1Dale un vistazo!
+
Extensi=C3=B3n de Markdown para VS Code
+
Ya que conoces lo que Markdown puede hacer y su sintaxis lo mejor que pu=
+edes hacer es instalar la extensi=C3=B3n de Markdown dentro de VS Code, est=
+o te puede llevar a un nivel mucho m=C3=A1s avanzado de documentaci=C3=B3n =
+porque te puede ayudar con la estructura del proyecto mostr=C3=A1ndote las =
+reglas que es recomendable no dejar en el documento.
+
Puedes encontrar el enlace de la extensi=C3=B3n aqu=C3=AD.
+
Dentro de VS Code la imagen es como la siguiente:
+
+
Una vez que lo hayas instalado entonces es momento de ponerla en prueba =
+y para ello debes simplemente cometer un par de errores al momento de escri=
+bir tu documento. Yo lo hice con este que ahora est=C3=A1s leyendo. Podr=C3=
+=A1s ver las l=C3=ADneas amarillas en cada l=C3=ADnea por corregir.
+
+
=C2=BFQuieres lo mejor? Solo basta que te coloques encima de las l=C3=AD=
+neas para que puedas conocer el error que puedes corregir.
+
+
Solo es cosa de que veas la regla y la modifiques, te debo confesar que =
+esta extensi=C3=B3n me ha hecho aprender a redactar de manera m=C3=A1s efic=
+iente mis documentos. =C2=A1Me encantar=C3=ADa recordar qui=C3=A9n me la en=
+se=C3=B1=C3=B3 para poder agradecerle por el gran tip!
+
Previsualizaci=C3=B3n de Markdown
+
Dentro de VS Code puedes previsualizar todos los documentos markdown ant=
+es de colocarlos en un control de versiones, solo es necesario que te ubiqu=
+es en la esquina superior derecha para encontrar un =C3=ADcono con una lupa=
+ y que te permite previsualizar el documento.
+
+
Al hacerlo podr=C3=A1s ver una divisi=C3=B3n entre el documento que est=
+=C3=A1s editando y su presentaci=C3=B3n final d=C3=A1ndote no solo una vist=
+a previa, sino que tambi=C3=A9n podr=C3=A1 mostrar cualquier error como una=
+ ruta de im=C3=A1genes mal direccionada o cosas por el estilo.
+
+
Usar esta vista es un recurso que puedes utilizar para muchas opciones, =
+como evitar un commit que repare los errores de uno anterior. Lo importante=
+ es que si usas el monitor de una laptop podr=C3=A1 ser un poco complicado =
+y es aqu=C3=AD donde podr=C3=A1s ansiar tener un monitor ultra wide para tr=
+abajar con total felicidad (=C2=A1yo quiero uno de esos!).
+
Diagramas Mermaid
+
Dejando de lado la funcionalidad b=C3=A1sica de lo que puedes hacer con =
+los markdown y VS Code podemos dar un paso adelante y utilizar una herramie=
+nta que te har=C3=A1 hacer documentos de otro nivel con los diagramas merma=
+id.
+
Estos diagramas te permiten dise=C3=B1ar gr=C3=A1ficas de muchos niveles=
+ y personalizarlas con la complejidad que deseas.
+
Por ejemplo, gracias a un c=C3=B3digo similar al siguiente podr=C3=A1s r=
+epresentar el flujo de interacci=C3=B3n entre diferentes ramas, muy acorde =
+a nuestro curso =C2=BFno?
Al insertar el c=C3=B3digo en tu documento podr=C3=A1s ver el resultado =
+luciendo como esta imagen.
+
+
Hacer diagramas as=C3=AD es muy =C3=BAtil para representar flujos de tra=
+bajo de una manera visual y mucho m=C3=A1s c=C3=B3modos de entender, adem=
+=C3=A1s, una ventaja adicional, es que no se requiere ninguna instalaci=C3=
+=B3n o configuraci=C3=B3n adicional, simplemente agregas el diagrama y todo=
+ aparece de maravilla.
Ojal=C3=A1 te animes a usar todas estas herramientas para hacer lo que t=
+odo desarrollador de software debe hacer =C2=A1Una gran documentaci=C3=B3n!=
+
Aprender a crear una portada atractiva y funcional en GitHub usando Markdown no solo mejora la presentación profesional de un perfil, sino que también permite personalizarlo con elementos visuales, enlaces y badges que muestran actividad e información de contacto. Aquí encontrarás un paso a paso para utilizar Markdown y hacer que tu perfil destaque.
+
¿Cómo iniciar el repositorio especial en GitHub?
+
+
Crear un repositorio: Ve a la sección de repositorios y crea uno nuevo usando el mismo nombre que tu nombre de usuario en GitHub; esto permite que el repositorio funcione como portada.
+
Descripción y visibilidad: Añade una descripción breve (ej. “Portada de perfil”), hazlo público y agrega un archivo README.md. Esto es esencial para que el contenido sea visible en tu perfil.
+
Clonación del repositorio: Clona el repositorio usando git clone en la terminal. La opción HTTPS es conveniente para nuevos perfiles, aunque SSH es más seguro.
+
+
¿Cómo personalizar el README con Markdown?
+
Markdown facilita la creación de secciones y elementos visuales. Puedes agregar:
+
+
Títulos y subtítulos: Usa #, ## o ### según la jerarquía. Por ejemplo, ## Contacto.
+
Enlaces y badges: Incluye enlaces usando [Texto](URL). Para badges, visita shields.io donde encontrarás diferentes opciones (ej. actividad de commits, sitios web).
+
Iconos y emojis: Puedes agregar emojis como :computer: o :pencil: para destacar roles o actividades.
+
+
¿Cómo previsualizar y ajustar el archivo en Visual Studio Code?
+
+
Vista previa de Markdown: Selecciona Open Preview en la esquina superior derecha para ver cómo se verán los cambios en GitHub.
+
Extensiones recomendadas: Markdown Lint ayuda a mejorar el estilo al sugerir tips sobre el formato, como evitar espacios en blanco innecesarios.
+
Limpieza del código: Markdown Lint también ayuda a mantener el archivo ordenado eliminando líneas en blanco que no son necesarias.
+
+
¿Cómo añadir y ajustar badges en el perfil de GitHub?
+
+
Visita shields.io y busca categorías de badges como:
+
+
Website: Permite agregar un enlace a tu sitio web.
+
Actividad de Commits: Muestra la frecuencia de tus commits en GitHub. Puedes seleccionar el intervalo: weekly, monthly, yearly, o total.
+
+
+
Insertar badges en Markdown: Selecciona “Markdown” en shields.io para obtener el código y pégalo en el README.md.
+
Prueba de visualización: Asegúrate de que los badges se muestren correctamente en Visual Studio Code.
+
+
¿Qué estrategias aplicar para mejorar la portada en GitHub?
+
+
Referencias a otros repositorios: Examina perfiles de otros usuarios o proyectos con buena documentación. Visualiza su archivo README.md en modo “RAW” para ver el código en Markdown.
+
Explora y adapta: La práctica es clave; revisa diferentes perfiles para encontrar ideas y técnicas que puedas adaptar.
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/05-Creaci\303\263n y Gesti\303\263n de Wikis en GitHub.mhtml" "b/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/05-Creaci\303\263n y Gesti\303\263n de Wikis en GitHub.mhtml"
new file mode 100644
index 0000000000000000000000000000000000000000..39454e5e36cfda74ef2fdd51a67cf0eb02d59667
--- /dev/null
+++ "b/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/05-Creaci\303\263n y Gesti\303\263n de Wikis en GitHub.mhtml"
@@ -0,0 +1,28803 @@
+From:
+Snapshot-Content-Location: https://platzi.com/cursos/gitgithub/uso-de-wikis/
+Subject: =?utf-8?Q?Creaci=C3=B3n=20y=20Gesti=C3=B3n=20de=20Wikis=20en=20GitHub?=
+Date: Sat, 8 Nov 2025 15:37:52 -0500
+MIME-Version: 1.0
+Content-Type: multipart/related;
+ type="text/html";
+ boundary="----MultipartBoundary--Ykw5ida2QwRqG0FMY1cpvFwXufRPJQE2aCn8jdx3um----"
+
+
+------MultipartBoundary--Ykw5ida2QwRqG0FMY1cpvFwXufRPJQE2aCn8jdx3um----
+Content-Type: text/html
+Content-ID:
+Content-Transfer-Encoding: quoted-printable
+Content-Location: https://platzi.com/cursos/gitgithub/uso-de-wikis/
+
+Creaci=C3=B3n y Gesti=C3=B3n d=
+e Wikis en GitHub=
+=
+
Confirmar tu correo=
+
Enviamos un enlace de confirmaci=C3=B3n a tu correo =
+electr=C3=B3nico tomalabecker68@gmail.com
En las clases hemos visto como utilizar el archivo README.md para mostrar la documentaci=C3=B3n del proyecto, con el tiempo e=
+sta pr=C3=A1ctica ha ganado cada vez m=C3=A1s adopci=C3=B3n por su sencille=
+z, pero eso no es la =C3=BAnica manera de crear documentaci=C3=B3n.
+
Para ello existe dentro de Github la opci=C3=B3n de crear una Wiki en do=
+nde puedes generar un nivel m=C3=A1s estructurado de documentaci=C3=B3n. Pu=
+edes ver la secci=C3=B3n de Wiki en tus proyectos en la secci=C3=B3n superi=
+or del portal de Github.
+
<=
+/div>
+
Si seleccionas esta opci=C3=B3n entonces podr=C3=A1s ver un bot=C3=B3n q=
+ue te invita a crear tu primera p=C3=A1gina, hazlo presi=C3=B3nalo.
+
+
El formulario te da la opci=C3=B3n de crear una nueva p=C3=A1gina a la q=
+ue llama Home lo que es una gran opci=C3=B3n, puedes usar =
+esta p=C3=A1gina para mostrar la documentaci=C3=B3n inicial, pero tambi=C3=
+=A9n la puedes usar como un =C3=ADndice para poder llevar a tu lector a dif=
+erentes secciones y eso es lo que vamos a hacer. Escribe lo siguiente en tu=
+ formulario.
+
=
+# =C2=A1Bienvenido a la wiki!
+
+Aqu=C3=AD =
+podr=C3=A1s encontrar todas las secciones para poder implementar tu proyect=
+o de manera r=C3=A1pida y simple.
+
+## =C3=8Dndice de navegaci=C3=B3n
+
+[Explicaci=C3=B3n d=
+el proyecto](/=
+proyecto.=
+md)
+
Si presionas el bot=C3=B3n de guardar los cambios, el resultado de esta =
+primera edici=C3=B3n es igual al de esta imagen.
+
<=
+/div>
+
Repite la misma operaci=C3=B3n, ahora con una nueva p=C3=A1gina llamada =
+Proyecto, en su descripci=C3=B3n puedes agregar cualquier contenido, en la =
+imagen que sigue puedes ver un ejemplo de como debe lucir tu nueva p=C3=A1g=
+ina.
+
+
Si guardas los cambios, entonces el resultado de la estructura de tu wik=
+i lucir=C3=A1 de la siguiente manera.
+
+
Comienza a crear algunas p=C3=A1ginas, no te dir=C3=A9 cuantas ni con qu=
+=C3=A9 nombres para que te diviertas, lo que s=C3=AD har=C3=A9 es mostrarte=
+ como luce mi wiki al final.
+
+
Ahora vuelve a tu p=C3=A1gina Home en donde agregaste u=
+n poco de texto y adem=C3=A1s un enlace, en la esquina superior derecha hay=
+ un bot=C3=B3n con el que puedes editarla. En el c=C3=B3digo markdown de aq=
+u=C3=AD abajo podr=C3=A1s ver una manera f=C3=A1cil en la que puedes navega=
+r entre secciones.
+
=
+# =C2=A1Bienvenido a la wiki!
+
+Aqu=C3=AD =
+podr=C3=A1s encontrar todas las secciones para poder implementar tu proyect=
+o de manera r=C3=A1pida y simple.
+
+## =C3=8Dndice de navegaci=C3=B3n
+
+[Explicaci=C3=B3n d=
+el proyecto](./Proyecto)
+
+[Arquitectura](./Arqu=
+itectura)=
+
+
+[Documentaci=C3=B3n](./Documentaci=C3=B3n)
+
Con este =C3=ADndice es f=C3=A1cil que tus usuarios puedan navegar entre=
+ las secciones de una manera c=C3=B3moda, lo que estar=C3=ADa fenomenal es =
+que ahora les facilites a tus usuarios volver a la secci=C3=B3n principal e=
+n cada una de tus secciones para que la navegaci=C3=B3n se vuelva c=C3=ADcl=
+ica y as=C3=AD les sea muy f=C3=A1cil moverse entre todas las secciones. =
+=C2=BFC=C3=B3mo har=C3=ADas eso?
+
Volvamos a la pantalla principal de la wiki y observa que debajo del men=
+=C3=BA de p=C3=A1ginas est=C3=A1 una secci=C3=B3n que te permite crear una =
+barra lateral personalizada, selecciona esta opci=C3=B3n.
+
+
Al hacerlo notar=C3=A1s un formulario id=C3=A9ntico a los anteriores, so=
+lo que con un t=C3=ADtulo diferente en donde podr=C3=A1s personalizar todos=
+ los detalles de la barra lateral, intenta copiar y pegar aqu=C3=AD el mism=
+o markdown que acabamos de usar en la p=C3=A1gina Home. =
+=C2=A1Oh! Cierto, no cambies el t=C3=ADtulo, la palabra _Sidebar es lo que permite que Github sepa que estamos hablando de una barra =
+lateral y no de otra secci=C3=B3n m=C3=A1s.
+
+
Guarda tus cambios y disfruta de tu nueva barra de navegaci=C3=B3n.
+
+
Una caracter=C3=ADstica superinteresante es que puedes clonar esta wiki =
+dentro de tu entorno local sin mayor problema, observa que hacer esto signi=
+fica que solo vas a clonar todos estos documentos y no vas a hacer lo mismo=
+ con el repositorio lo que se me hace superinteresante porque puede ser que=
+ el portal de Github sea fant=C3=A1stico, pero no tanto como para pasar ah=
+=C3=AD horas leyendo documentos por lo que de esta manera puedes hacerlo de=
+sde tu lector de documentos Markdown favorito.
+
=C2=A1Invierte tiempo en tus wikis!. Visita las de otros proyectos y tom=
+a muchas ideas de ah=C3=AD, practica mucho con tu documentaci=C3=B3n aprend=
+iendo a usar el lenguaje Markdown y cuando tengas una wiki fant=C3=A1stica =
+no olvides compartirla con todos nosotros.
GitHub Gist permite compartir y discutir fragmentos de código de forma sencilla, sin necesidad de crear un repositorio completo. Esta herramienta es ideal para obtener retroalimentación rápida y colaborativa sin comprometer los cambios en un proyecto principal.
+
¿Qué es GitHub Gist y cómo se utiliza?
+
GitHub Gist es una funcionalidad de GitHub diseñada para almacenar y compartir pequeños fragmentos de código. A diferencia de un repositorio tradicional, un Gist no se vincula a un proyecto completo, sino que permite discutir una pieza de código de manera aislada, ideal para colaboración rápida.
+
+
Crear un Gist: Ingresa a gist.github.com, pega el fragmento de código y añade una descripción breve.
+
Compartir el enlace: Copia la URL generada y compártela con tus colaboradores para abrir la discusión.
+
Feedback en tiempo real: Los colaboradores pueden comentar directamente en el Gist, permitiendo iteraciones y mejoras rápidas.
+
+
¿Cómo se usa GitHub Gist para colaboración?
+
La simplicidad de los Gists facilita el trabajo en equipo al ofrecer un espacio directo de intercambio de ideas y mejoras sin alterar el proyecto base.
+
+
Conversación activa: Puedes recibir y responder comentarios sobre el fragmento de código.
+
Actualización en tiempo real: Si el colaborador sugiere cambios, puedes editar el Gist y mejorar el código sin necesidad de crear nuevas ramas.
+
Ventajas en pair programming: Un Gist puede ser usado como base en sesiones de pair programming, manteniendo el enfoque en mejoras puntuales y rápidas.
+
+
¿Cómo se gestionan los Gists en GitHub?
+
GitHub permite gestionar y organizar fácilmente los Gists en tu perfil, lo que facilita tener una colección de snippets reutilizables.
+
+
Acceso rápido: Los Gists se encuentran en tu perfil y pueden organizarse en una colección para referencias futuras.
+
Eliminar Gists innecesarios: Si un Gist ya no es útil, puede eliminarse sin afectar otros proyectos.
+
Edición y actualización: Los Gists pueden editarse directamente para mantener el código actualizado según las necesidades del proyecto.
+
+
¿Qué beneficios adicionales ofrece GitHub Gist?
+
Además de la colaboración, los Gists son útiles para mantener una biblioteca personal de snippets de código, mejorando la eficiencia en nuevos proyectos.
+
+
Biblioteca personal: Guarda configuraciones iniciales o fragmentos reutilizables para evitar escribir código repetitivo.
+
Probar ideas antes de integrarlas: Permite experimentar con variantes de código antes de incorporarlas oficialmente.
+
Ahorro de tiempo: Facilita el acceso y reutilización de código en proyectos similares, optimizando el flujo de trabajo.
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/06-Uso de GitHub Gist para Compartir y Revisar C\303\263digo Colaborativo.mp4" "b/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/06-Uso de GitHub Gist para Compartir y Revisar C\303\263digo Colaborativo.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..760baa4b88e0cedf9884191e12bb70eef1230b10
--- /dev/null
+++ "b/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/06-Uso de GitHub Gist para Compartir y Revisar C\303\263digo Colaborativo.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:63160c0d8e45691fb04c8d81a7c2ea36aff0cf7527da16379bb06b412d9cb2ac
+size 58821212
diff --git "a/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/06-Uso de GitHub Gist para Compartir y Revisar C\303\263digo Colaborativo.vtt" "b/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/06-Uso de GitHub Gist para Compartir y Revisar C\303\263digo Colaborativo.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..73eea3dd263d2d29eb6d0427746437efa014f22c
--- /dev/null
+++ "b/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/06-Uso de GitHub Gist para Compartir y Revisar C\303\263digo Colaborativo.vtt"
@@ -0,0 +1,196 @@
+WEBVTT
+
+00:00:00.070 --> 00:00:09.610
+Aquí estamos trabajando de manera colaborativa dentro de GitHub con nuestro equipo, subiendo código, creando pull request y haciendo todas estas contribuciones.
+
+00:00:10.110 --> 00:00:20.000
+Es momento de hacer una pausa y detenerme para pensar si necesito crear una rama y después crear un pull request para ver si el código que yo
+
+00:00:20.000 --> 00:00:25.630
+estaba sugiriendo era la mejor idea.
+En lugar de eso puedo crear un GitHub Gist.
+
+00:00:25.630 --> 00:00:36.890
+GitHub Gist es la herramienta de GitHub que me va a permitir crear un pequeño fragmento de código sin estar asociado a ningún repositorio ni nada.
+
+00:00:37.410 --> 00:00:49.000
+Simplemente puedo crear este fragmento de código, mandárselo a mi compañero y poner una conversación que me permita abrir la discusión para saber qué opina
+
+00:00:49.000 --> 00:00:54.990
+y cómo lo podemos mejorar.
+De esta manera podemos platicar acerca de un pequeño fragmento.
+
+00:00:55.450 --> 00:01:03.290
+En este Gist tenemos esta conversación y cuando lleguemos
+a un punto en común, entonces sí, ya puedo trabajar para integrar
+
+00:01:03.290 --> 00:01:11.910
+esa parte dentro de mi proyecto sin ningún problema.
+Entra a la página de gist.github.com.
+
+00:01:12.000 --> 00:01:19.690
+En esta página que por cierto encontrarás dentro de los recursos de esta clase, vas a poder pegar un fragmento de código que quieras compartir.
+
+00:01:19.690 --> 00:01:32.150
+Voy a colocar aquí un archivo html que me va a permitir establecer una discusión con mi compañero para ver qué opina, si es esto lo que quiero o no.
+
+00:01:32.770 --> 00:01:42.210
+Pongo en la descripción del Gist y con ese título de qué
+te parece este fragmento de html y este Gist, creamos este Gist.
+
+00:01:43.810 --> 00:01:47.550
+Con este botón, ahora ya lo tengo todo listo.
+
+00:01:47.950 --> 00:01:53.750
+Es momento de mandarle este enlace
+a mi compañero para que él pueda saber qué opina de todo.
+
+00:01:54.450 --> 00:02:02.150
+Con este Gist creado, compro la URL
+del Gist y ahora se lo puedo mandar a alguien más.
+
+00:02:03.950 --> 00:02:08.970
+Se lo he mandado ya a Miguel para
+que revise este fragmento y me dé su opinión.
+
+00:02:08.970 --> 00:02:12.330
+Esperaré a ver qué pone él en la discusión.
+
+00:02:12.450 --> 00:02:18.410
+Es probable que tengas que refrescar la página para
+ver los últimos comentarios de la conversación estando activa.
+
+00:02:18.710 --> 00:02:22.650
+Aquí Miguel me aparece diciendo
+¿y si no tengo canal de YouTube?
+
+00:02:23.230 --> 00:02:26.770
+Bueno, yo puse la sugerencia
+de poner un botón con el canal de YouTube.
+
+00:02:27.290 --> 00:02:32.630
+Entonces podría sugerir utilizar
+el botón con el canal de TikTok.
+
+00:02:32.630 --> 00:02:41.150
+Voy a ingresar en esta parte
+y aquí puedo poner algo así como, ¿qué te parece usar TikTok?
+
+00:02:42.810 --> 00:02:47.770
+Otra vez en mayúsculas, pero bueno,
+lo dejaré para poder distinguirlo un poco del código en html.
+
+00:02:50.030 --> 00:02:50.630
+Comentario.
+
+00:02:51.690 --> 00:02:54.190
+Veremos qué es lo que Miguel comenta de esto.
+
+00:02:55.390 --> 00:02:59.350
+Es probable que debas refrescar
+la página para ver los comentarios más recientes.
+
+00:02:59.350 --> 00:03:03.030
+Aquí Miguel me puso, ¿y si no tengo canal de YouTube?
+
+00:03:03.730 --> 00:03:07.750
+Dado que yo estaba utilizando
+el canal de YouTube en el botón.
+
+00:03:08.050 --> 00:03:22.890
+Puedo ponerle,
+¿qué te parece, al revés, usar un canal de TikTok?
+
+00:03:23.770 --> 00:03:28.910
+Mando mi comentario y esperaré a ver
+qué es lo que Miguel opina de esta parte.
+
+00:03:29.730 --> 00:03:35.810
+Actualizo de nuevo mi página para
+ver qué parece y Miguel me dice, me parece mejor.
+
+00:03:36.330 --> 00:03:42.590
+Entonces, si esa es la sugerencia,
+puedo subir un poco, seleccionar el botón de edit.
+
+00:03:44.190 --> 00:03:51.470
+Y cambiar este archivo div por un
+archivo div que tenga el canal de TikTok.
+
+00:03:52.170 --> 00:03:55.110
+Actualizo este gist y listo.
+
+00:03:55.570 --> 00:04:03.990
+De esta forma yo estoy viendo la interacción entre Miguel y yo para ver cuál es la mejor opción dentro del proyecto en el que estamos trabajando.
+
+00:04:04.890 --> 00:04:11.500
+Una consideración que debes de tener
+mucho en cuenta es que esto de gist está únicamente.
+
+00:04:15.700 --> 00:04:23.240
+Si tú das click en tu perfil, vas a regresar al perfil,
+pero de los gist que tú ya tienes previamente creados.
+
+00:04:23.240 --> 00:04:26.280
+Por ejemplo, aquí tengo uno que dice Hello World.
+
+00:04:26.760 --> 00:04:31.800
+Aquí tengo el otro gist que tengo
+utilizando con la conversación que tuve con Miguel.
+
+00:04:32.300 --> 00:04:34.960
+Y así puedo tener toda esta colección.
+
+00:04:35.500 --> 00:04:43.720
+Si hay un gist que tú consideras que ya no es necesario que tengas
+aquí porque ya no lo compartiste o simplemente ya lo utilizaste.
+
+00:04:44.300 --> 00:04:47.940
+Puedes seleccionarlo y presionar el botón de delete.
+
+00:04:47.940 --> 00:04:54.520
+Te va a pedir confirmar estos cambios
+y ahora yo solo tengo un gist sin problema.
+
+00:04:55.160 --> 00:05:00.340
+Si quieres regresar a tu perfil
+de GitHub, solo selecciona la opción Back de GitHub.
+
+00:05:03.200 --> 00:05:07.340
+Estamos de vuelta a la página inicial de tu perfil de GitHub.
+
+00:05:07.960 --> 00:05:13.760
+Y de nuevo, si quieres ahora
+verificar tus gist, selecciona tu foto de perfil.
+
+00:05:13.760 --> 00:05:17.760
+Y aquí está la opción de Your Gist.
+
+00:05:18.860 --> 00:05:24.760
+Puedes así regresar a tu colección
+de gist sin ningún problema desde la página principal.
+
+00:05:25.740 --> 00:05:30.820
+Gist es una de esas pequeñas herramientas
+escondidas dentro de GitHub que son una maravilla total.
+
+00:05:31.360 --> 00:05:34.180
+Te apoyan muchísimo en las sesiones de Peer Programming.
+
+00:05:34.580 --> 00:05:42.120
+Te apoyan muchísimo también como individuo si utilizas ciertos fragmentos de código de manera recurrente en tus proyectos.
+
+00:05:42.120 --> 00:05:53.120
+Por ejemplo, aquí en un gist podrías guardar la configuración de un snippet de código o la configuración de un proyecto inicial o muchas otras variables.
+
+00:05:53.720 --> 00:06:04.000
+De esa manera, en lugar de estar escribiendo código constantemente, solo puedes regresar a tu colección de gist, copiar ese código, pegarlo en tus nuevos proyectos
+
+00:06:04.000 --> 00:06:12.000
+y te estás ahorrando muchísimo tiempo. Considera que los usos de los gist no están limitados solo a compartir ese código con alguien más
+
+00:06:12.000 --> 00:06:20.060
+o tenerlo dentro de tu reserva. También puedes utilizarlo como variantes de algún proyecto que tú estás proponiendo y que puedes mandar
+
+00:06:20.060 --> 00:06:29.880
+primero al gist para solicitar retroalimentación. Si esa retroalimentación es positiva, entonces puedes comenzar a contribuir con ese proyecto.
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/07-Creaci\303\263n y Publicaci\303\263n de Sitios Web con GitHub Pages.mp4" "b/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/07-Creaci\303\263n y Publicaci\303\263n de Sitios Web con GitHub Pages.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..28ab51e6ba4c46c658a38e307d546be84a0912c5
--- /dev/null
+++ "b/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/07-Creaci\303\263n y Publicaci\303\263n de Sitios Web con GitHub Pages.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a7361ebe67b842c0bbffa83f6a8eb984975db8dfa503a70267541d53a1e829fe
+size 71743048
diff --git "a/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/07-Creaci\303\263n y Publicaci\303\263n de Sitios Web con GitHub Pages.vtt" "b/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/07-Creaci\303\263n y Publicaci\303\263n de Sitios Web con GitHub Pages.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..19f774f0fce4214c3a481766390d97576fd94d0a
--- /dev/null
+++ "b/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/07-Creaci\303\263n y Publicaci\303\263n de Sitios Web con GitHub Pages.vtt"
@@ -0,0 +1,285 @@
+WEBVTT
+
+1
+00:00:00.040 --> 00:00:05.160
+En tu perfil profesional está la opción de explorar el desarrollo front-end.
+
+2
+00:00:05.580 --> 00:00:10.240
+Estoy seguro que GitHub Pages va a ser tu herramienta favorita dentro de GitHub.
+
+3
+00:00:10.760 --> 00:00:17.960
+GitHub Pages te permite crear sitios web para poder desplegarlos y hacerlos accesibles a todo el mundo.
+
+4
+00:00:18.020 --> 00:00:24.940
+Ahora, una parte muy importante, que tú tengas un GitHub Page no quiere decir un entorno por completo aislado.
+
+5
+00:00:24.940 --> 00:00:32.580
+Es decir, estás trabajando en un repositorio de GitHub y no importa si tu sitio web es estático o dinámico.
+
+6
+00:00:33.020 --> 00:00:39.560
+Aquí tú lo vas a poder alojar en este repositorio y desplegarlo dentro de una page sin mayor problema.
+
+7
+00:00:40.440 --> 00:00:55.500
+Lo primero que aquí te recomendaría es que explores la página pages.github.com porque esta página, que de hecho está dentro de los recursos de esta clase, te permite un pequeño tutorial para saber cómo funciona.
+
+8
+00:00:55.800 --> 00:01:09.940
+Si vas desplazándote un poquito hacia abajo, verás que te dice que debes crear un repositorio con un username .github.io. De esta manera podemos arrancar.
+
+9
+00:01:10.480 --> 00:01:13.120
+Para ello voy a regresar a mi cuenta de GitHub.
+
+10
+00:01:13.120 --> 00:01:16.300
+Aquí estoy, en el home de esta cuenta.
+
+11
+00:01:16.920 --> 00:01:19.100
+Ahora voy a crear un nuevo repositorio.
+
+12
+00:01:20.920 --> 00:01:34.120
+Y este repositorio, como bien dijo, esta página debe de ser el de aminespinosa10.github.io. Todo el nombre debe de ir en este repositorio.
+
+13
+00:01:34.760 --> 00:01:42.600
+Es decir, tanto el nombre del usuario como el .github.io. En la descripción voy a poner mi página de prueba.
+
+14
+00:01:44.600 --> 00:01:46.620
+Este repositorio será público.
+
+15
+00:01:47.280 --> 00:01:52.620
+Hay que mencionar que todas las GitHub pages, por defecto, son públicas.
+
+16
+00:01:53.020 --> 00:01:58.660
+La única manera de hacer una GitHub page privada es utilizando planes empresariales.
+
+17
+00:01:59.280 --> 00:02:04.740
+En nuestro caso, puedo mantener el repositorio público, dado que el sitio también va a ser público.
+
+18
+00:02:04.740 --> 00:02:08.360
+Agrego un readme y creo este repositorio.
+
+19
+00:02:10.000 --> 00:02:21.000
+En el repositorio ya creado, selecciono el botón de code SSH y copio la dirección para clonar este repositorio en tu entorno local.
+
+20
+00:02:21.900 --> 00:02:25.720
+Me paso a mi terminal y escribiré git clone.
+
+21
+00:02:27.500 --> 00:02:31.720
+Pego la dirección y espero que mi repositorio sea clonado.
+
+22
+00:02:31.720 --> 00:02:44.340
+Me muevo a ese repositorio, cd aminespinosa10.github.io, y en esa ubicación, code espacio punto.
+
+23
+00:02:45.780 --> 00:02:52.380
+Dentro de VS Code, lo primero que necesito es agregar ya la carpeta del proyecto que quiero desplegar.
+
+24
+00:02:52.380 --> 00:03:02.260
+Para ello, puedo moverme al repositorio de GitHub que tengo ya previamente forkeado dentro de mi cuenta.
+
+25
+00:03:02.760 --> 00:03:07.680
+Si no has hecho ese fork, puedes ir al repositorio y también clonarlo.
+
+26
+00:03:08.320 --> 00:03:12.600
+La parte que me interesa es esta carpeta de plantilla web.
+
+27
+00:03:13.420 --> 00:03:18.360
+Lo que quiero es que esta carpeta esté dentro de mi nuevo proyecto de pages.
+
+28
+00:03:19.200 --> 00:03:38.500
+Yo estoy pegando este contenido y aquí está, plantilla web, assets, index.html. Con esta carpeta ya colocada dentro de mi proyecto, lo único que quiero es dar click derecho, renombrar y
+
+29
+00:03:38.500 --> 00:03:44.200
+utilizar la palabra específica, docs, para esa carpeta.
+
+30
+00:03:44.200 --> 00:03:50.460
+Es importante mencionar que esta palabra es la única que vamos a poder utilizar, docs.
+
+31
+00:03:50.920 --> 00:03:54.200
+Aquí tú puedes colocar el contenido de tu sitio web.
+
+32
+00:03:55.120 --> 00:04:11.060
+Aclaro, estoy haciendo esto porque el contenido dentro del repositorio de Platzi tiene esta página de index.html, que es una página web estática que nos puede utilizar o nos va a servir de página para nuestra GitHub page.
+
+33
+00:04:11.060 --> 00:04:22.900
+Aquí puedes hacer muchas modificaciones para que sea el lugar de mi plantilla, la plantilla de Amin o la plantilla de Miguel o la plantilla de cualquiera que esté colaborando en el equipo.
+
+34
+00:04:23.620 --> 00:04:31.760
+Puedes colocar el HTML que se te ocurra y de hecho yo, por ejemplo, puse mi curso de Git y GitHub aquí.
+
+35
+00:04:32.960 --> 00:04:43.300
+Ya que exploraste y modificaste la plantilla HTML a tu gusto, regresa a tu terminal o hazlo desde Visual Studio Code, como mejor te acomode.
+
+36
+00:04:43.660 --> 00:04:46.500
+Lo que importa es que tenemos que subir estos cambios.
+
+37
+00:04:47.120 --> 00:04:48.960
+En mi caso voy a limpiar mi terminal.
+
+38
+00:04:49.890 --> 00:04:54.280
+Ven que estos archivos ya están aquí, la carpeta de docs se marca.
+
+39
+00:05:07.260 --> 00:05:11.920
+Escribo enter y esos cambios ya fueron agregados.
+
+40
+00:05:16.400 --> 00:05:23.580
+La llave de mi SSH y esos cambios se actualizan.
+
+41
+00:05:27.220 --> 00:05:33.460
+Regreso a mi repo y una vez que haya refrescado esta página, ya puedo ver aquí mis cambios.
+
+42
+00:05:33.720 --> 00:05:35.360
+Está la carpeta de docs.
+
+43
+00:05:36.020 --> 00:05:40.500
+Ahora necesito irme a los settings de este proyecto.
+
+44
+00:05:42.120 --> 00:05:49.000
+Dentro de la configuración, en la columna izquierda, busca la categoría Pages y seleccionala.
+
+45
+00:05:51.620 --> 00:05:54.520
+El asistente te va a preguntar varias cosas.
+
+46
+00:05:54.780 --> 00:05:59.700
+En primer lugar, a partir de qué lugar vas a desplegar toda la información.
+
+47
+00:06:00.260 --> 00:06:03.660
+Si desde un GitHub Actions o desde un branch.
+
+48
+00:06:04.180 --> 00:06:06.500
+En nuestro caso lo vamos a hacer desde una rama.
+
+49
+00:06:07.220 --> 00:06:09.380
+Esta rama debe de ser específica.
+
+50
+00:06:09.380 --> 00:06:12.560
+Voy a poner Main como la rama por defecto.
+
+51
+00:06:13.180 --> 00:06:16.100
+Y después tengo solo dos opciones.
+
+52
+00:06:16.700 --> 00:06:21.520
+Hacerlo desde la raíz del proyecto o con la carpeta de docs.
+
+53
+00:06:22.000 --> 00:06:25.520
+Por ello era importante que esta carpeta tuviera este nombre.
+
+54
+00:06:26.320 --> 00:06:27.220
+Guardo mis cambios.
+
+55
+00:06:29.140 --> 00:06:37.040
+Cuando el mensaje de GitHub Pages Source Saved se haya mostrado, puedo regresar a mi página principal.
+
+56
+00:06:39.380 --> 00:06:41.000
+Aquí hay un pequeño truco.
+
+57
+00:06:41.380 --> 00:06:47.740
+Ya que estás en la página principal, regresa de nuevo a Settings, a la categoría de Pages.
+
+58
+00:06:48.160 --> 00:06:55.640
+Y podrás ver un nuevo mensaje que dice que tu sitio ahora está en vivo dentro de esta URL.
+
+59
+00:06:56.580 --> 00:07:03.160
+También puedes presionar el botón de visitar sitio para que te aparezca de manera inmediata en una nueva pestaña.
+
+60
+00:07:03.160 --> 00:07:09.000
+Esta es la plantilla HTML que tienes dentro de la carpeta de Docs.
+
+61
+00:07:09.380 --> 00:07:16.040
+Y la URL que estás utilizando ahora es una dirección pública que puedes compartir con cualquier persona.
+
+62
+00:07:17.120 --> 00:07:21.920
+Después de haber visto nuestro sitio ya publicado, puedes regresar a tu perfil.
+
+63
+00:07:22.740 --> 00:07:29.680
+Dentro de la categoría de GitHub Pages, hay una sección un poco abajo que dice Custom Domain.
+
+64
+00:07:29.680 --> 00:07:41.940
+Estos dominios personalizados te permiten saber que si tú ya tienes tu dominio como, no sé, aminespinosa.com, comoplatzi.com, puedes asociarlo a esta página.
+
+65
+00:07:42.180 --> 00:07:48.940
+Haciendo que la dirección URL no sea tan larga y corresponda a un nombre de dominio en específico.
+
+66
+00:07:50.200 --> 00:07:52.820
+Está fantástico trabajar con GitHub Pages, ¿no?
+
+67
+00:07:52.980 --> 00:07:57.940
+Puedes hacer una plantilla y publicarla al mundo para compartirla con quien tú quieras.
+
+68
+00:07:57.940 --> 00:08:10.380
+Te invito a que personalices esta plantilla HTML para que le agregues tus redes sociales, tu imagen y, no sé, muchas cosas que quieras compartir con todo el mundo.
+
+69
+00:08:10.880 --> 00:08:19.820
+Dentro de esta plantilla HTML, los cambios que tú quieras hacer se verán reflejados de manera casi inmediata en tu GitHub Page.
+
+70
+00:08:19.820 --> 00:08:32.820
+Ahora que ya vimos toda esta extensa colección de herramientas colaborativas en GitHub, es momento de detenernos, practicar muchísimo con todas ellas, ver qué otros usos le podemos utilizar.
+
+71
+00:08:33.240 --> 00:08:39.559
+Y bueno, ya que terminaste tu GitHub Page, estaría fantástico que la compartas para ver el resultado de tu trabajo.
diff --git "a/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/07-Lecturas recomendadas.txt" "b/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/07-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..3fcc363ba18434ecc4291bff21589ab71b489099
--- /dev/null
+++ "b/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/07-Lecturas recomendadas.txt"
@@ -0,0 +1,3 @@
+https://pages.github.com/
+https://docs.github.com/es/pages/quickstart
+https://github.com/platzi/git-github
diff --git "a/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/07-Resumen.html" "b/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/07-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..7fd0b46618a9fcbcdc854d254e0158a18d0d5c3d
--- /dev/null
+++ "b/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/07-Resumen.html"
@@ -0,0 +1,148 @@
+
+
+
+
+
+
+ Creación y Publicación de Sitios Web con GitHub Pages
+
+
+
+
+
+
Resumen
¿Cómo crear un sitio web con GitHub Pages?
+
GitHub Pages es una herramienta poderosa para cualquier desarrollador que busca crear y desplegar sitios web de manera sencilla y eficaz. Puedes alojar tanto sitios estáticos como dinámicos y hacerlos accesibles al mundo entero. Este recurso permite que tus proyectos sean parte de la web y maximiza la utilidad de tus repositorios de GitHub. Aquí te explicamos cómo comenzar a usar GitHub Pages para crear tu propio sitio.
+
¿Cómo iniciar un proyecto en GitHub Pages?
+
Para arrancar con GitHub Pages, debes seguir algunos pasos básicos que te facilitarán el proceso de crear y alojar tu sitio web.
+
+
+
Visitar la página de recursos de GitHub Pages: Navega a pages.github.com para acceder a un tutorial que te guiará a través de los conceptos básicos de configuración.
+
+
+
Crear un nuevo repositorio: En tu cuenta de GitHub, crea un nuevo repositorio con el nombre username.github.io, donde "username" será tu nombre de usuario de GitHub.
+
+
+
Configuración del repositorio: Asegúrate de que el repositorio sea público para que la GitHub Page esté accesible a todos. Añade un README para incluir instrucciones o notas sobre la página.
+
+
+
Clonar el repositorio: Copia la URL SSH del repositorio nuevo y clónalo en tu máquina local usando Git. Utiliza el comando git clone [URL] en tu terminal.
+
+
+
Configurar el proyecto en VS Code: Una vez clonado, abre el repositorio en un editor como Visual Studio Code.
+
+
+
¿Cómo agregar contenido a tu GitHub Page?
+
Ya configurado el repositorio, el siguiente paso es agregar y personalizar el contenido que desees mostrar en tu página.
+
+
+
Agregar contenido web: Dentro del repositorio, ubica la carpeta del proyecto que contendrá tu sitio web. Si tienes una plantilla previa, asegúrate de que su estructura esté organizada y funcional.
+
+
+
Renombrar la carpeta principal: Es crucial que esta carpeta se llame "docs", ya que GitHub Pages la reconocerá automáticamente para desplegar el contenido.
+
+
+
Modificar la plantilla HTML: Personaliza la plantilla con contenido como tus redes sociales, imágenes o cualquier información que quieras compartir. Incluso puedes añadir enlaces a tus cursos o proyectos en los que has trabajado.
+
+
+
Subir cambios al repositorio: Desde la terminal o Visual Studio Code, asegúrate de hacer commit y push de los cambios al repositorio para que GitHub Pages los publique.
+
+
+
¿Cómo publicar y personalizar tu GitHub Page?
+
Una vez terminado el diseño y contenido del sitio, es momento de dar vida a tu página en la web y personalizarla al máximo.
+
+
+
Configurar GitHub Pages: Dentro de tu repositorio en GitHub, ve a la sección de "Settings" y busca la categoría "Pages". Aquí selecciona la rama y directorio desde donde se desplegará tu sitio, en este caso, "main" y "docs".
+
+
+
Verificar el despliegue: Una vez configurado, GitHub te proporcionará una URL pública para visitar tu nuevo sitio web.
+
+
+
Agregar un dominio personalizado: Si cuentas con un dominio propio (e.g., aminespinosa.com), puedes asociarlo a la GitHub Page para utilizar una URL más profesional y personalizada.
+
+
+
Actualizar contenido fácilmente: Cualquier modificación que hagas en el HTML de tu proyecto se reflejará casi de inmediato. Esto te da la flexibilidad de ajustar tu sitio en tiempo real según lo que desees mostrar.
+
+
+
GitHub Pages no solo es una herramienta esencial para compartir tus proyectos con el mundo, sino también una oportunidad para perfeccionar tus habilidades de desarrollo front-end. Personaliza, despliega y comparte tus creaciones al instante, y observa cómo tu trabajo online cobra vida. ¡Ahora es tu turno! Crea, edita y dale al mundo una muestra de tu talento.
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/08-Quiz.mhtml" "b/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/08-Quiz.mhtml"
new file mode 100644
index 0000000000000000000000000000000000000000..a4aab24ec01ac1b1f677f9277ff6cbc49536480e
--- /dev/null
+++ "b/Curso de Git y GitHub/03-Herramientas de colaboraci\303\263n en GitHub/08-Quiz.mhtml"
@@ -0,0 +1,13243 @@
+From:
+Snapshot-Content-Location: https://platzi.com/clases/quiz/21260/
+Subject:
+Date: Sat, 8 Nov 2025 15:38:36 -0500
+MIME-Version: 1.0
+Content-Type: multipart/related;
+ type="text/html";
+ boundary="----MultipartBoundary--AfCHfZQjvDkUNnkY71QotYJuQfFqyNEmlZZGUzzkUz----"
+
+
+------MultipartBoundary--AfCHfZQjvDkUNnkY71QotYJuQfFqyNEmlZZGUzzkUz----
+Content-Type: text/html
+Content-ID:
+Content-Transfer-Encoding: quoted-printable
+Content-Location: https://platzi.com/clases/quiz/21260/
+
+
+ =20
+
+ =20
+
+
+
+
+
+
+
+
+
+
+
+ =20
+
+ =20
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ =20
+ =20
+ =20
+
+ =20
+
+ =20
+
+
+ =20
+
+ =20
+
+
+
+ =20
+
+
+ =20
+ =20
+ =20
+
+
+
GitHub Codespaces es una herramienta poderosa que permite crear y gestionar entornos de desarrollo en la nube, aumentando la flexibilidad y productividad para desarrolladores en cualquier lugar. Con una interfaz similar a Visual Studio Code, Codespaces permite desarrollar proyectos desde cualquier dispositivo, sin importar si está instalado el entorno completo en la máquina local.
+
¿Qué es GitHub Codespaces y cómo funciona?
+
GitHub Codespaces ofrece entornos de desarrollo alojados en máquinas virtuales en la nube. Esto permite a los desarrolladores trabajar desde cualquier dispositivo, como una tableta o teléfono, en proyectos alojados en repositorios de GitHub. Con acceso a herramientas de compilación y despliegue, se puede trabajar con múltiples lenguajes de programación sin necesidad de instalarlos localmente.
+
¿Cómo se crea un Codespace?
+
Para iniciar un Codespace:
+
+
Selecciona “New Codespace” en el menú.
+
Escoge el repositorio en el que vas a trabajar.
+
Elige la rama y región que prefieras.
+
Configura el tipo de máquina virtual, seleccionando entre diferentes núcleos y memoria RAM según la necesidad del proyecto.
+
+
Una vez creado, se abre una interfaz de desarrollo completa, que incluye explorador de archivos, terminal integrada y control de versiones.
+
¿Cuáles son las características clave de Codespaces?
+
Algunas funcionalidades destacadas incluyen:
+
+
Explorador de archivos y extensiones: permite administrar archivos y añadir extensiones, igual que en VS Code.
+
Terminal integrada: facilita ejecutar comandos sin salir del entorno.
+
Preconfiguración de entornos: lenguajes como Node, Python y .NET ya están instalados, permitiendo trabajar sin configurarlos en la máquina local.
+
+
¿Cómo se gestiona un proyecto en Codespaces?
+
Puedes crear y gestionar proyectos en múltiples lenguajes. Por ejemplo, para un proyecto en .NET:
+
+
Crea una carpeta para el proyecto en la rama del repositorio.
+
Usa comandos como .NET new console para iniciar el proyecto, sin preocuparte por tener .NET instalado localmente.
+
La terminal permite ejecutar el proyecto con .NET run y hacer ajustes sobre la marcha.
+
+
¿Cómo hacer commit y sincronizar cambios?
+
Al realizar cambios en el proyecto, estos se pueden ver en la sección de control de versiones:
+
+
Añade un mensaje de commit que describa los cambios.
+
Sincroniza los cambios para reflejarlos en el repositorio de GitHub.
+
+
Esta integración asegura que cada modificación quede guardada y reflejada en GitHub, como si se hubiese hecho en un entorno local.
+
¿Por qué es importante eliminar Codespaces al terminar?
+
Cada Codespace utiliza recursos de GitHub y, en cuentas gratuitas, existe un límite de 120 horas de uso al mes. Al completar una tarea:
+
+
Elimina el Codespace para evitar cargos adicionales.
+
Desde “My Codespaces”, selecciona el Codespace y elige “delete” para confirmar la eliminación.
+
+
Este proceso garantiza que solo uses el tiempo necesario y no excedas el límite de la cuenta gratuita.
+
+
+
+
+
\ No newline at end of file
diff --git a/Curso de Git y GitHub/04-GitHub Codespaces/02-Lecturas recomendadas.txt b/Curso de Git y GitHub/04-GitHub Codespaces/02-Lecturas recomendadas.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3d788229bb949edc9b7254997eccc16fa4176fb9
--- /dev/null
+++ b/Curso de Git y GitHub/04-GitHub Codespaces/02-Lecturas recomendadas.txt
@@ -0,0 +1,3 @@
+https://docs.github.com/es/codespaces/getting-started/understanding-the-codespace-lifecycle
+https://github.com/codespaces
+https://github.com/platzi/git-github
diff --git a/Curso de Git y GitHub/04-GitHub Codespaces/02-Resumen.html b/Curso de Git y GitHub/04-GitHub Codespaces/02-Resumen.html
new file mode 100644
index 0000000000000000000000000000000000000000..de183edf8d779a5344127e55c83b345ffd3b8604
--- /dev/null
+++ b/Curso de Git y GitHub/04-GitHub Codespaces/02-Resumen.html
@@ -0,0 +1,126 @@
+
+
+
+
+
+
+ Uso de Codespaces y plantillas en GitHub para proyectos con Django
+
+
+
+
+
+
Resumen
Los Codespaces de GitHub permiten una experiencia de desarrollo altamente personalizable sin necesidad de configurar entornos locales, gracias a su integración de plantillas y configuraciones específicas. Aquí exploramos cómo aprovechar al máximo estas plantillas, como una basada en Django con Python, y cómo ajustar la configuración para mejorar la experiencia en proyectos colaborativos o personales.
+
¿Cómo encontrar y utilizar plantillas de Codespaces?
+
+
Accede a tus Codespaces en github.com/codespaces para ver todos los entornos que has creado.
+
En lugar de crear un Codespace desde cero, selecciona una plantilla. Por ejemplo, puedes usar una con Django, lo cual permite omitir configuraciones iniciales, ya que la plantilla incluye todo lo necesario.
+
Las plantillas permiten crear un entorno en blanco o preconfigurado para un lenguaje o framework específico, sin necesidad de cuestionarios de configuración.
+
+
¿Cómo configurar y editar un Codespace en tiempo real?
+
+
Al crear un proyecto con una plantilla, como Django, puedes modificar el código en tiempo real. Los cambios, como actualizar el texto en un archivo HTML, se reflejan sin necesidad de compilar, como sería el caso en entornos .NET.
+
Para probar la visibilidad de tu proyecto, puedes copiar la URL pública que se genera para compartir avances en tiempo real.
+
+
¿Qué configuraciones están disponibles en el archivo devcontainer.json?
+
Dentro de cada plantilla, encontrarás una carpeta .devcontainer que contiene el archivo devcontainer.json. Este archivo:
+
+
Define el entorno que tu Codespace utilizará, configurando lenguajes y herramientas específicos, como Python en el caso de un proyecto Django.
+
Permite agregar extensiones de Visual Studio Code necesarias para el proyecto. Por ejemplo, al agregar la extensión “Live Share”, puedes activarla en el archivo devcontainer.json para que esté disponible en futuras sesiones.
+
+
¿Cómo optimizar el desarrollo remoto en Visual Studio Code Desktop?
+
+
Usa la opción “Abrir en Visual Studio Code Desktop” para una experiencia completa de edición fuera del navegador.
+
Instala la extensión de GitHub Codespaces en Visual Studio si es la primera vez que usas este entorno.
+
Asegúrate de que tu Codespace solo se ejecute en un entorno a la vez (navegador o desktop), para evitar conflictos de puerto.
+
Puedes controlar el estado del servidor desde la terminal en cualquiera de los entornos, y detener la aplicación con Control-C para reiniciar el servidor cuando sea necesario.
+
+
¿Por qué utilizar plantillas preconfiguradas en Codespaces?
+
+
Las plantillas permiten explorar nuevas tecnologías sin necesidad de configurarlas en tu equipo local. Esto es útil para probar frameworks o lenguajes sin modificar entornos personales.
+
Ejemplos de plantillas populares incluyen Jupyter para análisis de datos, Node para desarrollo de aplicaciones web, y Django para aplicaciones con Python.
+
+
Usando estas plantillas, puedes acelerar la curva de aprendizaje y concentrarte en el desarrollo sin preocuparte por la configuración inicial.
+
+
+
+
+
\ No newline at end of file
diff --git a/Curso de Git y GitHub/04-GitHub Codespaces/02-Uso de Codespaces y plantillas en GitHub para proyectos con Django.mp4 b/Curso de Git y GitHub/04-GitHub Codespaces/02-Uso de Codespaces y plantillas en GitHub para proyectos con Django.mp4
new file mode 100644
index 0000000000000000000000000000000000000000..05809bbe22c1b3c7e993d9e73d9312adba7bff8b
--- /dev/null
+++ b/Curso de Git y GitHub/04-GitHub Codespaces/02-Uso de Codespaces y plantillas en GitHub para proyectos con Django.mp4
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:96294d5365ae52ea6aba13bf41e40f7331ff06d1dc32ba7421bdcbbb3b0c6733
+size 89958496
diff --git a/Curso de Git y GitHub/04-GitHub Codespaces/03-Lecturas recomendadas.txt b/Curso de Git y GitHub/04-GitHub Codespaces/03-Lecturas recomendadas.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5ea1a5b0bed19cb9268a5760e4235625fbe41d2f
--- /dev/null
+++ b/Curso de Git y GitHub/04-GitHub Codespaces/03-Lecturas recomendadas.txt
@@ -0,0 +1,2 @@
+https://github.com/platzi/git-github
+https://code.visualstudio.com/blogs/2017/11/15/live-share
diff --git "a/Curso de Git y GitHub/04-GitHub Codespaces/03-Programaci\303\263n Colaborativa con Live Share en VS Code.mp4" "b/Curso de Git y GitHub/04-GitHub Codespaces/03-Programaci\303\263n Colaborativa con Live Share en VS Code.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..2616011122afe4ad39f91a70ec5344cffe57849e
--- /dev/null
+++ "b/Curso de Git y GitHub/04-GitHub Codespaces/03-Programaci\303\263n Colaborativa con Live Share en VS Code.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5525d05edf80b3d1240f05133b37347611e6fbb053cc821758d0f21c26a0fdb2
+size 80761857
diff --git "a/Curso de Git y GitHub/04-GitHub Codespaces/03-Programaci\303\263n Colaborativa con Live Share en VS Code.vtt" "b/Curso de Git y GitHub/04-GitHub Codespaces/03-Programaci\303\263n Colaborativa con Live Share en VS Code.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..fc5325cffd46d88b7b532ede7e342f9b18e992a5
--- /dev/null
+++ "b/Curso de Git y GitHub/04-GitHub Codespaces/03-Programaci\303\263n Colaborativa con Live Share en VS Code.vtt"
@@ -0,0 +1,725 @@
+WEBVTT
+
+00:00.000 --> 00:02.600
+Ahora que ya tenemos nuestro Code Space en
+línea,
+
+00:02.600 --> 00:06.100
+con un proyecto de Django y todo
+personalizado para trabajar
+
+00:06.100 --> 00:07.400
+desde VS
+Code,
+
+00:07.400 --> 00:10.100
+puedo aprovecharme de la extensión que
+instalé
+
+00:10.100 --> 00:13.000
+en la clase anterior para compartir este
+código,
+
+00:13.000 --> 00:15.000
+o de hecho, todo este
+proyecto,
+
+00:15.000 --> 00:18.300
+con un colaborador y poder hacer una
+sesión como
+
+00:18.300 --> 00:21.600
+de pair programming o programación en pareja,
+
+00:21.600 --> 00:24.600
+en donde yo puedo permitirle a otra
+persona
+
+00:24.600 --> 00:27.000
+que entre a mi entorno de
+trabajo,
+
+00:27.000 --> 00:28.500
+edite algunas
+líneas,
+
+00:28.500 --> 00:31.800
+y entre los dos podamos decidir qué es lo
+que se va a quedar
+
+00:31.800 --> 00:34.800
+como producto final antes de hacer un commit.
+
+00:34.800 --> 00:39.400
+En mi VS Code me quedé exactamente en
+donde estaba trabajando.
+
+00:39.400 --> 00:41.800
+Voy primero a detener esta
+sesión,
+
+00:41.800 --> 00:43.400
+es decir, mi
+aplicación.
+
+00:43.400 --> 00:44.900
+Como ya la
+detuve,
+
+00:44.900 --> 00:48.200
+ahora puedo cerrar este explorador de
+ejemplo
+
+00:48.200 --> 00:50.800
+para tener una mejor vista de mi código.
+
+00:50.800 --> 00:54.000
+Aquí, en la parte de
+extensiones,
+
+00:54.000 --> 00:56.000
+puedes ver algunas
+extensiones.
+
+00:56.000 --> 00:57.500
+Aquí está la categoría de
+local,
+
+00:57.500 --> 01:01.500
+que es las extensiones que yo tengo dentro
+de VS Code.
+
+01:01.500 --> 01:04.900
+Y aquí está la extensión de Code Spaces,
+
+01:04.900 --> 01:07.300
+es decir, las que están
+instaladas.
+
+01:07.300 --> 01:09.600
+Después está la categoría de
+recomendados
+
+01:09.600 --> 01:11.100
+que siempre te va a
+aparecer.
+
+01:11.100 --> 01:13.200
+Pero esta es la que me
+interesa.
+
+01:13.200 --> 01:15.000
+Si yo pongo Live
+Share,
+
+01:15.000 --> 01:18.100
+me voy a dar cuenta que dentro de mi Code
+Space
+
+01:18.100 --> 01:20.300
+ya está ahí
+instalada.
+
+01:20.300 --> 01:21.700
+Aquí
+está.
+
+01:21.700 --> 01:24.300
+Me aparece este mensajito de deshabilitar.
+
+01:24.300 --> 01:26.600
+Y hay una forma mucho más
+rápida
+
+01:26.600 --> 01:29.900
+de deshabilitar tu código sin tener que ir
+a la extensión.
+
+01:29.900 --> 01:31.700
+Voy a cerrar esta
+ventana,
+
+01:31.700 --> 01:33.600
+regresar a mi explorador de archivos,
+
+01:33.600 --> 01:36.800
+y solo necesitas desplazarte hasta
+abajo
+
+01:36.800 --> 01:39.700
+a la sección de Live
+Share.
+
+01:39.700 --> 01:41.400
+Presiona esta
+sección
+
+01:41.400 --> 01:44.200
+y se va a abrir un pequeño puente de
+comunicación
+
+01:44.200 --> 01:46.600
+para que otra persona pueda acceder.
+
+01:46.600 --> 01:48.200
+De hecho, aquí
+está.
+
+01:48.200 --> 01:50.400
+En el pop-up me dice que la
+invitación
+
+01:50.400 --> 01:52.400
+ha sido copiada a mi
+clipboard.
+
+01:52.400 --> 01:55.100
+Le voy a mandar este enlace a Miguel.
+
+01:55.100 --> 01:58.200
+Y solo espero a que Miguel se conecte.
+
+01:58.200 --> 02:00.400
+Mientras espero a que Miguel se conecte,
+
+02:00.400 --> 02:02.200
+voy a utilizar una nueva
+pestaña
+
+02:02.200 --> 02:07.000
+para mostrarte qué es lo que tu invitado a
+la sesión va a ver.
+
+02:07.000 --> 02:11.200
+Selecciono la URL que Visual Studio Code
+me dio.
+
+02:11.200 --> 02:13.900
+Espero a que
+cargue.
+
+02:13.900 --> 02:15.900
+Y me aparece una leyenda
+diciendo
+
+02:15.900 --> 02:18.100
+que si lo quiero abrir en Visual Studio Code.
+
+02:18.100 --> 02:20.100
+No, no lo voy a abrir con Visual Studio
+Code
+
+02:20.100 --> 02:21.800
+porque yo ya lo estoy
+utilizando.
+
+02:21.800 --> 02:24.200
+Voy a seleccionar la opción de Continuar
+en web.
+
+02:24.200 --> 02:28.400
+Lo ideal sería que sí, tu invitado a la
+sesión
+
+02:28.400 --> 02:31.200
+lo haga desde VS
+Code
+
+02:31.200 --> 02:34.100
+para optimizar un poco más los recursos.
+
+02:34.100 --> 02:36.900
+Una leyenda aquí de Visual Studio Code
+web
+
+02:36.900 --> 02:39.700
+me dice que si quiero mantenerme como
+anónimo
+
+02:39.700 --> 02:41.700
+porque no me he
+registrado.
+
+02:41.700 --> 02:45.200
+Aquí puedo ponerle invitado
+2.
+
+02:47.100 --> 02:48.700
+Presiono
+Enter.
+
+02:50.100 --> 02:53.000
+Y espero a que Visual Studio
+Code
+
+02:53.000 --> 02:55.000
+en mi explorador haga lo
+suyo
+
+02:55.000 --> 02:57.200
+para poder acceder al
+proyecto.
+
+02:57.200 --> 03:01.100
+Esto es en esencia lo que Miguel va a
+estar viendo
+
+03:01.100 --> 03:04.200
+ahora que le acabo de enviar este enlace.
+
+03:04.200 --> 03:06.300
+Listo, en mi sesión como
+invitado
+
+03:06.300 --> 03:09.400
+aquí me aparece Following a mí en
+Spinoza10
+
+03:09.400 --> 03:12.800
+y está el cursor de donde yo me encuentro.
+
+03:12.800 --> 03:14.000
+Voy a cerrar esta
+pestaña
+
+03:14.000 --> 03:17.000
+porque ya quedé listo para mostrar cómo
+funciona.
+
+03:17.000 --> 03:18.900
+Y regresar a Visual Studio
+Code
+
+03:18.900 --> 03:21.900
+en donde VS Code me
+notifica
+
+03:21.900 --> 03:25.200
+que el usuario invitado 2 dejó la sesión.
+
+03:25.200 --> 03:27.400
+Sin embargo, también tengo una
+notificación
+
+03:27.400 --> 03:30.700
+de que Miguel ha iniciado esta sesión.
+
+03:30.700 --> 03:33.300
+Ahora a jugar a las
+escondidillas.
+
+03:33.300 --> 03:34.500
+Saber en dónde
+está.
+
+03:34.500 --> 03:36.300
+Ahí está Miguel
+Torres.
+
+03:36.300 --> 03:37.400
+Ya está por
+ahí.
+
+03:37.400 --> 03:38.800
+Y vamos a
+desplazarnos.
+
+03:38.800 --> 03:40.600
+Ahí está, ahí
+sigue.
+
+03:40.600 --> 03:42.900
+Puedo seguir su
+actividad.
+
+03:42.900 --> 03:45.200
+Puedo ver lo que él está
+haciendo
+
+03:45.200 --> 03:46.900
+y puedo ver las
+modificaciones
+
+03:46.900 --> 03:50.200
+que él sugiera para este
+proyecto.
+
+03:50.200 --> 03:53.600
+Todas estas ediciones, cuando yo las haga,
+
+03:53.600 --> 03:57.300
+las ve él en tiempo real o semi-real.
+
+03:57.300 --> 04:00.900
+Y también todo lo que yo veo que él esté
+actualizando
+
+04:00.900 --> 04:03.600
+lo puedo ver sin ningún
+problema.
+
+04:03.600 --> 04:05.300
+Ahora yo me mantengo
+pasivo
+
+04:05.300 --> 04:07.600
+para ver cuáles son las
+actualizaciones
+
+04:07.600 --> 04:09.600
+que Miguel quiera
+poner.
+
+04:09.600 --> 04:11.000
+Veo que se está tomando su
+tiempo
+
+04:11.000 --> 04:12.500
+para poder actualizar el
+código
+
+04:12.500 --> 04:14.900
+y ahí está
+Miguel,
+
+04:15.700 --> 04:18.700
+Corazoncito, GitHub,
+Codespaces.
+
+04:18.700 --> 04:21.500
+Ah, sí, la H siempre va en mayúscula.
+
+04:21.500 --> 04:25.100
+Qué bueno que él me corrige esa actualización.
+
+04:25.100 --> 04:26.300
+Y ya
+está.
+
+04:26.300 --> 04:28.000
+Esas son las
+sugerencias
+
+04:28.000 --> 04:29.400
+que cualquier otra
+persona
+
+04:29.400 --> 04:31.200
+pueda hacer dentro de tu
+código.
+
+04:31.200 --> 04:34.400
+Y ojo, que las esté haciendo dentro de tu
+código
+
+04:34.400 --> 04:36.600
+significa que tú te vas a
+quedar
+
+04:36.600 --> 04:38.200
+con el crédito de esos
+cambios
+
+04:38.200 --> 04:40.200
+porque lo estamos haciendo en mi entorno.
+
+04:40.200 --> 04:43.100
+Significa que las actualizaciones de
+Miguel
+
+04:43.100 --> 04:46.600
+truculentamente se podrán ir
+guardando
+
+04:46.600 --> 04:47.900
+dentro de un
+commit.
+
+04:47.900 --> 04:50.000
+Sin embargo, Visual Studio
+Code
+
+04:50.000 --> 04:52.700
+le manda un poco de crédito también a los
+demás
+
+04:52.700 --> 04:56.200
+y pone un mensaje de que esto fue
+hecho
+
+04:56.200 --> 04:58.800
+en colaboración con
+Miguel.
+
+04:58.800 --> 05:02.200
+Recuerda que lo más importante dentro de
+todo esto
+
+05:02.200 --> 05:04.800
+es que estamos en un entorno virtual.
+
+05:04.800 --> 05:08.200
+Significa que si yo cierro este
+Codespace
+
+05:08.200 --> 05:10.500
+también se va a cerrar la sesión de Miguel.
+
+05:10.500 --> 05:12.000
+Y por el otro
+lado,
+
+05:12.000 --> 05:14.500
+si yo vuelvo a abrir el
+Codespace
+
+05:14.500 --> 05:17.100
+y no tengo la extensión de Live
+Share
+
+05:17.100 --> 05:19.900
+dentro de
+devcontainer.json,
+
+05:19.900 --> 05:21.500
+como está
+aquí,
+
+05:21.500 --> 05:23.800
+que fue lo que hice desde la clase pasada,
+
+05:23.800 --> 05:26.700
+puede ser que al volver a mi
+Codespace
+
+05:26.700 --> 05:30.400
+necesite volver a instalar esa extensión.
+
+05:30.400 --> 05:33.000
+Ahí está a nada de borrar
+Miguel
+
+05:33.000 --> 05:34.800
+y de hecho está
+remarcándolo
+
+05:34.800 --> 05:37.100
+para que todos lo veamos,
+gracias.
+
+05:37.100 --> 05:40.100
+Y de esta forma podemos configurar nuestro
+Codespace
+
+05:40.100 --> 05:41.500
+con ciertas
+extensiones,
+
+05:41.500 --> 05:42.900
+no solo
+colaborativas,
+
+05:42.900 --> 05:44.800
+sino con otras
+tecnologías,
+
+05:44.800 --> 05:47.400
+con las extensiones que ya hemos visto
+como Markdown,
+
+05:47.400 --> 05:49.200
+como Python, como C
+Sharp,
+
+05:49.200 --> 05:51.700
+o la que necesitemos dentro de VS
+Code
+
+05:51.700 --> 05:53.900
+y mandarla a ese entorno
+virtual.
+
+05:53.900 --> 05:56.000
+Ahora que nuestro trabajo ya está concluido,
+
+05:56.000 --> 06:00.000
+lo primero que necesitas es bajar a la
+sección de Share
+
+06:00.000 --> 06:03.400
+y escoger la opción de Stop Collaboration
+Session,
+
+06:03.400 --> 06:05.600
+que quiere decir que las
+personas
+
+06:05.600 --> 06:08.500
+que estaban en Live Share colaborando
+contigo
+
+06:08.500 --> 06:10.700
+quedarán fuera de esta
+sesión.
+
+06:10.700 --> 06:13.900
+En este momento mi trabajo vuelve a ser
+individual
+
+06:13.900 --> 06:15.700
+dentro del
+Codespace.
+
+06:15.700 --> 06:18.100
+Ahora me voy a regresar
+también
+
+06:18.100 --> 06:21.200
+a github.com diagonal
+Codespaces
+
+06:21.200 --> 06:23.100
+para ver mi
+plantilla.
+
+06:23.100 --> 06:26.600
+De nuevo, recordando que es un entorno de
+colaboración
+
+06:26.600 --> 06:27.800
+en la
+nube,
+
+06:27.800 --> 06:31.300
+lo ideal es de nuevo regresar a los tres
+puntos
+
+06:31.300 --> 06:33.300
+y eliminar esta
+plantilla
+
+06:33.300 --> 06:36.300
+una vez que haya concluido todo mi trabajo.
+
+06:36.300 --> 06:38.500
+Divertidísimo trabajar de manera
+colaborativa
+
+06:38.500 --> 06:40.000
+con Codespaces,
+¿no?
+
+06:40.000 --> 06:42.600
+La verdad es que ofrece muchos
+beneficios
+
+06:42.600 --> 06:45.700
+que nosotros podríamos identificar ahora
+mismo.
+
+06:45.700 --> 06:48.400
+El primer beneficio es que le estás
+permitiendo
+
+06:48.400 --> 06:51.800
+a una persona entrar a un entorno virtual,
+
+06:51.800 --> 06:53.400
+modificar los
+cambios,
+
+06:53.400 --> 06:56.600
+colaborar de la forma que a los dos les
+convenga.
+
+06:56.600 --> 06:59.100
+Bueno, de hecho, a los dos o a muchos más.
+
+06:59.100 --> 07:01.800
+Puedes hacer un trabajo en equipo con un
+Live Share
+
+07:01.800 --> 07:04.500
+y una vez que ese trabajo se haya concluido,
+
+07:04.500 --> 07:07.500
+pueden entre todos unificar todo su
+trabajo
+
+07:07.500 --> 07:09.000
+por medio de un
+commit.
+
+07:09.000 --> 07:11.200
+La gran ventaja de todo esto es
+que
+
+07:11.200 --> 07:13.700
+nadie está entrando a tu
+equipo,
+
+07:13.700 --> 07:17.600
+nadie está entrando a tu entorno de
+desarrollo individual.
+
+07:17.600 --> 07:20.600
+Todo está siendo ejecutado en la nube.
+
+07:20.600 --> 07:23.900
+Ciertamente es más cómodo hacerlo desde
+Visual Studio Code,
+
+07:23.900 --> 07:26.800
+pero aún haciéndolo usando VS
+Code
+
+07:26.800 --> 07:29.900
+no quiere decir que nadie esté
+accediendo
+
+07:29.900 --> 07:31.200
+a tu entorno
+personal,
+
+07:31.200 --> 07:34.000
+lo que naturalmente te da una
+facilidad
+
+07:34.000 --> 07:38.300
+de aislar tu trabajo de todo el resto del
+equipo.
+
+07:38.300 --> 07:39.800
+Diviértete
+muchísimo,
+
+07:39.800 --> 07:42.600
+con Code Space Explora, invita amigos,
+
+07:42.600 --> 07:44.600
+aprendan a hacer un pair
+programming
+
+07:44.600 --> 07:46.900
+que es una de las cosas que más
+trabajo
+
+07:46.900 --> 07:49.100
+creo que nos cuesta a los
+desarrolladores
+
+07:49.100 --> 07:53.800
+y después, ya que hayan tenido su sesión
+de código compartido,
+
+07:53.800 --> 07:56.100
+recuerda, muy
+importante,
+
+07:56.100 --> 07:58.400
+siempre eliminar tu Code
+Space
+
+07:58.400 --> 08:10.400
+ya que hayas concluido todas tus actividades.
+
diff --git a/Curso de Git y GitHub/04-GitHub Codespaces/03-Resumen.html b/Curso de Git y GitHub/04-GitHub Codespaces/03-Resumen.html
new file mode 100644
index 0000000000000000000000000000000000000000..3930dbb458ad363345e7c5a502ee8880d1681e0a
--- /dev/null
+++ b/Curso de Git y GitHub/04-GitHub Codespaces/03-Resumen.html
@@ -0,0 +1,116 @@
+
+
+
+
+
+
+ Programación Colaborativa con Live Share en VS Code
+
+
+
+
+
+
Resumen
Trabajar en equipo y en tiempo real desde la nube se ha vuelto esencial, y GitHub Codespaces junto con la extensión de Live Share de Visual Studio Code permite precisamente eso: una colaboración dinámica y segura. Aquí te explicamos cómo puedes usar estas herramientas para hacer pair programming y trabajar en equipo sin comprometer tu espacio de desarrollo.
+
¿Cómo iniciar una sesión de colaboración en Codespaces?
+
Para compartir tu Codespace con otra persona, asegúrate de que la extensión de Live Share esté instalada en tu entorno de Visual Studio Code. Luego:
+
+
Detén la ejecución de cualquier aplicación en el Codespace.
+
Accede a la sección de Live Share en VS Code y selecciona “Iniciar sesión compartida”.
+
Copia el enlace de invitación y compártelo con tu colaborador. Al ingresar, podrá editar y sugerir cambios en tiempo real.
+
+
Tu invitado puede unirse desde VS Code o, de preferencia, a través del navegador usando la opción “Continuar en web” si busca un acceso más rápido y liviano.
+
¿Qué visualiza el colaborador en la sesión?
+
El colaborador que accede mediante el enlace ve tu código en tiempo real y puede realizar modificaciones que se reflejan en tu Codespace. Puedes observar sus movimientos, las ediciones sugeridas y trabajar en conjunto sin perder control sobre el entorno, ya que todos los cambios quedan bajo tu responsabilidad en el commit.
+
¿Qué ventajas tiene trabajar en la nube con Codespaces y Live Share?
+
+
Colaboración segura: Permites acceso solo al entorno de Codespaces en la nube, manteniendo tu espacio local aislado.
+
Facilidad para múltiples colaboradores: Puedes compartir el enlace con más de un participante, y al terminar la sesión todos los cambios pueden unificarse en un solo commit.
+
Entorno unificado: Todos los participantes trabajan con el mismo set de extensiones y configuración, lo que facilita la integración y el seguimiento del proyecto.
+
+
¿Cómo finalizar la sesión de colaboración?
+
Para detener la colaboración, ve a la sección de Live Share en tu Codespace y selecciona “Detener sesión de colaboración”. Esto retirará el acceso de los invitados y volverás a un modo de trabajo individual. Además, para cerrar por completo, regresa a GitHub Codespaces, revisa tu plantilla y elige la opción de eliminarla para liberar recursos.
+
¿Qué configuraciones adicionales puedes incluir en Codespaces?
+
Puedes personalizar tu Codespace añadiendo extensiones de lenguaje y herramientas de trabajo (como Markdown o Python) que optimicen tu flujo de trabajo. Estas configuraciones aseguran que, al reabrir tu Codespace, esté listo con las herramientas necesarias, siempre que las hayas especificado en el archivo devcontainer.json.
+
+
+
+
+
\ No newline at end of file
diff --git a/Curso de Git y GitHub/04-GitHub Codespaces/04-Lecturas recomendadas.txt b/Curso de Git y GitHub/04-GitHub Codespaces/04-Lecturas recomendadas.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a8d78340ddb3657a2f7e9c361fac113829f1b468
--- /dev/null
+++ b/Curso de Git y GitHub/04-GitHub Codespaces/04-Lecturas recomendadas.txt
@@ -0,0 +1,2 @@
+https://docs.github.com/es/codespaces/the-githubdev-web-based-editor
+https://github.com/platzi/git-github
diff --git a/Curso de Git y GitHub/04-GitHub Codespaces/04-Resumen.html b/Curso de Git y GitHub/04-GitHub Codespaces/04-Resumen.html
new file mode 100644
index 0000000000000000000000000000000000000000..96aa641281fc08d4891d479e20114208fd64e02c
--- /dev/null
+++ b/Curso de Git y GitHub/04-GitHub Codespaces/04-Resumen.html
@@ -0,0 +1,125 @@
+
+
+
+
+
+
+ Uso del Editor Web de GitHub para Edición Rápida de Archivos
+
+
+
+
+
+
Resumen
GitHub ha incorporado una herramienta que, aunque pasa desapercibida, puede hacer que editar archivos sea rápido y sencillo sin necesidad de un entorno completo como Codespaces. Este pequeño editor de código integrado en el navegador se activa al presionar Enter en la página de un repositorio, llevando al usuario a una experiencia muy similar a Visual Studio Code para ediciones rápidas y precisas.
+
¿Cómo funciona el GitHub Dev Editor?
+
El GitHub Dev Editor se activa al presionar Enter dentro de cualquier repositorio en GitHub. Esta acción abre un editor web donde puedes:
+
+
Visualizar y editar archivos de texto de inmediato.
+
Realizar cambios rápidos en archivos como README o en cualquier otro documento de texto dentro del repositorio.
+
Guardar automáticamente los cambios al cerrar la pestaña o realizar un “commit” y “push” de forma directa.
+
+
Este editor no cuenta con terminal ni opciones avanzadas de desarrollo; está diseñado únicamente para realizar ediciones en texto.
+
¿Qué ventajas ofrece frente a otros entornos de desarrollo?
+
GitHub Dev Editor es ideal para tareas de edición de texto simples. Aquí algunos beneficios:
+
+
Sin costo adicional: A diferencia de Codespaces, el uso del Dev Editor no genera cargos.
+
Accesibilidad: Disponible en cualquier navegador, sin requerir configuraciones complejas.
+
Rapidez: Acceso rápido para editar y confirmar cambios de inmediato, útil para pequeñas modificaciones o correcciones ortográficas.
+
+
¿Cuándo deberías utilizar Codespaces en lugar de GitHub Dev Editor?
+
El uso de Codespaces es recomendable cuando el proyecto requiere un entorno completo de desarrollo. Algunas de las principales razones para elegir Codespaces son:
+
+
Compilación y ejecución: Codespaces permite compilar y probar código, algo que no es posible en el Dev Editor.
+
Terminal y depuración: Incluye terminal y herramientas avanzadas para ejecutar comandos, ideal para proyectos complejos.
+
Colaboración avanzada: Permite trabajar con equipos en un entorno en la nube, manteniendo sincronización en tiempo real.
+
+
Sin embargo, hay un costo asociado a su uso cuando se superan las horas gratuitas mensuales, por lo que es importante considerar esta opción solo cuando el proyecto lo requiera.
+
¿Qué debes considerar al escoger entre GitHub Dev Editor y Codespaces?
+
+
Frecuencia y tipo de cambios: Si solo necesitas editar unas pocas líneas, GitHub Dev Editor es suficiente.
+
Costo: Codespaces tiene un costo en la nube, mientras que el Dev Editor es gratuito.
+
Necesidades de desarrollo: Para compilaciones y pruebas de código, Codespaces es indispensable; para correcciones menores, el Dev Editor es más práctico.
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/04-GitHub Codespaces/04-Uso del Editor Web de GitHub para Edici\303\263n R\303\241pida de Archivos.mp4" "b/Curso de Git y GitHub/04-GitHub Codespaces/04-Uso del Editor Web de GitHub para Edici\303\263n R\303\241pida de Archivos.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..39dc679a7e32aeea6154c18e6479596cb05bb12b
--- /dev/null
+++ "b/Curso de Git y GitHub/04-GitHub Codespaces/04-Uso del Editor Web de GitHub para Edici\303\263n R\303\241pida de Archivos.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6a4aca1846dfb5063a863af78cae4ed527acdababffaa959a99e6c39d4019bf1
+size 49868871
diff --git "a/Curso de Git y GitHub/04-GitHub Codespaces/04-Uso del Editor Web de GitHub para Edici\303\263n R\303\241pida de Archivos.vtt" "b/Curso de Git y GitHub/04-GitHub Codespaces/04-Uso del Editor Web de GitHub para Edici\303\263n R\303\241pida de Archivos.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..74e307deaa571ff120112829846a4f7b70ba9018
--- /dev/null
+++ "b/Curso de Git y GitHub/04-GitHub Codespaces/04-Uso del Editor Web de GitHub para Edici\303\263n R\303\241pida de Archivos.vtt"
@@ -0,0 +1,214 @@
+WEBVTT
+
+00:00.000 --> 00:06.120
+Llevo trabajando con repositorios de
+GitHub desde hace unos 10 años y apenas hace unos seis meses
+
+00:06.120 --> 00:12.680
+y por error encontré una característica
+muy interesante de GitHub. No puedo decir cuánto
+
+00:12.680 --> 00:17.880
+tiempo lleva esa característica ahí porque
+simplemente no sabía cuándo fue implementada.
+
+00:17.880 --> 00:24.720
+Sin embargo, te voy a mostrar. Si tú estás
+dentro de un repositorio, tienes un pequeño editor de
+
+00:24.720 --> 00:31.960
+código dentro de GitHub en tu explorador
+que te puede ayudar a editar de forma mucho más cómoda
+
+00:31.960 --> 00:39.360
+tus archivos. Vamos a verlo en pantalla.
+Me encuentro dentro de mi primer repo y hasta
+
+00:39.360 --> 00:44.640
+ahora, de hecho, lo mismo que he hecho en
+todo el curso es desplazarme hacia abajo,
+
+00:44.640 --> 00:52.720
+seleccionar este ícono de editar y poder
+editar mi archivo sin problema. Sin embargo,
+
+00:52.720 --> 00:59.320
+si yo me regreso a mi repositorio, a la
+portada o a cualquier ubicación dentro del repo y presiono
+
+00:59.320 --> 01:09.440
+Enter, GitHub me manda en automático a un
+editor web muy parecido a Visual Studio Code. Es decir,
+
+01:09.440 --> 01:16.240
+aquí carga mis archivos, esperando solo
+unos segundos y listo. Aquí está el preview del
+
+01:16.240 --> 01:23.280
+Readme. Ya está y listo. Lo puedo cerrar,
+abrir Readme y aquí con las líneas de código,
+
+01:23.280 --> 01:31.040
+que es un buen distintivo para saber que
+ya puedo editar, comienzo a editar. Cambios desde
+
+01:31.040 --> 01:37.320
+Dev Editor y puedo hacer los cambios que
+yo quiera, no solo en un Readme, sino en cualquier
+
+01:37.320 --> 01:42.880
+archivo dentro de mi proyecto. Solo
+necesito cerrar la pestaña para guardar estos cambios.
+
+01:42.880 --> 01:49.360
+Como siempre, al igual que en VS Code y en
+los Codespaces que ya visitamos, el ícono del control
+
+01:49.360 --> 01:56.600
+de versiones me dice que ya hay algunos
+cambios realizados en el Readme. Puedo poner aquí cambios
+
+01:56.600 --> 02:09.400
+desde web y poner commit and push. Listo,
+mis cambios fueron realizados. Este editor es muy
+
+02:09.400 --> 02:17.080
+eficaz para desplazarte rápido, hacer un
+cambio muy sencillo y regresar a tu repositorio de GitHub.
+
+02:17.080 --> 02:24.960
+Algo que debes de considerar es que,
+engañosamente, en un sitio web que parece que es Visual Studio,
+
+02:24.960 --> 02:30.680
+podríamos pensar que se trata de un
+entorno de desarrollo muy parecido al que estuvimos
+
+02:30.680 --> 02:37.040
+utilizando dentro de Codespaces, pero la
+realidad es muy diferente. Me muevo a la
+
+02:37.040 --> 02:40.800
+izquierda y en la parte superior, en el
+ícono de las tres líneas horizontales,
+
+02:40.800 --> 02:48.120
+selecciono la opción aquí, Go to repository.
+Me abre una nueva pestaña con mi repositorio
+
+02:48.120 --> 02:55.200
+y aquí está Readme.markdown, cambios desde
+web, hace tres minutos. Si me desplazo,
+
+02:55.200 --> 02:59.600
+puedo confirmar que aquí están mis cambios
+realizados de manera natural.
+
+02:59.600 --> 03:05.840
+Voy a regresar a mi pestaña y con este
+entorno de desarrollo o de edición,
+
+03:05.840 --> 03:12.240
+más bien de texto, puede surgir la duda de
+saber cuál es la diferencia entre trabajar
+
+03:12.240 --> 03:18.600
+con este editor y un Codespace. Hay un
+factor importantísimo y es el que marca la gran
+
+03:18.600 --> 03:25.600
+diferencia. Esto es únicamente un editor
+de texto. Si tú te vas a estos tres puntitos,
+
+03:25.600 --> 03:32.120
+dentro de un Codespace, tú podrías crear
+una nueva terminal o podrías ir aquí y buscarla
+
+03:32.120 --> 03:37.400
+o podrías hacer algunas cosas por el estilo.
+Es decir, aquí en terminal, si tú le pones,
+
+03:37.400 --> 03:45.720
+te dice que de hecho lo ideal, si quieres
+una terminal, es justamente irte a un Codespace.
+
+03:45.720 --> 03:52.520
+Voy a cerrar esta pestaña que ya me
+confirmó que sí se trata solo de un editor de texto y
+
+03:52.520 --> 03:59.280
+recordar que para los casos en donde
+dentro de mi repositorio a lo mejor cometí algún error,
+
+03:59.280 --> 04:06.400
+como dejar un comentario adicional dentro
+de mi código, dejar código comentado o simplemente
+
+04:06.400 --> 04:13.520
+en la documentación algún error ortográfico,
+el GitHub Dev Editor es la solución más rápida.
+
+04:13.520 --> 04:19.680
+En lugar de mantener el archivo en crudo
+desde mi terminal, desde de hecho el repositorio,
+
+04:19.680 --> 04:26.840
+aquí seleccionando la crayolita de editar,
+entonces sería mucho más cómodo visualmente
+
+04:26.840 --> 04:33.720
+hacerlo con ese editor de texto. Es para
+lo único que este GitHub Dev Editor te puede funcionar.
+
+04:33.720 --> 04:40.360
+De nuevo, es una buena práctica porque
+visualmente te permite desplazarte dentro de todos tus archivos
+
+04:40.360 --> 04:46.360
+sin problema. Si quieres avanzar, lo más
+importante es regresar o a VS Code o a un
+
+04:46.360 --> 04:50.920
+GitHub Codespace. Hay una consideración
+adicional de cuándo deberías de utilizar
+
+04:50.920 --> 04:58.400
+GitHub Dev Editor o un Codespace. Recuerda
+que un Codespace tiene costo, el Dev Editor no.
+
+04:58.400 --> 05:03.760
+Si tú quieres solo modificar algunas líneas,
+el Dev Editor es tu solución adecuada.
+
+05:03.760 --> 05:10.640
+Si tú quieres utilizar cualquier compilación,
+ejecutar tu proyecto, probarlo o cualquier cosa
+
+05:10.640 --> 05:17.760
+que requiera un entorno de desarrollo,
+entonces es Codespace. Solo recuerda, Codespace, como es
+
+05:17.760 --> 05:23.800
+una instancia en la nube, tiene un costo
+que se va a generar a tu cuenta siempre y cuando rebases
+
+05:23.800 --> 05:29.280
+las horas gratis reservadas por mes.
+Así que entre estas dos herramientas puedes escoger,
+
+05:29.280 --> 05:35.000
+si quieres una edición muy rápida o un
+entorno de desarrollo remoto para poder trabajar de una
+
+05:35.000 --> 05:39.400
+forma mucho más cómoda. Es de esta manera,
+con este balance en las dos herramientas,
+
+05:39.400 --> 05:45.360
+que podemos cerrar este módulo de GitHub
+Codespaces en donde la palabra colaboración
+
+05:45.360 --> 05:48.880
+fue llevada al límite de todas sus
+posibilidades.
+
diff --git a/Curso de Git y GitHub/04-GitHub Codespaces/05-Quiz.mhtml b/Curso de Git y GitHub/04-GitHub Codespaces/05-Quiz.mhtml
new file mode 100644
index 0000000000000000000000000000000000000000..dc07f40b022f2f81ad72996fe1a660bc06db63bf
--- /dev/null
+++ b/Curso de Git y GitHub/04-GitHub Codespaces/05-Quiz.mhtml
@@ -0,0 +1,13243 @@
+From:
+Snapshot-Content-Location: https://platzi.com/clases/quiz/21261/
+Subject:
+Date: Sat, 8 Nov 2025 17:33:13 -0500
+MIME-Version: 1.0
+Content-Type: multipart/related;
+ type="text/html";
+ boundary="----MultipartBoundary--cNRf8mZTqoLpoQnlgvA028iwI2nXUuYrpDyYEdYf6X----"
+
+
+------MultipartBoundary--cNRf8mZTqoLpoQnlgvA028iwI2nXUuYrpDyYEdYf6X----
+Content-Type: text/html
+Content-ID:
+Content-Transfer-Encoding: quoted-printable
+Content-Location: https://platzi.com/clases/quiz/21261/
+
+
+ =20
+
+ =20
+
+
+
+
+
+
+
+
+
+
+
+ =20
+
+ =20
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ =20
+ =20
+ =20
+
+ =20
+
+ =20
+
+
+ =20
+
+ =20
+
+
+
+ =20
+
+
+ =20
+ =20
+ =20
+
+
+
Para quienes buscan facilitar el trabajo colaborativo sin comprometer la seguridad de su repositorio privado, GitHub ofrece una solución eficaz a través de los tokens de acceso personal (PAT, por sus siglas en inglés). Estas llaves temporales otorgan acceso controlado a usuarios o aplicaciones, asegurando que solo puedan realizar acciones específicas y por el tiempo necesario. En este artículo, exploramos cómo crear y gestionar tokens en GitHub para maximizar la seguridad y funcionalidad en distintos entornos.
+
¿Cómo invitar a otros sin hacerlos colaboradores permanentes?
+
+
Escenarios comunes: Cuando deseas que alguien contribuya de forma temporal, pero sin añadirlo como colaborador permanente.
+
Solución con tokens: En lugar de agregarlo como colaborador, puedes crear un token con permisos limitados para que acceda al repositorio solo en el tiempo y con las acciones necesarias.
+
+
¿Qué tipos de tokens existen en GitHub?
+
GitHub ofrece dos tipos de tokens:
+
+
Tokens Clásicos: Permiten seleccionar permisos básicos y pueden tener duración indefinida (aunque no es recomendable).
+
Tokens Detallados: Versiones más nuevas que permiten control granular y una duración máxima de 90 días. Ideal para asegurar un acceso mucho más restringido.
+
+
¿Cómo se crea un token clásico?
+
+
Acceso a Configuración: Ve a “Settings” en tu perfil y selecciona “Developer Settings”.
+
Generar Token: Elige “Generate New Token” y configura:
+
+
Nombre: Ayuda a identificar el propósito del token.
+
Expiración: Ajusta a la duración esperada del proyecto.
+
Permisos: Elige los accesos que consideres necesarios (repos, paquetes, notificaciones, etc.).
+
+
+
Guardar Token: Copia el token en un lugar seguro, ya que no será visible nuevamente después de cerrar la página.
+
+
¿Cómo funcionan los tokens detallados?
+
A diferencia de los tokens clásicos, los detallados permiten:
+
+
Duración Máxima de 90 Días: Ofrece seguridad adicional al limitar el tiempo de acceso.
+
Control de Repositorio Específico: Puedes configurar que el token tenga acceso solo a repositorios específicos, incluso privados o públicos.
+
Permisos Granulares: Permiten ajustar más a detalle el alcance y las acciones que el token puede realizar.
+
+
¿Cómo utilizar el token en un entorno externo?
+
Al clonar un repositorio en un equipo sin credenciales de GitHub, el sistema pedirá el nombre de usuario y, en lugar de la contraseña de la cuenta, el token de acceso personal. Al ingresar el token en la terminal, podrás acceder al repositorio de forma segura, replicando el proceso de clonación estándar sin exponer tus credenciales personales.
+
¿Para qué otras tareas se pueden utilizar los tokens?
+
Los tokens no solo sirven para acceder desde equipos remotos; su funcionalidad se extiende a:
+
+
Automatización con GitHub Actions: Automatiza flujos de trabajo en tu repositorio.
+
Scripts Personalizados: Ideal para automatizar tareas repetitivas como commits periódicos o sincronización de proyectos.
+
Integración con Terceros: Configura accesos específicos para aplicaciones que interactúan con tu repositorio.
+
+
¿Qué medidas de seguridad deben tomarse con los tokens?
+
+
Configurar expiración: Limita la duración del token según las necesidades.
+
Reducir permisos: Otorga solo los permisos mínimos necesarios.
+
Revisión y eliminación: Revisa periódicamente los tokens en uso y elimina aquellos que ya no sean necesarios para evitar riesgos de acceso no autorizado.
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/02-Lecturas recomendadas.txt" "b/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/02-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..599a7539d5460ded8be49ba748115f58f747f489
--- /dev/null
+++ "b/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/02-Lecturas recomendadas.txt"
@@ -0,0 +1 @@
+https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens
diff --git "a/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/02-Mitigaci\303\263n de Brechas de Seguridad en Repositorios GitHub.mp4" "b/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/02-Mitigaci\303\263n de Brechas de Seguridad en Repositorios GitHub.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..22f0db663256c0a390fc522fccecf5fffb2528d2
--- /dev/null
+++ "b/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/02-Mitigaci\303\263n de Brechas de Seguridad en Repositorios GitHub.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ff65e03fa1f8a88539390fdfe7e1660b7bb681428c591ba6998674dd3b5fc99b
+size 91221208
diff --git "a/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/02-Mitigaci\303\263n de Brechas de Seguridad en Repositorios GitHub.vtt" "b/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/02-Mitigaci\303\263n de Brechas de Seguridad en Repositorios GitHub.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..a35d2a52258a039242e94dd38ed3f4e563867abb
--- /dev/null
+++ "b/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/02-Mitigaci\303\263n de Brechas de Seguridad en Repositorios GitHub.vtt"
@@ -0,0 +1,854 @@
+WEBVTT
+
+00:00.000 --> 00:03.300
+En la clase anterior vimos cómo crear un
+archivo gitignore
+
+00:03.300 --> 00:06.300
+y cómo administrar ciertos
+archivos
+
+00:06.300 --> 00:09.300
+que sabemos que pueden tener información
+delicada
+
+00:09.300 --> 00:11.700
+para evitar subirlas al repositorio.
+
+00:11.700 --> 00:17.200
+Sin embargo, eso no nos exenta de que
+podamos cometer ese error.
+
+00:17.200 --> 00:20.100
+Es decir, ni siquiera dentro de los
+archivos
+
+00:20.100 --> 00:22.300
+de configuración de un
+proyecto,
+
+00:22.300 --> 00:24.300
+dentro del mismo
+código,
+
+00:24.300 --> 00:27.100
+por error, por accidente, por descuido,
+
+00:27.100 --> 00:31.100
+podemos subir información que es
+considerada como delicada.
+
+00:31.100 --> 00:34.100
+¿Qué tipo de información puede ser
+delicada? No lo sé.
+
+00:34.100 --> 00:36.600
+Las llaves de acceso a una
+API,
+
+00:36.600 --> 00:39.600
+las llaves de conexión a una base de datos,
+
+00:39.600 --> 00:41.400
+o cosas por el
+estilo.
+
+00:41.400 --> 00:44.600
+De esta manera, lo que necesitamos hacer
+es aprender
+
+00:44.600 --> 00:48.600
+a mitigar esos daños dentro de nuestro
+repositorio.
+
+00:48.600 --> 00:51.100
+Me encuentro dentro de mi
+repositorio
+
+00:51.100 --> 00:53.600
+con el que he estado trabajando todo el curso.
+
+00:53.600 --> 00:55.600
+En la clase anterior lo hice
+privado
+
+00:55.600 --> 00:58.600
+para poder practicar estas mejoras de
+seguridad.
+
+00:58.600 --> 01:00.600
+Ahora lo voy a volver a hacer
+público
+
+01:00.600 --> 01:04.100
+para poder utilizar las herramientas que
+quiero mostrarte.
+
+01:04.100 --> 01:06.100
+Esto significa, en
+general,
+
+01:06.100 --> 01:10.100
+desplazarme hasta abajo a la zona de peligro.
+
+01:10.100 --> 01:12.100
+Me encanta esa
+sección.
+
+01:12.100 --> 01:14.600
+Y lo voy a volver público de
+nuevo.
+
+01:15.600 --> 01:19.600
+Sigo otra vez todas las recomendaciones
+que me pone GitHub.
+
+01:19.600 --> 01:22.600
+Y listo, se desvaneció el
+candado.
+
+01:22.600 --> 01:24.600
+Regreso a la sección
+principal.
+
+01:24.600 --> 01:27.600
+Me aparece que ya es público, y ahora sí.
+
+01:27.600 --> 01:31.600
+Puedo arrancar con las características que
+estoy buscando.
+
+01:31.600 --> 01:35.600
+La primera característica es regresar a
+Settings,
+
+01:35.600 --> 01:38.600
+desplazarme un poquito hacia
+abajo
+
+01:38.600 --> 01:42.600
+y encontrar Code Security and Analysis.
+
+01:43.100 --> 01:45.600
+Si te desplazas un poco hasta abajo,
+
+01:45.600 --> 01:49.100
+viene la categoría de Code Scanning.
+
+01:49.100 --> 01:53.600
+Si esta categoría y Secret Scanning no te
+aparecen,
+
+01:53.600 --> 01:57.600
+puede ser justamente porque tu repositorio
+es privado.
+
+01:57.600 --> 02:02.600
+Aquí, lo único que necesito es, dentro de
+Code Scanning,
+
+02:02.600 --> 02:05.600
+seleccionar en la sección de Herramientas,
+
+02:05.600 --> 02:08.600
+CodeQL
+Analyze.
+
+02:09.600 --> 02:11.600
+Y aquí
+está.
+
+02:11.600 --> 02:13.600
+Voy a poner, por
+default,
+
+02:13.600 --> 02:17.600
+el análisis de la revisión del código por
+defecto.
+
+02:17.600 --> 02:20.600
+El repositorio naturalmente va a
+saber
+
+02:20.600 --> 02:23.600
+cuál es el lenguaje que estoy utilizando más.
+
+02:23.600 --> 02:25.600
+En este caso, es C
+Sharp.
+
+02:25.600 --> 02:28.600
+Y si me desplazo un poco hacia abajo,
+
+02:28.600 --> 02:31.600
+puedo establecer algunos criterios de la
+búsqueda
+
+02:31.600 --> 02:33.600
+para poder habilitar
+esto.
+
+02:33.600 --> 02:37.600
+Habilito CodeQL como está, y queda listo.
+
+02:37.600 --> 02:42.600
+Ya me dice GitHub que tengo aquí todo esto
+habilitado.
+
+02:44.600 --> 02:47.600
+Me vuelvo a desplazar un poco para abajo,
+
+02:47.600 --> 02:51.600
+y esta es la sección que por ahora me va a
+interesar más.
+
+02:51.600 --> 02:53.600
+Secret
+Scanning.
+
+02:53.600 --> 02:58.600
+Aquí, si te das cuenta, no tienes que
+hacer absolutamente nada.
+
+02:58.600 --> 03:02.600
+Aparece un mensaje diciendo que recibes
+alertas de GitHub
+
+03:02.600 --> 03:04.600
+para secretos
+detectados.
+
+03:04.600 --> 03:08.600
+Y esto ya tiene un botón de deshabilitar.
+
+03:08.600 --> 03:10.600
+Quiere decir que, por
+defecto,
+
+03:10.600 --> 03:15.600
+GitHub tiene habilitado el escaneo de
+secretos
+
+03:15.600 --> 03:17.600
+dentro de tus
+repositorios.
+
+03:17.600 --> 03:20.600
+Es momento de probar y ver si es
+cierto
+
+03:20.600 --> 03:24.600
+que GitHub me puede mandar esas directivas
+de seguridad
+
+03:24.600 --> 03:27.600
+cuando yo esté cometiendo algún error.
+
+03:27.600 --> 03:32.600
+Eso significa, dentro de Code, en el
+proyecto de probando,
+
+03:33.600 --> 03:38.600
+voy a poner aquí en Program.cs una cadena
+de conexión
+
+03:38.600 --> 03:42.600
+y ver si lo identifica de la forma que
+estamos esperando
+
+03:42.600 --> 03:44.600
+que sí
+suceda.
+
+03:44.600 --> 03:46.600
+Me muevo a Visual Studio
+Code,
+
+03:46.600 --> 03:49.600
+en donde tengo exactamente ese archivo que
+tenía
+
+03:49.600 --> 03:52.600
+en mi primer repo dentro del sitio web,
+
+03:52.600 --> 03:54.600
+y voy a escribir algo así
+como
+
+03:54.600 --> 03:57.600
+string stripe API
+key,
+
+03:57.600 --> 04:01.600
+lo que suena demasiado lógico,
+¿cierto?
+
+04:01.600 --> 04:04.600
+Entonces, aquí solamente tengo que ponerlo
+entre comillas
+
+04:04.600 --> 04:06.600
+para que no haya ningún
+problema.
+
+04:06.600 --> 04:11.600
+Aquí ya agregué una llave de una API,
+
+04:11.600 --> 04:13.600
+de una cuenta de
+terceros,
+
+04:13.600 --> 04:17.600
+y esta llave podría darle acceso a quien
+tenga mi código
+
+04:17.600 --> 04:18.600
+a esa
+cuenta.
+
+04:18.600 --> 04:21.600
+Significa que es una brecha de
+seguridad
+
+04:21.600 --> 04:23.600
+que debería
+omitir.
+
+04:23.600 --> 04:25.600
+Lo ideal sería, si voy a hacer
+eso,
+
+04:25.600 --> 04:28.600
+ponerlo dentro de
+appsettings.json
+
+04:28.600 --> 04:31.600
+o de un archivo.env en otros lenguajes de
+programación.
+
+04:31.600 --> 04:35.600
+Así que voy a cometer este error a
+propósito
+
+04:35.600 --> 04:37.600
+y voy a subir estos
+cambios.
+
+04:39.600 --> 04:42.600
+En mi terminal, dentro de mi primer repo,
+
+04:42.600 --> 04:45.600
+escribo git
+status.
+
+04:45.600 --> 04:49.600
+Y aquí está la actualización de program.
+cs,
+
+04:49.600 --> 04:51.600
+git
+add,
+
+04:51.600 --> 04:53.600
+git
+commit,
+
+04:54.600 --> 04:58.600
+nuevos cambios por poner cualquier mensaje,
+
+04:58.600 --> 05:00.600
+y git
+push.
+
+05:02.600 --> 05:05.600
+Mis cambios ya fueron ingresados en el
+repositorio.
+
+05:05.600 --> 05:08.600
+Me voy a mover a ese
+repositorio.
+
+05:08.600 --> 05:11.600
+Si yo regreso a la portada de mi proyecto,
+
+05:11.600 --> 05:13.600
+te vas a dar cuenta de que hay
+aquí
+
+05:13.600 --> 05:17.600
+un pequeño circulito amarillo diciendo
+pending.
+
+05:17.600 --> 05:20.600
+Es decir, como yo acabo de hacer un cambio,
+
+05:20.600 --> 05:23.600
+aquí está now, y podríamos hacerlo probando,
+
+05:24.600 --> 05:27.600
+program.cs, y aquí está la
+llave.
+
+05:27.600 --> 05:30.600
+Este circulito lo que está haciendo
+es
+
+05:30.600 --> 05:32.600
+que GitHub en un segundo
+plano
+
+05:32.600 --> 05:35.600
+evalúa todos los cambios que
+subí
+
+05:35.600 --> 05:37.600
+y ahora solo es cosa de
+estar
+
+05:37.600 --> 05:39.600
+y ahora solo es cosa de
+esperar
+
+05:39.600 --> 05:42.600
+a ver que estos cambios se hayan realizado.
+
+05:42.600 --> 05:44.600
+Probablemente el circulito de
+pending
+
+05:44.600 --> 05:48.600
+no se actualice tan rápido como nosotros
+esperáramos.
+
+05:48.600 --> 05:50.600
+Pero si yo refresco la
+página,
+
+05:50.600 --> 05:54.600
+aunque el circulito ya está
+aquí,
+
+05:55.600 --> 06:00.600
+en la pestaña de seguridad ya me aparece
+un número uno.
+
+06:00.600 --> 06:03.600
+Un número uno, que en un proyecto
+real
+
+06:03.600 --> 06:06.600
+debería de preocuparme
+bastante.
+
+06:06.600 --> 06:09.600
+Selecciona este número
+uno.
+
+06:09.600 --> 06:12.600
+Y en esta sección tienes a la
+izquierda
+
+06:12.600 --> 06:15.600
+tres opciones de alertas de vulnerabilidades.
+
+06:15.600 --> 06:19.600
+Dependabot, CodeScanning y SecretScanning.
+
+06:19.600 --> 06:22.600
+Selecciona en dónde está la
+notificación
+
+06:22.600 --> 06:24.600
+y aquí está la
+alerta.
+
+06:24.600 --> 06:26.600
+Me aparece algo de retroalimentación,
+
+06:26.600 --> 06:28.600
+lo puedo cerrar para ver
+mejor,
+
+06:28.600 --> 06:31.600
+y si yo selecciono esta
+alerta,
+
+06:31.600 --> 06:35.600
+me dice que tengo un posible secreto activo.
+
+06:35.600 --> 06:38.600
+La recomendación que yo debería de
+hacer
+
+06:38.600 --> 06:41.600
+por haber publicado esta API
+Key
+
+06:41.600 --> 06:43.600
+dentro de mis
+repositorios.
+
+06:43.600 --> 06:45.600
+Las recomendaciones de estos cuatro
+pasos
+
+06:45.600 --> 06:47.600
+son esencialmente las
+mismas
+
+06:47.600 --> 06:50.600
+para cualquier error que vamos a cometer.
+
+06:50.600 --> 06:52.600
+Lo primero es ir a la otra
+cuenta,
+
+06:52.600 --> 06:54.600
+a la cuenta de
+terceros,
+
+06:54.600 --> 06:57.600
+y pedir que renueven las credenciales de
+acceso.
+
+06:57.600 --> 07:01.600
+Estas credenciales ya no deberían de ser
+aptas
+
+07:01.600 --> 07:03.600
+para un acceso a la
+cuenta,
+
+07:03.600 --> 07:05.600
+porque ya están
+ahí,
+
+07:05.600 --> 07:07.600
+y no solamente es
+necesario
+
+07:07.600 --> 07:10.600
+eliminar la línea de código y ya ser felices,
+
+07:10.600 --> 07:13.600
+sino que no puede
+eliminarse
+
+07:13.600 --> 07:15.600
+dentro de todo el
+historial
+
+07:15.600 --> 07:18.600
+de modificaciones de los commits de GitHub.
+
+07:18.600 --> 07:20.600
+Así que lo ideal es,
+primero,
+
+07:20.600 --> 07:25.600
+rotar esta llave para evitar un acceso no
+deseado.
+
+07:25.600 --> 07:27.600
+Después, modificar el
+código
+
+07:27.600 --> 07:30.600
+para que naturalmente ya tenga la
+posibilidad
+
+07:30.600 --> 07:33.600
+de evitar que esto se filtre como un
+commit
+
+07:33.600 --> 07:36.600
+dentro de mi
+proyecto.
+
+07:36.600 --> 07:39.600
+Ahora, hay un punto bien importante.
+
+07:39.600 --> 07:42.600
+Aquí escribí Stripe API
+Key
+
+07:42.600 --> 07:45.600
+y sí se ve a todas
+luces
+
+07:45.600 --> 07:48.600
+que estoy hablando de una llave de seguridad.
+
+07:48.600 --> 07:52.600
+Sin embargo, si yo regreso a Visual Studio
+Code
+
+07:52.600 --> 07:54.600
+y escribo otra
+línea,
+
+07:54.600 --> 07:57.600
+puedo insertar algo como si
+fuera
+
+07:57.600 --> 07:59.600
+una llave de conexión a
+SQL.
+
+07:59.600 --> 08:03.600
+Es decir, String Testing Connection.
+
+08:03.600 --> 08:06.600
+No estoy poniendo String Connection,
+
+08:06.600 --> 08:09.600
+SQL Connection, SQL
+Key,
+
+08:09.600 --> 08:13.600
+o algunas claves que podrían detectarse
+más fácilmente.
+
+08:13.600 --> 08:16.600
+Y la cadena es una cadena de
+conexión
+
+08:16.600 --> 08:18.600
+que podría ser una cadena
+real.
+
+08:18.600 --> 08:22.600
+Aquí, Stripe API Key me lo identificó de
+prisa.
+
+08:22.600 --> 08:25.600
+Sin embargo, si yo subo
+esto,
+
+08:25.600 --> 08:28.600
+puedo burlar un poquito la seguridad.
+
+08:28.600 --> 08:31.600
+Es decir, primero limpio mi terminal,
+
+08:31.600 --> 08:34.600
+veo que mi cambio de la String
+Connection
+
+08:34.600 --> 08:37.600
+está listo, ahí
+está.
+
+08:37.600 --> 08:39.600
+Git
+Add.
+
+08:39.600 --> 08:41.600
+Git
+Commit.
+
+08:45.600 --> 08:48.600
+Voy a poner como mensaje cadena nueva,
+
+08:48.600 --> 08:51.600
+Enter, y Git
+Push,
+
+08:51.600 --> 08:54.600
+para subir estos
+cambios.
+
+08:54.600 --> 08:57.600
+Mis cambios suben y voy a regresar a mi
+repositorio
+
+08:57.600 --> 09:00.600
+en donde dentro de
+Code
+
+09:00.600 --> 09:03.600
+sigo teniendo la brecha de
+seguridad
+
+09:03.600 --> 09:06.600
+de lo que yo tenía con el Stripe API Key.
+
+09:06.600 --> 09:09.600
+Sin embargo, puedo esperar unos
+minutos
+
+09:09.600 --> 09:13.600
+y ver que no se va a crear una nueva alerta.
+
+09:13.600 --> 09:15.600
+Bien, dejé pasar unos cuatro
+minutos
+
+09:15.600 --> 09:17.600
+después de mi último
+commit
+
+09:17.600 --> 09:20.600
+para ver que la revisión del
+código
+
+09:20.600 --> 09:22.600
+haya sido
+exitosa.
+
+09:22.600 --> 09:25.600
+Aquí está mi palomita de que el proceso
+terminó.
+
+09:25.600 --> 09:28.600
+Aquí está mi último commit de cadena
+nueva
+
+09:28.600 --> 09:30.600
+hace cuatro
+minutos.
+
+09:30.600 --> 09:33.600
+Y si yo voy a la sección de seguridad,
+
+09:33.600 --> 09:36.600
+sigo teniendo solo una
+alerta,
+
+09:36.600 --> 09:39.600
+la alerta de la llave de
+Stripe.
+
+09:39.600 --> 09:42.600
+No me menciona ninguna alerta
+relacionada
+
+09:42.600 --> 09:45.600
+a mi cadena de conexión a
+SQL.
+
+09:45.600 --> 09:48.600
+Esto es importante que lo tengas bien
+presente,
+
+09:48.600 --> 09:51.600
+porque GitHub te ayuda a
+revisar
+
+09:51.600 --> 09:53.600
+que no se filtra
+información.
+
+09:53.600 --> 09:56.600
+Sin embargo, como puedes ver gracias al
+segundo caso,
+
+09:56.600 --> 09:59.600
+esta medida no es
+infalible.
+
+09:59.600 --> 10:02.600
+Lo mejor que te puedo decir
+aquí
+
+10:02.600 --> 10:05.600
+es que siempre va a ser mucho más fácil
+evitar
+
+10:05.600 --> 10:07.600
+que
+lamentar.
+
+10:07.600 --> 10:10.600
+Para eso aprendimos a utilizar el archivo
+de Gitignore.
+
+10:10.600 --> 10:13.600
+El archivo de Gitignore nos permite
+utilizar
+
+10:13.600 --> 10:16.600
+variables de entorno en los archivos.
+env
+
+10:16.600 --> 10:19.600
+o
+appsettings.json,
+
+10:19.600 --> 10:22.600
+dependiendo el lenguaje de programación
+que utilices,
+
+10:22.600 --> 10:25.600
+y de esta forma evitar
+subir
+
+10:25.600 --> 10:29.600
+todos estos archivos estáticos dentro de
+nuestro código.
+
+10:29.600 --> 10:32.600
+Ya que aprendiste a utilizar tus
+secretos
+
+10:32.600 --> 10:35.600
+de una forma más segura en los archivos de
+variables de ambiente
+
+10:35.600 --> 10:38.600
+y omitir estos archivos con Gitignore,
+
+10:38.600 --> 10:41.600
+ten por seguro que Code Scanning y Secret
+Scanning
+
+10:41.600 --> 10:45.600
+son herramientas que nunca vas a utilizar
+dentro de GitHub.
+
+10:45.600 --> 10:48.600
+Y esperemos que así
+sea.
+
+10:48.600 --> 10:50.600
+Significa que te estás
+adoptando
+
+10:50.600 --> 10:53.600
+a las mejores prácticas de desarrollo en
+tu proyecto
+
+10:53.600 --> 10:56.600
+y evitando cualquier dolor de cabeza posible.
+
+10:56.600 --> 10:59.600
+Tener que rotar llaves de
+acceso
+
+10:59.600 --> 11:02.600
+o tener que rotar cadenas de
+conexión
+
+11:02.600 --> 11:05.600
+es un proceso complicado porque puede ser
+que tu producto
+
+11:05.600 --> 11:08.600
+no sea el único que las está utilizando.
+
+11:08.600 --> 11:11.600
+De nuevo, la mejor forma de solucionar
+todo esto
+
+11:11.600 --> 11:14.600
+es previniendo y utilizando tus
+archivos
+
+11:14.600 --> 11:17.600
+de variables de ambiente para tener un
+mejor control
+
+11:17.600 --> 11:20.600
+de seguridad en tus
+proyectos.
+
diff --git "a/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/02-Resumen.html" "b/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/02-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..9186919701893723a9df4d13c0139bc32b560a39
--- /dev/null
+++ "b/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/02-Resumen.html"
@@ -0,0 +1,120 @@
+
+
+
+
+
+
+ Mitigación de Brechas de Seguridad en Repositorios GitHub
+
+
+
+
+
+
Resumen
Al configurar un proyecto en GitHub, es crucial proteger la información sensible, como llaves de API o datos de conexión, evitando que sean subidas por error al repositorio. Aunque el uso de archivos como .gitignore es clave para excluir información sensible, existen herramientas adicionales en GitHub para detectar y mitigar estos riesgos. Aquí te explico cómo activar y aprovechar al máximo CodeQL y Secret Scanning para mejorar la seguridad de tu código en repositorios públicos.
+
¿Cómo activar CodeQL y Secret Scanning en GitHub?
+
Para comenzar, es necesario hacer el repositorio público, ya que algunas de estas funciones no están disponibles en repositorios privados. Sigue estos pasos para activar la seguridad de tu código:
+
+
Ve a Settings en el repositorio y desplázate a Code Security and Analysis.
+
Activa CodeQL Analysis en la sección de Code Scanning. GitHub detectará el lenguaje de tu proyecto y comenzará a analizar el código en segundo plano.
+
Luego, asegúrate de que Secret Scanning esté habilitado. Esta función, que viene activada por defecto, detecta automáticamente secretos o llaves sensibles en el código.
+
+
¿Cómo probar si Secret Scanning detecta información sensible?
+
Para verificar el funcionamiento de Secret Scanning, puedes añadir intencionadamente una clave sensible en el código. Por ejemplo:
+
+
Agrega una cadena como string stripeApiKey = "clave_sensible"; en tu archivo de código y sube el cambio.
+
GitHub realizará el análisis en segundo plano y, si detecta una llave API, emitirá una alerta en la sección de Security.
+
+
En cambio, una cadena menos evidente, como string connectionString = "cadena_sensible";, podría pasar desapercibida. Este ejemplo muestra que, aunque Secret Scanning es útil, no es infalible y puede omitir cadenas sensibles si no siguen patrones comunes.
+
¿Qué hacer si GitHub detecta una alerta de seguridad?
+
Si GitHub te notifica sobre una alerta de secreto en el código, sigue estos pasos para mitigar el riesgo:
+
+
Renueva las credenciales en la cuenta del servicio de terceros para evitar accesos no autorizados.
+
Elimina la clave del historial de commits, ya que eliminarla solo del código actual no la quita de versiones anteriores.
+
Modifica tu código para utilizar archivos de configuración, como .env o appsettings.json, y exclúyelos con .gitignore para evitar futuras filtraciones.
+
+
¿Por qué CodeQL y Secret Scanning no son suficientes?
+
Aunque GitHub ofrece herramientas poderosas de análisis, no garantizan la detección de todas las cadenas sensibles. Por eso, la mejor práctica sigue siendo prevenir las filtraciones configurando correctamente .gitignore y almacenando secretos en archivos de entorno.
+
Estas prácticas te ayudarán a evitar el riesgo de exponer información crítica, reduciendo los problemas de seguridad y permitiéndote mantener un código limpio y seguro.
+
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/03-Gesti\303\263n de Seguridad de Paquetes con Dependabot en Proyectos NET.mp4" "b/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/03-Gesti\303\263n de Seguridad de Paquetes con Dependabot en Proyectos NET.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..3cd53a01f439b51136b54fc191c4d51321e480b2
--- /dev/null
+++ "b/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/03-Gesti\303\263n de Seguridad de Paquetes con Dependabot en Proyectos NET.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7dbc2eaebcc6337b8a3cec6009c82cd7cbe09f184163e655d9585919ae90f906
+size 115917258
diff --git "a/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/03-Gesti\303\263n de Seguridad de Paquetes con Dependabot en Proyectos NET.vtt" "b/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/03-Gesti\303\263n de Seguridad de Paquetes con Dependabot en Proyectos NET.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..1348410d65dad3312d94d1e451a00f623a772492
--- /dev/null
+++ "b/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/03-Gesti\303\263n de Seguridad de Paquetes con Dependabot en Proyectos NET.vtt"
@@ -0,0 +1,902 @@
+WEBVTT
+
+00:00.000 --> 00:03.500
+Ahora que ya vimos cómo evitar fugas de
+información
+
+00:03.500 --> 00:05.300
+gracias a Secret
+Scanning,
+
+00:05.300 --> 00:08.600
+es momento de cubrir otro gran bache de
+información
+
+00:08.600 --> 00:10.500
+que nosotros podríamos
+tener
+
+00:10.500 --> 00:13.400
+gracias a los paquetes que utilizamos.
+
+00:13.400 --> 00:16.200
+Es decir, si tú estás creando una
+aplicación
+
+00:16.200 --> 00:18.300
+y haces un hola,
+mundo,
+
+00:18.300 --> 00:22.100
+esta quizá podría ser la única manera
+posible
+
+00:22.100 --> 00:26.300
+de no agregarle paquetes de extensión a tu
+aplicación.
+
+00:26.300 --> 00:29.700
+Cuando quieras comenzar a leer un archivo
+JSON,
+
+00:29.700 --> 00:32.600
+probablemente vas a utilizar un paquete de
+PIP,
+
+00:32.600 --> 00:35.100
+de NPM o de
+Nuget
+
+00:35.100 --> 00:37.600
+para poder interpretar esta información.
+
+00:37.600 --> 00:40.100
+Si tú quieres que tu aplicación de
+Python
+
+00:40.100 --> 00:42.400
+pueda trabajar como una
+API,
+
+00:42.400 --> 00:44.100
+vas a agregarle
+Flask,
+
+00:44.100 --> 00:47.800
+y esto es un paquete agregado en tu
+aplicación.
+
+00:47.800 --> 00:51.300
+Si tú quieres que Node interprete con
+colores algo,
+
+00:51.300 --> 00:54.200
+vas a necesitar un paquete para ello.
+
+00:54.200 --> 00:59.100
+Y así, todas las aplicaciones dependen
+mucho de paquetes de terceros
+
+00:59.100 --> 01:02.100
+para hacerte el trabajo mucho más fácil a ti.
+
+01:02.100 --> 01:04.700
+Estas aplicaciones con
+paquetes
+
+01:04.700 --> 01:06.800
+pueden tener una brecha de
+seguridad
+
+01:06.800 --> 01:09.500
+si los paquetes no están actualizados,
+
+01:09.500 --> 01:13.300
+y para ello, Dependabot es nuestra
+herramienta ideal.
+
+01:13.300 --> 01:15.600
+Me encuentro dentro de mi
+repositorio
+
+01:15.600 --> 01:17.600
+con el que he estado
+trabajando.
+
+01:17.600 --> 01:20.100
+Voy a la sección de
+Settings.
+
+01:20.100 --> 01:24.000
+De hecho, puedo ir a Settings o a Seguridad.
+
+01:24.000 --> 01:26.800
+Cualquiera de los dos me puede llevar a lo
+mismo.
+
+01:26.800 --> 01:31.100
+Por ejemplo, vamos a agarrar Seguridad y
+Dependabot.
+
+01:32.300 --> 01:36.200
+Aquí me aparece que Dependabot está
+deshabilitado
+
+01:36.200 --> 01:40.100
+y me está mandando a los Settings del
+repositorio.
+
+01:40.100 --> 01:42.400
+Cualquiera de las dos opciones me va a
+llevar
+
+01:42.400 --> 01:44.500
+exactamente al mismo
+lugar.
+
+01:44.500 --> 01:49.100
+Settings, Code Security and Analysis,
+
+01:49.100 --> 01:50.600
+y aquí
+está.
+
+01:50.600 --> 01:54.300
+Aquí lo que necesito es desplazarme hacia
+abajo,
+
+01:54.300 --> 01:57.300
+seleccionar la categoría de
+Dependabot
+
+01:57.300 --> 02:01.100
+y habilitar las alertas del Dependabot.
+
+02:03.200 --> 02:04.100
+Ahí
+está.
+
+02:04.100 --> 02:07.200
+Estos cambios ya fueron
+guardados.
+
+02:07.200 --> 02:10.000
+Me desplazo un poquito hacia
+abajo
+
+02:10.000 --> 02:14.900
+y veo que ya el Dependabot está habilitado
+con sus alertas.
+
+02:14.900 --> 02:17.800
+Le voy a decir que todo esté habilitado.
+
+02:17.800 --> 02:24.300
+Voy a hacer las actualizaciones de
+seguridad del Dependabot.
+
+02:26.300 --> 02:29.600
+Después me desplazo otra vez a esa
+sección
+
+02:29.600 --> 02:34.300
+y las actualizaciones de seguridad agrupadas.
+
+02:34.300 --> 02:37.300
+¿Por qué estoy habilitando toda la
+funcionalidad?
+
+02:37.300 --> 02:38.200
+Simple.
+
+02:38.200 --> 02:41.500
+Si ya estoy esperando que Dependabot me ayude,
+
+02:41.500 --> 02:44.600
+ahora quiero que me ayude con todas las
+posibilidades
+
+02:44.600 --> 02:47.700
+que yo le puedo pedir a esta herramienta.
+
+02:47.700 --> 02:49.700
+Voy a hacer un clic en el
+botón
+
+02:49.700 --> 02:52.700
+de Dependabot, Version
+Updates,
+
+02:52.700 --> 02:54.700
+que de hecho será
+esta,
+
+02:54.700 --> 02:57.700
+particularmente la que más me importe.
+
+02:57.700 --> 03:00.700
+Cuando yo le puse habilitar en este botón,
+
+03:00.700 --> 03:03.700
+me apareció este archivo
+YAML,
+
+03:03.700 --> 03:06.700
+Dependabot.yaml,
+
+03:06.700 --> 03:09.200
+que se creó de manera
+automática,
+
+03:09.200 --> 03:12.200
+solo por haber presionado ese botón.
+
+03:12.200 --> 03:16.700
+Esto es un ciclo que el Dependabot va a
+estar ejecutando
+
+03:16.700 --> 03:19.700
+por ejemplo, aquí puede ser semanal.
+
+03:19.700 --> 03:22.700
+Por ahorita con estos cambios, en lugar de
+semanal,
+
+03:22.700 --> 03:24.700
+voy a cambiarlo a
+daily.
+
+03:26.200 --> 03:30.700
+Y ya con ese cambio, puedo guardar este
+nuevo archivo
+
+03:30.700 --> 03:32.700
+dentro de mi rama
+mail,
+
+03:32.700 --> 03:35.700
+como si fuera cualquier otro archivo en mi
+proyecto.
+
+03:36.700 --> 03:40.700
+Aquí me aparece la ubicación de ese nuevo
+archivo,
+
+03:40.700 --> 03:43.700
+mi primer repo, punto,
+GitHub,
+
+03:43.700 --> 03:46.700
+y un
+Dependabot.yaml,
+
+03:46.700 --> 03:50.700
+igual que el issue template que hice hace
+algunas clases.
+
+03:50.700 --> 03:53.700
+Voy a regresar a la portada de mi proyecto.
+
+03:53.700 --> 03:55.700
+Ya con todo esto
+listo,
+
+03:55.700 --> 03:59.700
+entonces me puedo desplazar un poquito
+hacia abajo
+
+03:59.700 --> 04:02.700
+para ver que como mi proyecto es de.
+NET,
+
+04:02.700 --> 04:05.700
+entonces voy a agregar un paquete de.
+NET,
+
+04:05.700 --> 04:07.700
+un paquete de
+Nuget.
+
+04:07.700 --> 04:10.700
+Primero voy a abrir una nueva
+pestaña
+
+04:10.700 --> 04:14.700
+y pegar una dirección del paquete Nuget
+que voy a utilizar.
+
+04:14.700 --> 04:16.700
+Esta dirección
+URL,
+
+04:16.700 --> 04:19.700
+si estás siguiendo el ejercicio al pie de
+la letra,
+
+04:19.700 --> 04:22.700
+la puedes obtener en los recursos de esta
+clase.
+
+04:22.700 --> 04:26.700
+Aquí está el paquete de nuget-newtonsoft.
+json,
+
+04:26.700 --> 04:29.700
+que yo me atrevería a creer que es el
+paquete
+
+04:29.700 --> 04:32.700
+más utilizado
+en.NET.
+
+04:32.700 --> 04:36.700
+Su versión final es la versión 13.0.3.
+
+04:36.700 --> 04:38.700
+Voy a hacer un
+zoom
+
+04:38.700 --> 04:41.700
+para que se pueda ver un poco mejor.
+
+04:41.700 --> 04:45.700
+Aquí ya puedo ver el 13.0.3
+mejor,
+
+04:45.700 --> 04:48.700
+pero no voy a utilizar esa
+versión.
+
+04:48.700 --> 04:53.700
+Voy a seleccionar de aquí abajo la
+categoría Versions.
+
+04:53.700 --> 04:55.700
+Desplazarme un
+poco
+
+04:55.700 --> 04:59.700
+y en la versión
+12.0.3
+
+04:59.700 --> 05:03.700
+vas a darte cuenta que hay un pequeño
+signo de exclamación
+
+05:03.700 --> 05:07.700
+diciendo que tiene al menos una
+vulnerabilidad.
+
+05:07.700 --> 05:10.700
+Este es el que me interesa, entonces.
+
+05:10.700 --> 05:13.700
+La versión
+12.0.3
+
+05:13.700 --> 05:16.700
+para hacer que mi Dependabot pueda trabajar.
+
+05:16.700 --> 05:19.700
+Para poder agregar esta versión en mi
+proyecto,
+
+05:19.700 --> 05:21.700
+voy a irme a Visual
+Studio,
+
+05:21.700 --> 05:23.700
+en mi proyecto de C
+Sharp,
+
+05:23.700 --> 05:26.700
+cierro estas pestañas que ahorita ya no
+necesito,
+
+05:26.700 --> 05:28.700
+tres
+puntos,
+
+05:28.700 --> 05:31.700
+Terminal y una nueva
+terminal.
+
+05:31.700 --> 05:35.700
+Aquí estoy abriendo una terminal de
+WSL
+
+05:35.700 --> 05:38.700
+dentro de la ubicación del proyecto en el
+que estoy trabajando,
+
+05:38.700 --> 05:41.700
+es decir, mi primer
+repo.
+
+05:41.700 --> 05:44.700
+Me voy a desplazar a proyecto 1 y probando.
+
+05:44.700 --> 05:48.700
+Esto es CD, proyecto
+1,
+
+05:50.700 --> 05:53.700
+y después era CD
+probando.
+
+05:54.700 --> 05:56.700
+Ahora que estoy aquí, limpio mi
+terminal
+
+05:56.700 --> 06:00.700
+y escribo el
+código.NET
+
+06:00.700 --> 06:04.700
+ADD PACKAGE
+newtonsoft.json
+
+06:04.700 --> 06:08.700
+y la versión que seleccioné, 12.0.3.
+
+06:08.700 --> 06:11.700
+Esta es la forma en la que yo agrego los
+paquetes de Nuget
+
+06:11.700 --> 06:13.700
+dentro de mis proyectos
+de.NET,
+
+06:13.700 --> 06:16.700
+de la misma forma que tú utilizas pip
+install
+
+06:16.700 --> 06:19.700
+o npm en Node o
+Python.
+
+06:20.700 --> 06:22.700
+Presiono
+Enter
+
+06:22.700 --> 06:26.700
+y la terminal y.NET hacen su
+magia.
+
+06:26.700 --> 06:28.700
+Agregaron ya mi
+paquete.
+
+06:28.700 --> 06:31.700
+Si no estás familiarizado con los
+proyectos de.NET,
+
+06:31.700 --> 06:36.700
+puedes abrir el archivo
+probando.csproject
+
+06:36.700 --> 06:38.700
+y por aquí, aquí
+está,
+
+06:38.700 --> 06:41.700
+dentro de Item Group está el
+listado
+
+06:41.700 --> 06:44.700
+de todos los paquetes de Nuget que hemos
+agregado,
+
+06:44.700 --> 06:46.700
+así como su
+versión.
+
+06:46.700 --> 06:48.700
+Voy a limpiar mi
+terminal
+
+06:49.700 --> 06:51.700
+y aquí no se ve muy
+bien.
+
+06:51.700 --> 06:53.700
+Voy a usar mi terminal por separado.
+
+06:53.700 --> 06:54.700
+Está.
+
+06:54.700 --> 06:56.700
+Limpio mi
+pantalla
+
+06:56.700 --> 06:59.700
+y escribo git
+status.
+
+06:59.700 --> 07:02.700
+Ahí está, el proyecto ha sido
+modificado
+
+07:02.700 --> 07:04.700
+para utilizar ese paquete de
+Nuget.
+
+07:04.700 --> 07:06.700
+git
+add,
+
+07:07.700 --> 07:09.700
+git
+commit,
+
+07:09.700 --> 07:13.700
+m, y nuevo paquete
+agregado.
+
+07:15.700 --> 07:18.700
+Después de eso, por último, git push.
+
+07:19.700 --> 07:21.700
+¡Wow! Una feliz
+coincidencia.
+
+07:21.700 --> 07:25.700
+Ahora, como yo hice cambios dentro de mi
+repositorio
+
+07:25.700 --> 07:28.700
+antes de trabajar con mi repositorio local,
+
+07:28.700 --> 07:31.700
+git me está indicando que primero
+necesito
+
+07:31.700 --> 07:35.700
+obtener los cambios de mi repositorio
+remoto
+
+07:35.700 --> 07:38.700
+para después fusionar los
+míos.
+
+07:38.700 --> 07:40.700
+Escribo git
+pull.
+
+07:42.700 --> 07:45.700
+Me aparecen algunas opciones que de hecho,
+
+07:45.700 --> 07:48.700
+en alguna clase posterior, necesitamos
+revisar
+
+07:48.700 --> 07:50.700
+la configuración de
+git
+
+07:50.700 --> 07:54.700
+para poder hacer esta mezcla entre git
+pull y git push.
+
+07:54.700 --> 07:57.700
+Por ahora, solo voy a seleccionar la
+primera opción.
+
+07:57.700 --> 08:03.700
+Dar clic derecho, pegar y volver a
+escribir git pull
+
+08:03.700 --> 08:06.700
+para jalar todos mis
+datos.
+
+08:06.700 --> 08:09.700
+Ahora que ya tengo un git
+pull,
+
+08:09.700 --> 08:13.700
+git push para de nuevo subir toda mi
+información.
+
+08:13.700 --> 08:17.700
+Listo. Mis cambios están en el repositorio.
+
+08:17.700 --> 08:19.700
+Vamos a ese
+repo.
+
+08:19.700 --> 08:22.700
+Aquí, mi primer
+repo.
+
+08:22.700 --> 08:25.700
+Aquí está el puntito de que se están
+ejecutando
+
+08:25.700 --> 08:27.700
+los procesos de
+seguridad.
+
+08:27.700 --> 08:30.700
+Sin embargo, esto fue demasiado rápido.
+
+08:30.700 --> 08:33.700
+Ya hay un número dos en
+seguridad.
+
+08:33.700 --> 08:36.700
+Estoy cavando mi propia tumba en este
+proyecto.
+
+08:36.700 --> 08:40.700
+Ya no tengo solo la notificación de Secret
+Scanning,
+
+08:40.700 --> 08:43.700
+ya tengo también la notificación de
+Dependabot.
+
+08:43.700 --> 08:46.700
+Selecciona esta
+categoría.
+
+08:46.700 --> 08:49.700
+Desplázate un poco hacia
+abajo
+
+08:49.700 --> 08:52.700
+y Dependabot es mucho más
+veloz.
+
+08:52.700 --> 08:55.700
+No solo te dice que estás
+utilizando
+
+08:55.700 --> 08:58.700
+una versión obsoleta de tu
+paquete,
+
+08:58.700 --> 09:02.700
+sino que lo pone como versión alta o de
+alta prioridad.
+
+09:02.700 --> 09:04.700
+Seleccionalo.
+
+09:04.700 --> 09:07.700
+La diferencia entre Secret Scanning y el
+Dependabot
+
+09:07.700 --> 09:11.700
+es que por algunos segundos apareció una
+ruedita girando
+
+09:11.700 --> 09:14.700
+y ahora me aparece este
+mensaje.
+
+09:14.700 --> 09:17.700
+El Dependabot ha creado un pull
+request
+
+09:17.700 --> 09:21.700
+para que esto se solucione de manera autónoma.
+
+09:21.700 --> 09:24.700
+Si me desplazo un poco hacia el texto,
+
+09:24.700 --> 09:28.700
+voy a ver que me está explicando cuál es
+el problema,
+
+09:28.700 --> 09:32.700
+cuál es la razón por la cual tengo que
+actualizar esta versión.
+
+09:32.700 --> 09:35.700
+Si tienes un poco de tiempo, sería
+fantástico
+
+09:35.700 --> 09:39.700
+que dediques algo para leer todos los
+cambios
+
+09:39.700 --> 09:42.700
+entre la versión 12 y la versión 13.
+
+09:42.700 --> 09:45.700
+De esta forma puedes aprender mucho de
+seguridad
+
+09:45.700 --> 09:47.700
+en tus
+paquetes.
+
+09:47.700 --> 09:50.700
+Sin embargo, lo que por ahora me
+interesa
+
+09:50.700 --> 09:55.700
+es que selecciones este botón de Review
+Security Update.
+
+09:57.700 --> 10:00.700
+Esto te va a sacar de la sección de
+Security
+
+10:00.700 --> 10:03.700
+y te va a llevar a Pull
+Request.
+
+10:03.700 --> 10:07.700
+Aquí lo que va a suceder es que si te
+desplazas hacia abajo,
+
+10:07.700 --> 10:12.700
+Dependabot creó un PR únicamente para
+solucionar
+
+10:12.700 --> 10:15.700
+esta diferencia entre las versiones.
+
+10:15.700 --> 10:18.700
+Te dice cuál es la versión que tú
+pusiste
+
+10:18.700 --> 10:21.700
+y cuál es la versión que necesitas
+tener
+
+10:21.700 --> 10:23.700
+como la más
+estable.
+
+10:23.700 --> 10:26.700
+La compatibilidad entre versiones
+indica
+
+10:26.700 --> 10:29.700
+cuál es la diferencia entre la
+funcionalidad
+
+10:29.700 --> 10:31.700
+de una o la otra
+versión.
+
+10:31.700 --> 10:35.700
+Naturalmente, entre más lejana sea esta
+versión,
+
+10:35.700 --> 10:39.700
+menos compatible va a ser con la versión
+más reciente.
+
+10:39.700 --> 10:43.700
+Puedo desplazarme y antes de que alguien
+en mi equipo
+
+10:43.700 --> 10:45.700
+se entere de mi gran
+error,
+
+10:45.700 --> 10:48.700
+puedo fusionar este Pull
+Request.
+
+10:48.700 --> 10:51.700
+Hago el Confirm
+Merge.
+
+10:51.700 --> 10:55.700
+Espero a que mi Pull Request haya sido
+fusionado
+
+10:55.700 --> 10:59.700
+con la rama principal y puedo eliminar
+esta rama.
+
+11:01.700 --> 11:04.700
+¡Wow! Ni siquiera tuve que
+hacerlo.
+
+11:04.700 --> 11:08.700
+Antes de presionar el botón, el Dependabot
+lo acaba de hacer.
+
+11:08.700 --> 11:10.700
+Eliminó la rama por sí
+solo.
+
+11:10.700 --> 11:14.700
+Ahora me regreso a la portada de mi proyecto.
+
+11:14.700 --> 11:16.700
+Probando.
+
+11:16.700 --> 11:20.700
+El archivo csproy, o proj, o proyecto.
+
+11:20.700 --> 11:23.700
+Y ahora ya está
+actualizado.
+
+11:23.700 --> 11:28.700
+13.01 en la versión más estable de mi
+paquete de Nuget.
+
+11:28.700 --> 11:32.700
+Como puedes ver, la más grande ventaja de
+Dependabot
+
+11:32.700 --> 11:35.700
+es que no solo identifica el problema,
+
+11:35.700 --> 11:38.700
+sino que lo contiene y crea una
+solución
+
+11:38.700 --> 11:40.700
+por medio de un Pull
+Request.
+
+11:40.700 --> 11:43.700
+Esto sirve para que si yo cometo un
+error
+
+11:43.700 --> 11:46.700
+y subo un paquete
+obsoleto,
+
+11:46.700 --> 11:50.700
+Dependabot de inmediato detenga el problema,
+
+11:50.700 --> 11:54.700
+lo contiene en un Pull Request y genera
+esa solución
+
+11:54.700 --> 11:58.700
+para que cualquiera en el equipo fusione
+el Pull Request
+
+11:58.700 --> 12:00.700
+y todo quede en
+orden.
+
+12:00.700 --> 12:04.700
+Considera que el Dependabot va a ser
+sumamente útil
+
+12:04.700 --> 12:07.700
+porque entre más grande va siendo tu proyecto,
+
+12:07.700 --> 12:09.700
+más paquetes vas a
+necesitar
+
+12:09.700 --> 12:11.700
+y es probable que en el día a
+día
+
+12:11.700 --> 12:14.700
+se te olvide estar actualizando las versiones.
+
+12:14.700 --> 12:17.700
+Así que cada vez que salga una nueva
+versión del paquete
+
+12:17.700 --> 12:19.700
+que tú estás
+utilizando,
+
+12:19.700 --> 12:22.700
+Dependabot va a crear ese Pull
+Request
+
+12:22.700 --> 12:25.700
+para mantenerte siempre con lo
+último
+
+12:25.700 --> 12:42.700
+de las versiones estables de todos tus
+paquetes.
+
diff --git "a/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/03-Lecturas recomendadas.txt" "b/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/03-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..8461d75fcaef53868be9b4d3ef39b1b0a7304777
--- /dev/null
+++ "b/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/03-Lecturas recomendadas.txt"
@@ -0,0 +1,3 @@
+https://github.com/platzi/git-github
+https://github.com/dependabot
+https://www.nuget.org/packages/newtonsoft.json/
diff --git "a/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/03-Resumen.html" "b/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/03-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..f222e16600bdaffc354f99e89fbccb543ea454c1
--- /dev/null
+++ "b/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/03-Resumen.html"
@@ -0,0 +1,128 @@
+
+
+
+
+
+
+ Gestión de Seguridad de Paquetes con Dependabot en Proyectos .NET
+
+
+
+
+
+
Resumen
La gestión de dependencias es esencial para mantener la seguridad y estabilidad de las aplicaciones. Dependabot es una herramienta eficaz que, al integrarse en el flujo de trabajo, identifica y soluciona problemas en las versiones de paquetes de terceros, minimizando vulnerabilidades. Aquí exploramos cómo configurar y aprovechar al máximo Dependabot.
+
¿Por qué es importante mantener actualizados los paquetes de terceros?
+
Los paquetes de terceros son un recurso común en el desarrollo para simplificar tareas como la lectura de archivos JSON o la creación de APIs. Sin embargo, estas dependencias pueden convertirse en un riesgo si no se actualizan, ya que las versiones desactualizadas pueden contener vulnerabilidades que comprometan la seguridad de la aplicación.
+
¿Cómo activar Dependabot en un repositorio?
+
Para activar Dependabot:
+
+
Accede a Settings o Security dentro del repositorio.
+
Ve a Code Security and Analysis y selecciona la categoría de Dependabot.
+
Activa las alertas de seguridad y actualizaciones de versión.
+
Dependabot generará un archivo dependabot.yml, donde puedes ajustar la frecuencia de las revisiones, como cambiar de semanal a diaria para detectar actualizaciones con mayor regularidad.
+
+
¿Cómo utilizar Dependabot para gestionar versiones específicas?
+
En el caso de proyectos .NET, se pueden elegir versiones específicas de paquetes:
+
+
Navega a la pestaña del paquete deseado (por ejemplo, Newtonsoft.Json).
+
Escoge una versión con vulnerabilidades conocidas (como 12.0.3 en este ejemplo) para ver cómo Dependabot detecta y notifica el problema.
+
Dependabot genera un pull request automáticamente para actualizar la versión del paquete y solucionar la vulnerabilidad detectada.
+
+
¿Qué sucede cuando Dependabot detecta una vulnerabilidad?
+
Cuando Dependabot encuentra una vulnerabilidad:
+
+
Notifica con prioridad la versión insegura del paquete.
+
Crea un pull request para actualizar el paquete a una versión segura.
+
Permite revisar y aceptar la actualización directamente desde la sección de Security o en Pull Requests.
+
+
Dependabot analiza la compatibilidad de versiones para asegurar que la actualización sea estable y, en algunos casos, puede incluso eliminar la rama creada una vez fusionada la actualización.
+
¿Por qué integrar Dependabot en el flujo de trabajo?
+
Dependabot simplifica la gestión de actualizaciones:
+
+
Detecta y repara vulnerabilidades sin intervención manual.
+
Mantiene el proyecto actualizado con las versiones estables más recientes de cada dependencia.
+
Agiliza la revisión y aplicación de actualizaciones, evitando que el equipo trabaje con versiones obsoletas.
+
+
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/04-Configuraci\303\263n de Repositorios Privados en GitHub.mp4" "b/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/04-Configuraci\303\263n de Repositorios Privados en GitHub.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..700d3696d8dce6a4afdc9c75f239eb87b17bd163
--- /dev/null
+++ "b/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/04-Configuraci\303\263n de Repositorios Privados en GitHub.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b19baf07c21f7c35b197e41827425d1f0c72760c05d706bf78583e616b1319cc
+size 114042324
diff --git "a/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/04-Configuraci\303\263n de Repositorios Privados en GitHub.vtt" "b/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/04-Configuraci\303\263n de Repositorios Privados en GitHub.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..52aec949fe5d06047c0489bcfd8345f68c78d5ea
--- /dev/null
+++ "b/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/04-Configuraci\303\263n de Repositorios Privados en GitHub.vtt"
@@ -0,0 +1,1176 @@
+WEBVTT
+
+00:00.000 --> 00:03.080
+Ahora que ya hemos conocido tanto
+herramientas colaborativas
+
+00:03.080 --> 00:06.880
+como repositorios y un largo etcétera de
+GitHub,
+
+00:06.880 --> 00:10.680
+es momento de cuidar uno de los detalles
+más importantes,
+
+00:10.680 --> 00:13.180
+la seguridad de nuestros
+repositorios
+
+00:13.180 --> 00:16.280
+y, por ende, de todo nuestro código.
+
+00:16.280 --> 00:19.380
+Vamos a ver cómo tener dos mejores
+prácticas
+
+00:19.380 --> 00:22.380
+que te van a quitar muchísimos dolores de
+cabeza
+
+00:22.380 --> 00:25.380
+al momento de trabajar con todos sus
+proyectos de software
+
+00:25.380 --> 00:27.580
+dentro de tus repositorios en GitHub.
+
+00:27.580 --> 00:31.580
+La primera de las observaciones que debes
+de tener bien presente
+
+00:31.580 --> 00:34.580
+es el tipo de repositorio en el que estás
+trabajando.
+
+00:34.580 --> 00:38.080
+Todos los repositorios que hasta este
+momento en el curso
+
+00:38.080 --> 00:40.080
+hemos creado son
+públicos,
+
+00:40.080 --> 00:44.080
+es decir, básicamente cualquier persona
+que acceda a tu perfil
+
+00:44.080 --> 00:48.080
+puede acceder a tu repositorio y a tus
+avances de código.
+
+00:48.080 --> 00:50.080
+Esto es una excelente
+idea
+
+00:50.080 --> 00:53.080
+si quieres mostrarle al mundo todo tu trabajo.
+
+00:53.080 --> 00:56.080
+Sin embargo, si estás trabajando en un
+entorno
+
+00:56.080 --> 00:58.580
+en donde quieres mantener el
+código
+
+00:58.580 --> 01:01.080
+solo limitado a ciertas
+personas,
+
+01:01.080 --> 01:03.580
+tu repositorio debería de ser privado.
+
+01:03.580 --> 01:06.080
+En la pantalla, puedes darte
+cuenta
+
+01:06.080 --> 01:09.080
+que a la derecha de mi primer
+repo
+
+01:09.080 --> 01:11.580
+aparece la opción
+Public.
+
+01:11.580 --> 01:14.580
+Solo necesitas ir a
+Settings,
+
+01:16.580 --> 01:20.580
+desplazarte hasta abajo de la categoría
+General
+
+01:20.580 --> 01:22.580
+y seleccionar
+Privado.
+
+01:28.580 --> 01:32.580
+Y en la zona del peligro, que está de
+hecho en rojo,
+
+01:32.580 --> 01:36.580
+porque significa que estás tomando
+decisiones muy drásticas,
+
+01:36.580 --> 01:39.080
+puedes seleccionar la primera opción,
+
+01:39.080 --> 01:42.580
+que es cambiar la visibilidad de tu
+repositorio.
+
+01:42.580 --> 01:44.580
+Selecciona el
+botón
+
+01:44.580 --> 01:47.580
+y te va a dar la opción de cambiar a privado.
+
+01:47.580 --> 01:49.580
+Selecciona
+Confirmar
+
+01:49.580 --> 01:51.580
+y selecciona el botón de
+Confirmar
+
+01:51.580 --> 01:54.580
+para ver que estás completamente de
+acuerdo
+
+01:54.580 --> 01:56.580
+con lo que va a
+suceder.
+
+01:56.580 --> 02:00.580
+Selecciona el botón para confirmar que sí
+estás de acuerdo.
+
+02:00.580 --> 02:03.580
+Y una vez más, GitHub te va a
+decir
+
+02:03.580 --> 02:07.580
+ten cuidado, ¿es esto lo que
+verdaderamente quieres?
+
+02:07.580 --> 02:09.580
+Sí, sí lo quiero hacer
+privado.
+
+02:09.580 --> 02:11.580
+Ojo, dentro de todas estas
+preguntas
+
+02:11.580 --> 02:15.580
+te menciono que si tu repositorio ya tenía
+algunas estrellas
+
+02:15.580 --> 02:17.580
+y que estás
+observándolo,
+
+02:17.580 --> 02:20.580
+estas se van a desvanecer al momento de
+hacerse privado.
+
+02:20.580 --> 02:23.580
+Si tú regresas al repositorio, Mi primer repo,
+
+02:23.580 --> 02:27.580
+ahora aparece la categoría de Private y
+más importante,
+
+02:27.580 --> 02:30.580
+hay un pequeño candadito desde aquí
+arriba
+
+02:30.580 --> 02:33.580
+indicando que el repositorio ahora es
+inaccesible
+
+02:33.580 --> 02:35.580
+para todos los
+demás.
+
+02:35.580 --> 02:38.580
+Ya que tenemos el primer tip de
+seguridad
+
+02:38.580 --> 02:41.580
+para poder evitar que todo el mundo vea
+los proyectos
+
+02:41.580 --> 02:43.580
+en los que yo quiero
+trabajar,
+
+02:43.580 --> 02:46.580
+pero que solo mi equipo debe
+ver,
+
+02:46.580 --> 02:49.580
+entonces vamos por la segunda
+práctica
+
+02:49.580 --> 02:51.580
+y esta es una práctica
+preventiva,
+
+02:51.580 --> 02:54.580
+pero muy, muy
+útil.
+
+02:54.580 --> 02:58.580
+Lo primero que yo necesito es regresar con
+mi primer repo
+
+02:58.580 --> 03:00.580
+desde Visual Studio
+Code.
+
+03:00.580 --> 03:03.580
+Con mi terminal abierta, lo primero que
+necesito hacer
+
+03:03.580 --> 03:05.580
+es jalar todos los
+cambios
+
+03:05.580 --> 03:08.580
+que he estado haciendo dentro de este
+repositorio.
+
+03:08.580 --> 03:10.580
+Para ello, primero voy a escribir git
+branch
+
+03:10.580 --> 03:13.580
+para saber que me encuentro en la rama
+principal.
+
+03:13.580 --> 03:16.580
+Me doy cuenta que aún mi terminal
+permanece
+
+03:16.580 --> 03:18.580
+con una rama de
+developer01,
+
+03:18.580 --> 03:24.580
+así que escribiré git switch y main.
+
+03:24.580 --> 03:29.580
+Me muevo a main, confirmo otra vez que ya
+estoy en main
+
+03:29.580 --> 03:32.580
+y ahora sí escribo git
+pull.
+
+03:32.580 --> 03:35.580
+Curiosamente, ahora la
+terminal,
+
+03:35.580 --> 03:39.580
+como sabe que mi primer repo no está
+disponible,
+
+03:39.580 --> 03:41.580
+me pide
+validarme.
+
+03:41.580 --> 03:43.580
+Entonces aquí está mi nombre de
+usuario
+
+03:43.580 --> 03:45.580
+que es con el que he estado
+trabajando
+
+03:45.580 --> 03:48.580
+y descarga los datos sin ningún problema.
+
+03:48.580 --> 03:50.580
+Bastante información,
+parece.
+
+03:50.580 --> 03:54.580
+Bueno, en fin, ya que tengo toda esta
+información,
+
+03:54.580 --> 03:57.580
+escribo code espacio punto para
+abrir
+
+03:57.580 --> 04:00.580
+una nueva instancia de Visual Studio
+Code
+
+04:00.580 --> 04:03.580
+desde este repositorio
+nuevo.
+
+04:03.580 --> 04:05.580
+Ahora que ya estoy en Visual Studio
+Code
+
+04:05.580 --> 04:07.580
+con este
+repositorio,
+
+04:07.580 --> 04:09.580
+puedo cerrar la pestaña de
+inicio
+
+04:09.580 --> 04:13.580
+y agregar un archivo en la raíz de mi
+proyecto.
+
+04:13.580 --> 04:18.580
+Este archivo se va a llamar.gitignore.
+
+04:18.580 --> 04:21.580
+Y este archivo lo que va a hacer es
+que
+
+04:21.580 --> 04:24.580
+todos los archivos que correspondan con
+patrones
+
+04:24.580 --> 04:26.580
+que yo ponga
+aquí,
+
+04:26.580 --> 04:29.580
+están vetados de ser subidos al repositorio.
+
+04:29.580 --> 04:32.580
+Es decir, si yo, por
+ejemplo,
+
+04:32.580 --> 04:38.580
+supongo que el archivo sln de mi primer repo.
+generated,
+
+04:38.580 --> 04:40.580
+que no quiero tener en el
+repositorio
+
+04:40.580 --> 04:42.580
+porque Visual Studio Code lo
+crea
+
+04:42.580 --> 04:45.580
+cada vez que detecta un proyecto de.
+net,
+
+04:45.580 --> 04:48.580
+entonces puedo agregarlo
+aquí.
+
+04:48.580 --> 04:51.580
+Así puedo ir agregando todos los archivos
+que yo quiera.
+
+04:51.580 --> 04:57.580
+Por ejemplo, escribir asterisco.sln.
+
+04:57.580 --> 05:00.580
+Cuando yo agregué esa
+extensión,
+
+05:00.580 --> 05:03.580
+la
+extensión.sln,
+
+05:03.580 --> 05:05.580
+gitignore se pone en
+verde
+
+05:05.580 --> 05:09.580
+porque es un archivo que sí voy a subir a
+mi repositorio.
+
+05:09.580 --> 05:15.580
+Sin embargo, el de mi primer repo.generated.
+sln,
+
+05:15.580 --> 05:18.580
+solo por la extensión que
+tiene,
+
+05:18.580 --> 05:21.580
+ya no va a ir al
+repositorio.
+
+05:21.580 --> 05:24.580
+Ahora, si expando proyecto
+1,
+
+05:24.580 --> 05:26.580
+me daré cuenta que hay
+carpetas
+
+05:26.580 --> 05:28.580
+que realmente no
+necesito.
+
+05:28.580 --> 05:31.580
+Las carpetas de compilación del proyecto,
+
+05:31.580 --> 05:34.580
+como por ejemplo, bin y
+obj.
+
+05:34.580 --> 05:36.580
+Si te diste cuenta en la
+terminal,
+
+05:36.580 --> 05:40.580
+aquí aparecen bin y obj con un montón de
+archivos
+
+05:40.580 --> 05:43.580
+que ni siquiera uso para poder escribir
+código
+
+05:43.580 --> 05:45.580
+dentro de los proyectos
+de.net.
+
+05:45.580 --> 05:49.580
+Así sucede con los proyectos de Node,
+de Python, de PHP,
+
+05:49.580 --> 05:51.580
+de Go, de Rust, el que
+sea.
+
+05:51.580 --> 05:53.580
+Todos tienen un montón de
+archivos
+
+05:53.580 --> 05:56.580
+que no necesitamos para poder trabajar en
+el proyecto.
+
+05:56.580 --> 05:59.580
+Significa que puedo regresar
+a.gitignore
+
+05:59.580 --> 06:02.580
+y agregar todas estas
+ubicaciones.
+
+06:02.580 --> 06:05.580
+Primero puedo comenzar por eliminar esas
+carpetas
+
+06:05.580 --> 06:07.580
+porque ya no las voy a
+ocupar.
+
+06:07.580 --> 06:11.580
+Clic derecho y eliminar permanentemente.
+
+06:12.580 --> 06:17.580
+Obj, lo mismo, clic derecho y eliminar
+permanentemente.
+
+06:19.580 --> 06:21.580
+Esto lo puedes hacer, por
+ejemplo,
+
+06:21.580 --> 06:23.580
+dentro de Node o dentro de
+JavaScript
+
+06:23.580 --> 06:26.580
+con las carpetas de los paquetes
+npm
+
+06:26.580 --> 06:28.580
+que has estado
+descargando.
+
+06:28.580 --> 06:32.580
+De todas maneras, al momento de reiniciar
+tu proyecto,
+
+06:32.580 --> 06:35.580
+si es necesario, estas carpetas se van a
+crear
+
+06:35.580 --> 06:37.580
+como pasaría con estas dos
+carpetas
+
+06:37.580 --> 06:39.580
+dentro de los proyectos
+de.net.
+
+06:39.580 --> 06:43.580
+Ahora yo puedo agregar aquí la ubicación.
+bin
+
+06:43.580 --> 06:47.580
+o más bien diagonal bin y diagonal
+obj
+
+06:47.580 --> 06:49.580
+para evitar que esas
+carpetas
+
+06:49.580 --> 06:52.580
+vuelvan a subirse a los repositorios.
+
+06:52.580 --> 06:55.580
+Solo que saber ese nivel de
+detalle
+
+06:55.580 --> 06:59.580
+de cada lenguaje de programación y de cada
+tecnología
+
+06:59.580 --> 07:01.580
+es demasiado
+complicado.
+
+07:01.580 --> 07:04.580
+Además, que si tienes tan mala memoria
+como yo,
+
+07:04.580 --> 07:07.580
+también va a ser muy complicado
+recordar
+
+07:07.580 --> 07:10.580
+cuáles son las ubicaciones que necesitamos.
+
+07:10.580 --> 07:12.580
+Para ello, en los recursos de esta
+clase
+
+07:12.580 --> 07:14.580
+te estoy colocando una
+dirección
+
+07:14.580 --> 07:17.580
+en donde GitHub pone a tu
+disposición
+
+07:17.580 --> 07:22.580
+una colección gigantesca de repositorios
+gitignore.
+
+07:22.580 --> 07:24.580
+Entra a la dirección y te vas a dar
+cuenta
+
+07:24.580 --> 07:27.580
+que es un repositorio que se llama
+gitignore
+
+07:27.580 --> 07:31.580
+dentro de la organización de GitHub.
+
+07:31.580 --> 07:36.580
+Este repositorio lo que hace es tener un
+acervo enorme
+
+07:36.580 --> 07:39.580
+de todos los archivos gitignore que
+podrías necesitar.
+
+07:39.580 --> 07:42.580
+Por ejemplo, si yo presiono control F para
+buscar,
+
+07:42.580 --> 07:45.580
+aquí está una opción de
+nodes.
+
+07:45.580 --> 07:48.580
+Puedes irte a
+nodes.gitignore
+
+07:48.580 --> 07:51.580
+y vienen todas las opciones de los
+archivos
+
+07:51.580 --> 07:55.580
+que podrías evitar subir a un repositorio
+de nodes.
+
+07:55.580 --> 07:58.580
+Así, puedes encontrar cualquiera de todas
+las opciones.
+
+07:58.580 --> 08:01.580
+Vamos a buscar aquí
+Python
+
+08:01.580 --> 08:04.580
+y dentro de el gitignore de
+Python
+
+08:04.580 --> 08:07.580
+vienen todos los archivos que
+probablemente
+
+08:07.580 --> 08:10.580
+no quieras subir en tu
+repositorio
+
+08:10.580 --> 08:13.580
+porque son archivos de bibliotecas de clases,
+
+08:13.580 --> 08:16.580
+de modificación o de
+caché.
+
+08:16.580 --> 08:20.580
+De esta manera, para el proyecto que yo
+tengo en mi primer repo,
+
+08:20.580 --> 08:23.580
+lo que voy a hacer es regresar aquí,
+
+08:23.580 --> 08:26.580
+borrar y volver a abrir la
+búsqueda
+
+08:26.580 --> 08:29.580
+para escribir Visual
+Studio.
+
+08:29.580 --> 08:33.580
+Ya sé, el gitignore
+de.net
+
+08:33.580 --> 08:38.580
+no es.net, es visualstudio.gitignore.
+
+08:38.580 --> 08:41.580
+No me pregunten, alguien lo hizo de esa
+manera.
+
+08:41.580 --> 08:44.580
+Lo que importa es el contenido de este
+gitignore.
+
+08:44.580 --> 08:48.580
+Puedo simplemente seleccionar las partes
+que más me interesan
+
+08:48.580 --> 08:51.580
+o, si es necesario,
+desplazarme
+
+08:51.580 --> 08:54.580
+y ver todo el contenido de este gitignore.
+
+08:54.580 --> 08:57.580
+Puede ser, por ejemplo, para eliminar
+pruebas unitarias
+
+08:57.580 --> 09:00.580
+o para eliminar pruebas de ciertos frameworks,
+etc.
+
+09:00.580 --> 09:03.580
+Mira una parte
+importante.
+
+09:03.580 --> 09:08.580
+En la línea 30 puedes ver que la B está
+con mayúscula y minúscula
+
+09:08.580 --> 09:12.580
+para la carpeta que yo ya eliminé de mi repo,
+la de BIN.
+
+09:12.580 --> 09:16.580
+El gitignore hace exactamente lo mismo con
+obj.
+
+09:16.580 --> 09:20.580
+Y si te das cuenta, la diagonal yo la puse
+al principio,
+
+09:20.580 --> 09:22.580
+cuando va al
+final.
+
+09:22.580 --> 09:27.580
+De esta manera, insisto, no necesitas
+recordar cada detalle
+
+09:27.580 --> 09:29.580
+por agregar en tu archivo gitignore,
+
+09:29.580 --> 09:33.580
+sino que simplemente puedes guardar este
+repositorio
+
+09:33.580 --> 09:36.580
+y tenerlo como referencia para cuando
+estés trabajando
+
+09:36.580 --> 09:39.580
+en el proyecto con la tecnología que tú
+quieras.
+
+09:39.580 --> 09:43.580
+Lo que ahora voy a hacer es primero cerrar
+mi barra de búsqueda
+
+09:43.580 --> 09:46.580
+y después seleccionar el botón
+Raw.
+
+09:47.580 --> 09:51.580
+El botón Raw lo que hace es darme esa
+lista
+
+09:51.580 --> 09:53.580
+en un espacio de texto
+simple.
+
+09:53.580 --> 09:58.580
+Lo selecciono todo, lo copio y regreso a
+Visual Studio
+
+09:58.580 --> 10:02.580
+en donde puedo eliminar todas estas
+posibilidades.
+
+10:02.580 --> 10:04.580
+Ahí está, todo
+cubierto.
+
+10:04.580 --> 10:09.580
+Sin embargo, recuerda que yo quería que el
+archivo sln
+
+10:09.580 --> 10:10.580
+no se
+subiera.
+
+10:10.580 --> 10:13.580
+Y mira, curiosamente es el de la última línea.
+
+10:13.580 --> 10:19.580
+Solo borro esta extensión y ese archivo
+sln va a quedar listo,
+
+10:19.580 --> 10:21.580
+eliminado.
+
+10:21.580 --> 10:23.580
+De esta manera, tú puedes saber que
+sí
+
+10:23.580 --> 10:26.580
+y que no quieres subir a tus repositorios.
+
+10:26.580 --> 10:29.580
+Y ahora vamos a encontrar la razón más
+importante
+
+10:29.580 --> 10:31.580
+de por qué debemos hacer
+esto.
+
+10:31.580 --> 10:34.580
+Dentro de la carpeta de
+probando,
+
+10:34.580 --> 10:37.580
+que es en donde está el proyecto de.
+NET que utilicé,
+
+10:37.580 --> 10:43.580
+necesito crear un archivo llamado appsettings.
+json.
+
+10:43.580 --> 10:49.580
+Este archivo es el equivalente a un archivo.
+env de Node
+
+10:49.580 --> 10:51.580
+o de Python o hasta de
+Java,
+
+10:51.580 --> 10:54.580
+en donde yo puedo guardar ciertas
+credenciales de productos
+
+10:54.580 --> 10:59.580
+o de llaves o conexiones a, no sé, una
+base de datos,
+
+10:59.580 --> 11:01.580
+cualquier sistema de
+configuración,
+
+11:01.580 --> 11:04.580
+lo tengo que poner dentro de estos archivos.
+
+11:04.580 --> 11:06.580
+En este archivo de
+appsettings,
+
+11:06.580 --> 11:08.580
+yo voy a agregar algo de
+contenido,
+
+11:08.580 --> 11:10.580
+pero para evitar
+escribir,
+
+11:10.580 --> 11:13.580
+está mi ventana de chat de
+Copilot.
+
+11:13.580 --> 11:17.580
+Si no estás familiarizado con Copilot
+dentro de VS Code
+
+11:17.580 --> 11:18.580
+o con Copilot en
+general,
+
+11:18.580 --> 11:22.580
+te recomendaría que visites el curso que
+tenemos aquí en Platzi
+
+11:22.580 --> 11:26.580
+de Copilot para saber de qué va esta
+maravillosa herramienta.
+
+11:26.580 --> 11:29.580
+Por ahora, dentro de mi texto, yo voy a
+poner
+
+11:29.580 --> 11:34.580
+Agrega una simulación
+de...
+
+11:34.580 --> 11:36.580
+Se me fue una
+letra...
+
+11:36.580 --> 11:38.580
+de cadena de
+conexión.
+
+11:41.580 --> 11:44.580
+Espero mi respuesta, y ya que tengo mi
+respuesta,
+
+11:44.580 --> 11:46.580
+agrego esa parte de
+código.
+
+11:46.580 --> 11:50.580
+Aquí, en un mundo en donde yo estoy
+conectándome
+
+11:50.580 --> 11:53.580
+con mi proyecto a una base de datos,
+
+11:53.580 --> 11:56.580
+aquí en
+appsettings.json
+
+11:56.580 --> 11:58.580
+debería poner la cadena de conexión,
+
+11:58.580 --> 12:02.580
+una cadena de conexión que naturalmente no
+quiero
+
+12:02.580 --> 12:04.580
+que se vaya a mi
+repositorio.
+
+12:04.580 --> 12:08.580
+Ya que está este archivo de appsettings.
+json,
+
+12:08.580 --> 12:11.580
+puedo regresar a mi archivo gitignore.
+
+12:11.580 --> 12:14.580
+Me desplazo un par de líneas hacia
+abajo
+
+12:14.580 --> 12:18.580
+y escribo
+appsettings.json.
+
+12:18.580 --> 12:22.580
+Lo ideal, así como el archivo gitignore me
+lo está sugiriendo,
+
+12:22.580 --> 12:25.580
+es poner algún comentario que
+diga
+
+12:25.580 --> 12:30.580
+Elimina este archivo de configuración.
+
+12:30.580 --> 12:33.580
+Así ya solamente sabré qué es lo que estoy
+haciendo
+
+12:33.580 --> 12:34.580
+con esta
+línea.
+
+12:34.580 --> 12:38.580
+Y ahora que lo agregaste, appsettings se
+opacó,
+
+12:38.580 --> 12:41.580
+exactamente igual que mi primer
+repo
+
+12:41.580 --> 12:44.580
+con la extensión
+SLN.
+
+12:44.580 --> 12:47.580
+Esto visualmente te indica que esos
+archivos
+
+12:47.580 --> 12:51.580
+no van a subirse dentro del commit y el
+push
+
+12:51.580 --> 12:52.580
+que tú
+realices.
+
+12:52.580 --> 12:55.580
+Voy a regresar a mi
+terminal,
+
+12:55.580 --> 12:59.580
+limpiar la pantalla y escribir git status.
+
+13:01.580 --> 13:05.580
+Aquí vienen todas las cosas que yo
+eliminé
+
+13:05.580 --> 13:09.580
+y el archivo.gitignore que yo quiero subir.
+
+13:09.580 --> 13:13.580
+Si yo hubiera tenido algún fallo en subir
+los archivos
+
+13:13.580 --> 13:16.580
+que no quiero, aquí
+aparecerían.
+
+13:16.580 --> 13:21.580
+Entonces pongo git add, git
+commit,
+
+13:21.580 --> 13:23.580
+con un mensaje que
+diga
+
+13:23.580 --> 13:27.580
+Nuevo gitignore
+creado.
+
+13:30.580 --> 13:34.580
+Ahora que esto está todo listo, escribo
+git push
+
+13:34.580 --> 13:37.580
+y naturalmente, como
+recordarás,
+
+13:37.580 --> 13:39.580
+se trata de un repositorio
+privado
+
+13:39.580 --> 13:42.580
+al cual yo necesito
+indicarle
+
+13:42.580 --> 13:46.580
+que tengo acceso a mi
+terminal.
+
+13:46.580 --> 13:48.580
+Estos datos se
+suben.
+
+13:48.580 --> 13:50.580
+Y ya que estos datos se
+subieron,
+
+13:50.580 --> 13:52.580
+puedo primero limpiar mi
+terminal
+
+13:52.580 --> 13:55.580
+y después volver a mi
+repositorio.
+
+13:55.580 --> 13:57.580
+En el sitio de mi
+repositorio,
+
+13:57.580 --> 14:01.580
+primero voy a refrescar la página para ver
+los cambios
+
+14:01.580 --> 14:04.580
+y aquí aparece ya el archivo gitignore.
+
+14:04.580 --> 14:07.580
+Dice que ahora estos cambios fueron
+realizados.
+
+14:07.580 --> 14:11.580
+Significa que si yo me muevo hacia probando,
+
+14:11.580 --> 14:13.580
+voy a ver que no hay
+nada.
+
+14:13.580 --> 14:16.580
+Para confirmar que no hay una carpeta
+bin
+
+14:16.580 --> 14:19.580
+y no hay una carpeta
+obj
+
+14:19.580 --> 14:23.580
+y tampoco hay un archivo de appsettings.json.
+
+14:23.580 --> 14:25.580
+Como podrás ver, hasta
+ahora,
+
+14:25.580 --> 14:28.580
+en mi repositorio llamado mi primer repo,
+
+14:28.580 --> 14:30.580
+pude solucionar las
+cosas.
+
+14:30.580 --> 14:33.580
+Es decir, agregar un archivo gitignore,
+
+14:33.580 --> 14:36.580
+eliminar manualmente los archivos que no
+quería
+
+14:36.580 --> 14:39.580
+y omitir appsettings y cosas por el estilo.
+
+14:39.580 --> 14:42.580
+La única manera de hacer este
+proceso
+
+14:42.580 --> 14:45.580
+es cuando tú estás creando un repositorio.
+
+14:45.580 --> 14:48.580
+Es decir, si tú seleccionas el signo de
+más
+
+14:48.580 --> 14:50.580
+y creas un nuevo
+repositorio,
+
+14:50.580 --> 14:52.580
+primero puedes ponerle
+aquí
+
+14:52.580 --> 14:55.580
+el nombre del repositorio que tú quieras.
+
+14:55.580 --> 14:57.580
+Después seleccionar el
+owner
+
+14:57.580 --> 15:00.580
+y un poco más abajo puedes
+seleccionar
+
+15:00.580 --> 15:02.580
+tu repositorio como
+privado
+
+15:02.580 --> 15:04.580
+para omitir el proceso que
+hicimos
+
+15:04.580 --> 15:06.580
+al principio de esta
+clase.
+
+15:06.580 --> 15:09.580
+Si te desplazas un poco más
+abajo,
+
+15:09.580 --> 15:12.580
+aquí está la categoría de agregar.gitignore.
+
+15:12.580 --> 15:16.580
+¿Recuerdas que yo busqué el gitignore de
+Visual Studio?
+
+15:16.580 --> 15:18.580
+Bueno, aquí lo puedo buscar
+así,
+
+15:18.580 --> 15:21.580
+Visual Studio, y va a
+aparecer.
+
+15:21.580 --> 15:24.580
+De la misma manera que busqué los
+gitignore
+
+15:24.580 --> 15:26.580
+tanto de Node como de
+Python.
+
+15:26.580 --> 15:29.580
+Es decir, antes de crear tu repositorio,
+
+15:29.580 --> 15:31.580
+tú tienes la oportunidad de
+agregar
+
+15:31.580 --> 15:34.580
+el archivo.gitignore que vas a
+utilizar
+
+15:34.580 --> 15:37.580
+para el lenguaje o lenguajes de
+programación
+
+15:37.580 --> 15:39.580
+dentro de ese
+repositorio,
+
+15:39.580 --> 15:41.580
+eliminándote así un dolor de
+cabeza
+
+15:41.580 --> 16:04.580
+para tener que hacerlo en un proceso
+posterior.
+
diff --git "a/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/04-Lecturas recomendadas.txt" "b/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/04-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..8a908de300b20867d25e93874c199a2c90f6e755
--- /dev/null
+++ "b/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/04-Lecturas recomendadas.txt"
@@ -0,0 +1,3 @@
+https://github.com/github/gitignore
+https://docs.github.com/en/get-started/getting-started-with-git/ignoring-files
+https://platzi.com/cursos/github-copilot/
diff --git "a/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/04-Resumen.html" "b/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/04-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..be7e87279f779eb675142dacd99cbc9ea34d2311
--- /dev/null
+++ "b/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/04-Resumen.html"
@@ -0,0 +1,121 @@
+
+
+
+
+
+
+ Configuración de Repositorios Privados en GitHub
+
+
+
+
+
+
Resumen
¿Cómo configurar un repositorio privado y excluir archivos innecesarios en Git?
+
Cuando creas un repositorio en Git, es crucial asegurarte de que esté configurado correctamente desde el principio. Saber cómo mantener ciertas configuraciones básicas te ayudará a proteger tu trabajo y a evitar problemas en el futuro. Aquí te muestro algunos pasos clave para un proceso de configuración efectivo y eficiente.
+
¿Cómo se hace privado un repositorio?
+
Primero, crear un repositorio privado es vital para mantener la confidencialidad de tu proyecto. Esto garantiza que solo las personas a las que les has dado acceso puedan ver y modificar tus archivos. Para establecer tu repositorio como privado, sigue estos pasos:
+
+
Ve a la sección "Settings" de tu repositorio.
+
Busca la categoría relacionada con la privacidad del repositorio y selecciona la opción para hacerlo privado.
+
Recuerda que este ajuste puede requerir permisos administrativos, dependiendo del entorno donde trabajes.
+
+
¿Qué es un archivo .gitignore y por qué es importante?
+
El archivo .gitignore es esencial para omitir archivos innecesarios o sensibles que no necesitan ser rastreados por Git. Esto puede incluir archivos temporales generados por tu entorno de desarrollo, configuraciones locales o archivos de gran tamaño que no deberían estar en tu repositorio.
+
Creación de un archivo .gitignore:
+
+
Antes de crear tu repositorio, busca ejemplos de .gitignore que se adapten a tus necesidades específicas de desarrollo (por ejemplo, para Visual Studio, Node o Python).
+
Añade estas configuraciones a tu archivo .gitignore para asegurarte de que se excluyan los archivos que no deseas en el control de versiones.
+
Si utilizas Visual Studio, puedes buscar específicamente el archivo VisualStudio.gitignore para simplificar este proceso.
+
+
¿Cuál es el beneficio de configurar correctamente el archivo inicial de tu proyecto?
+
Configurar apropiadamente el archivo inicial de tu proyecto no solo previene la inclusión de archivos innecesarios, sino que también facilita la colaboración con otros desarrolladores. A continuación, algunos beneficios:
+
+
Organización y limpieza: Ayuda a mantener un entorno de desarrollo organizado y limpio al excluir archivos que no son relevantes para todos los colaboradores.
+
Rendimiento: Mejora el rendimiento reduciendo el tamaño del repositorio eliminando archivos grandes o inservibles.
+
Protección de información sensible: Previene la inclusión accidental de información sensible o confidencial, como claves API o contraseñas, en el repositorio.
+
+
Crear un archivo inicial bien configurado y establecer tu repositorio como privado son pasos críticos que construyen una base sólida para el desarrollo de software colaborativo y seguro. Recuerda revisar regularmente estas configuraciones conforme tu proyecto evoluciona y adoptar buenas prácticas para un desarrollo eficaz.
+
+
Al seguir estas directrices puedes asegurarte de que tu repositorio esté adecuado para el trabajo en equipo y la colaboración, mientras proteges tu información confidencial y mantienes tu código organizado. ¡El camino al éxito en el desarrollo de software comienza con una sólida configuración inicial!
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/05-Quiz.mhtml" "b/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/05-Quiz.mhtml"
new file mode 100644
index 0000000000000000000000000000000000000000..1156d5d60a1036cac5aa16ea2a8630ab4c8b69c8
--- /dev/null
+++ "b/Curso de Git y GitHub/05-Seguridad y buenas pr\303\241cticas en GitHub/05-Quiz.mhtml"
@@ -0,0 +1,13243 @@
+From:
+Snapshot-Content-Location: https://platzi.com/clases/quiz/21262/
+Subject:
+Date: Sat, 8 Nov 2025 17:34:58 -0500
+MIME-Version: 1.0
+Content-Type: multipart/related;
+ type="text/html";
+ boundary="----MultipartBoundary--YCsJQ8eeIoCdgQ10pBWdbDKsFpbca2nDjkF16qNofh----"
+
+
+------MultipartBoundary--YCsJQ8eeIoCdgQ10pBWdbDKsFpbca2nDjkF16qNofh----
+Content-Type: text/html
+Content-ID:
+Content-Transfer-Encoding: quoted-printable
+Content-Location: https://platzi.com/clases/quiz/21262/
+
+
+ =20
+
+ =20
+
+
+
+
+
+
+
+
+
+
+
+ =20
+
+ =20
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ =20
+ =20
+ =20
+
+ =20
+
+ =20
+
+
+ =20
+
+ =20
+
+
+
+ =20
+
+
+ =20
+ =20
+ =20
+
+
+
¿Cómo configurar los ajustes esenciales en GitHub?
+
Al ingresar al mundo del desarrollo, especialmente en plataformas colaborativas como GitHub, es crucial establecer configuraciones adecuadas. Esto no solo optimiza tu flujo de trabajo, sino que también asegura que estés aprovechando al máximo las funcionalidades que ofrece GitHub. Vamos a desglosar cómo puedes configurar los ajustes vitales para maximizar tu experiencia de desarrollo.
+
¿Cómo gestionar los repositorios públicos y privados?
+
Un aspecto esencial de la configuración de GitHub es decidir si quieres que tus repositorios sean públicos o privados. Veamos las diferencias y cómo gestionarlos:
+
+
Repositorios Públicos: Por defecto, estos están habilitados. Permiten que cualquiera vea y contribuya, lo que es ideal para proyectos de código abierto.
+
Repositorios Privados: Son perfectos para mantener tu trabajo confidencial. Puedes decidir si otras personas pueden acceder y clonar estos repositorios.
+
+
Al ajustar estas configuraciones, es importante considerar la privacidad de tu código y colaboración. Habilitar la opción de que los demás puedan “fork” o bifurcar tus repositorios privados depende del nivel de colaboración que desees.
+
¿Cómo realizar un pull request exitoso?
+
El pull request es una herramienta fundamental en GitHub, ya que permite que las contribuciones de otros desarrolladores sean revisadas e integradas en el proyecto principal. Aquí te dejo algunos pasos para realizar uno exitosamente:
+
+
Crea una rama en tu repositorio para hacer cambios.
+
Realiza commits significativos y claros sobre tus cambios.
+
Abre un pull request en el repositorio original.
+
Escribe un mensaje claro explicando lo que has hecho y por qué es importante.
+
Solicita revisiones de tus colaboradores para asegurarte de que los cambios son precisos.
+
+
Un buen pull request no solo mejora el proyecto, sino que también puede convertirte en un colaborador valioso en tu comunidad de desarrollo.
+
¿Qué es un Profile Readme y por qué es importante?
+
El Profile Readme es como tu carta de presentación en GitHub. Este archivo se muestra en la parte superior de tu perfil y puede incluir:
+
+
Información personal profesional: como quién eres, en qué trabajas, y cuáles son tus habilidades.
+
Proyectos destacados: que desees compartir con la comunidad.
+
Enlaces a redes sociales y otros proyectos: para construir una red más amplia.
+
+
Crear un atractivo Profile Readme puede ayudarte a destacarte en el mundo de la programación y atraer a más colaboradores o incluso empleadores potenciales.
+
¿Cómo colaborar eficazmente con equipos en GitHub?
+
Colaborar en equipo es una parte fundamental para cualquier desarrollador que usa GitHub. Aquí hay algunos consejos para asegurarte de que tu colaboración sea efectiva:
+
+
Comunicación clara: Mantén siempre una comunicación clara y abierta con tus colaboradores. Las herramientas integradas de GitHub, como comentarios en los issues y pull requests, son fundamentales.
+
Utiliza las “issues”: para documentar tareas y bugs, asegurando un flujo de trabajo estructurado.
+
Proyectos y tableros: Para organizar tareas y hacer seguimiento de los progresos.
+
+
Garantizar una colaboración fluida y organizada no solo optimiza el trabajo en equipo, sino que también puede impulsar el éxito de los proyectos.
+
Desarrollar estas competencias y configuraciones en GitHub no solo mejorará tu eficiencia y eficacia como desarrollador, sino que también te brindará una comprensión más profunda y una presencia sólida en la comunidad de desarrolladores. ¡Continúa explorando, aprendiendo y participando en esta increíble plataforma!
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/06-Administraci\303\263n de GitHub/02-Automatizaci\303\263n de GitHub Actions para Actualizar Perfil.mp4" "b/Curso de Git y GitHub/06-Administraci\303\263n de GitHub/02-Automatizaci\303\263n de GitHub Actions para Actualizar Perfil.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..45b42a169d76279c1fc3c9bcda6214946ec43a1c
--- /dev/null
+++ "b/Curso de Git y GitHub/06-Administraci\303\263n de GitHub/02-Automatizaci\303\263n de GitHub Actions para Actualizar Perfil.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f071789eda6965a93275f59dd01904c11b27c0289318743d74ebb5c16f58a84
+size 103995135
diff --git "a/Curso de Git y GitHub/06-Administraci\303\263n de GitHub/02-Automatizaci\303\263n de GitHub Actions para Actualizar Perfil.vtt" "b/Curso de Git y GitHub/06-Administraci\303\263n de GitHub/02-Automatizaci\303\263n de GitHub Actions para Actualizar Perfil.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..0717109c762e67f32e3a8ce2f2d4bb876433ad51
--- /dev/null
+++ "b/Curso de Git y GitHub/06-Administraci\303\263n de GitHub/02-Automatizaci\303\263n de GitHub Actions para Actualizar Perfil.vtt"
@@ -0,0 +1,915 @@
+WEBVTT
+
+00:00.000 --> 00:03.000
+Yo voy a seguir insistiendo con el tiempo
+que has invertido
+
+00:03.000 --> 00:05.800
+en mejorar tu perfil personal de GitHub.
+
+00:05.800 --> 00:08.600
+Ya avanzaste, ya pusiste más iconitos,
+
+00:08.600 --> 00:10.800
+ya pusiste tus enlaces
+sociales.
+
+00:10.800 --> 00:13.800
+Ahora vamos a comenzar a hacer un pequeño tip.
+
+00:13.800 --> 00:16.800
+Las GitHub Actions son la herramienta de
+GitHub
+
+00:16.800 --> 00:19.800
+que te permite automatizar varios procesos.
+
+00:19.800 --> 00:23.300
+Ya en algunas clases nos hemos topado con
+algunas de ellas.
+
+00:23.300 --> 00:25.500
+Por ejemplo, para que el
+Dependabot
+
+00:25.500 --> 00:29.800
+haga una revisión esporádica, en nuestro
+caso fue diaria,
+
+00:29.800 --> 00:33.800
+de todos los paquetes que utilizamos y
+otros casos más.
+
+00:33.800 --> 00:37.800
+En el caso de ahora, lo que vamos a hacer
+con una GitHub Action
+
+00:37.800 --> 00:41.300
+es jalar nuestra actividad más reciente de
+GitHub
+
+00:41.300 --> 00:44.300
+y ponerla en nuestra portada de perfil.
+
+00:44.300 --> 00:46.800
+Te muestro lo que queremos
+lograr.
+
+00:46.800 --> 00:50.300
+En mi perfil de GitHub, si te desplazas un
+poquito para abajo,
+
+00:50.300 --> 00:53.300
+aquí aparece Actividad
+reciente.
+
+00:53.300 --> 00:56.300
+Y no es ninguna sorpresa que toda esa
+actividad
+
+00:56.300 --> 01:00.300
+está ahorita dentro de mi primer repo y
+los repositorios
+
+01:00.300 --> 01:03.800
+que he estado utilizando dentro de este curso.
+
+01:03.800 --> 01:06.800
+Vamos a hacer exactamente este
+contenido
+
+01:06.800 --> 01:09.300
+dentro de tu perfil de
+GitHub.
+
+01:09.300 --> 01:11.800
+Voy a desplazarme un poco para
+arriba
+
+01:11.800 --> 01:15.800
+y seleccionar en los repositorios el
+repositorio
+
+01:15.800 --> 01:19.300
+con el nombre de usuario que estás
+utilizando para GitHub,
+
+01:19.300 --> 01:23.300
+es decir, el repositorio de portada,
+por decirlo de alguna manera.
+
+01:23.300 --> 01:26.800
+El que ya hemos utilizado para insertar en
+el README
+
+01:26.800 --> 01:28.800
+algunos de estos
+datos.
+
+01:28.800 --> 01:32.300
+Ahora voy a seleccionar el icono de
+Editar
+
+01:32.300 --> 01:37.300
+o puedo presionar el punto para tener el
+editor en línea de GitHub.
+
+01:37.300 --> 01:41.300
+Cierra la pestaña del README y vuelve a
+abrir ese archivo
+
+01:41.300 --> 01:44.300
+para que te aparezca en la versión nativa,
+
+01:44.300 --> 01:46.800
+no en la versión de vista
+previa.
+
+01:46.800 --> 01:50.800
+Aquí elimino esta parte porque la tenía
+previamente puesta,
+
+01:50.800 --> 01:54.800
+pero lo que necesito pegar es un fragmento
+de código
+
+01:54.800 --> 01:58.300
+que de hecho está dentro de los recursos
+de esta clase
+
+01:58.300 --> 02:00.300
+como un archivo
+Markdown.
+
+02:00.300 --> 02:04.800
+Voy a hacer un pequeño zoom para poder ver
+bien qué fue lo que hice.
+
+02:04.800 --> 02:07.300
+Creo que este zoom es
+suficiente.
+
+02:07.300 --> 02:08.800
+Y aquí
+está.
+
+02:08.800 --> 02:13.300
+Solamente estoy poniendo un comentario tipo,
+no sé, HTML,
+
+02:13.300 --> 02:18.300
+con estos guiones y los indicadores de los
+triángulitos
+
+02:18.300 --> 02:22.300
+para saber que aquí voy a crear una nueva
+sección.
+
+02:22.300 --> 02:26.300
+Después solo puso un título que tiene un
+pequeño emoji
+
+02:26.300 --> 02:28.300
+y actividad
+reciente.
+
+02:28.300 --> 02:31.300
+Puedes cambiar el título de la forma que
+quieras.
+
+02:31.300 --> 02:36.300
+Mi actividad reciente, mis commits más
+recientes, como gustes.
+
+02:36.300 --> 02:38.800
+Voy a guardar estos
+cambios.
+
+02:39.800 --> 02:42.300
+Voy a mi control de
+versiones
+
+02:42.300 --> 02:48.300
+y voy a poner actividad
+reciente.
+
+02:51.300 --> 02:54.300
+Commit y
+Push.
+
+02:56.800 --> 03:01.300
+Con estos cambios ya listos, es momento de
+cerrar esta pestaña,
+
+03:01.300 --> 03:04.300
+o no, de hecho, regresar a mi repositorio
+desde aquí,
+
+03:04.300 --> 03:06.800
+en el menú de las líneas horizontales,
+
+03:06.800 --> 03:09.300
+Go to
+Repository.
+
+03:09.300 --> 03:13.300
+De vuelta a mi repositorio, voy a ver que
+aquí está Code,
+
+03:13.300 --> 03:16.800
+Pull Request, y esta es la sección de Actions.
+
+03:16.800 --> 03:20.300
+Es la sección que voy a querer utilizar ahora.
+
+03:21.300 --> 03:24.300
+Actions, en este caso, me va a permitir
+crear
+
+03:24.300 --> 03:28.800
+un nuevo flujo de trabajo para poder
+automatizar esta tarea.
+
+03:28.800 --> 03:30.800
+Lo
+selecciono.
+
+03:32.300 --> 03:35.800
+Y te aparecen, muy parecido a Codespaces,
+
+03:35.800 --> 03:40.300
+un montón de plantillas de GitHub Actions
+que puedes utilizar.
+
+03:40.300 --> 03:45.300
+Por ahora, a mí solamente me interesa un
+simple workflow,
+
+03:45.300 --> 03:46.800
+lo más
+básico.
+
+03:46.800 --> 03:48.800
+Lo
+selecciono.
+
+03:51.300 --> 03:56.800
+Y me aparece un archivo YAML, que se llama
+blank.yaml.
+
+03:56.800 --> 04:01.300
+Este archivo está ubicado en una parte muy
+especial
+
+04:01.300 --> 04:02.800
+del
+repositorio.
+
+04:02.800 --> 04:05.800
+Tiene que estar dentro de Workflows,
+
+04:05.800 --> 04:08.800
+en la
+carpeta.github.
+
+04:08.800 --> 04:11.800
+Es fundamental que este archivo se
+encuentre
+
+04:11.800 --> 04:14.800
+dentro de esta ubicación para hacer que la
+acción
+
+04:14.800 --> 04:17.300
+se pueda ejecutar sin ningún problema.
+
+04:17.300 --> 04:20.300
+Aquí me aparecen algunos textos que me
+dicen
+
+04:20.300 --> 04:22.800
+los pasos que se están
+utilizando.
+
+04:22.800 --> 04:26.300
+Si quieres profundizar un poco más acerca
+de lo que Actions
+
+04:26.300 --> 04:28.300
+tiene la capacidad de
+hacer,
+
+04:28.300 --> 04:31.300
+en Platzi tenemos un curso de GitHub
+Actions
+
+04:31.300 --> 04:34.300
+específicamente hablando, porque sí,
+
+04:34.300 --> 04:38.300
+el tema no da para un video, da para un
+curso completo.
+
+04:38.300 --> 04:41.300
+Por ahora, para aprender a utilizarlas,
+
+04:41.300 --> 04:44.300
+voy a seleccionar con Control-A o Control-E,
+
+04:44.300 --> 04:46.800
+dependiendo del idioma de tu máquina,
+
+04:46.800 --> 04:49.300
+todo el texto, y lo voy a
+borrar.
+
+04:49.300 --> 04:52.800
+Voy a pegar aquí el texto del archivo
+YAML
+
+04:52.800 --> 04:55.800
+que tú tienes en los recursos de esta clase.
+
+04:55.800 --> 04:58.800
+Este texto me permite saber varias cosas.
+
+04:58.800 --> 05:02.800
+En primer lugar, el nombre de la acción
+que voy a ejecutar,
+
+05:02.800 --> 05:04.800
+actualizar un
+README.
+
+05:04.800 --> 05:07.800
+Ya tengo esta acción, así que le voy a
+poner un README 2,
+
+05:07.800 --> 05:09.300
+por cualquier
+cosa.
+
+05:09.300 --> 05:12.300
+La segunda parte es la de agendar el tiempo,
+
+05:12.300 --> 05:15.800
+y voy a hacerle un zoom para que se pueda
+ver mejor ese texto.
+
+05:15.800 --> 05:16.800
+Listo.
+
+05:16.800 --> 05:19.300
+Aquí puedo agendar el
+tiempo
+
+05:19.300 --> 05:21.800
+gracias a este formato de tipo cron.
+
+05:21.800 --> 05:25.300
+Es decir, puedo hacer que esta tarea se
+ejecute
+
+05:25.300 --> 05:30.300
+cada minuto, cada hora, cada día o hasta
+cada segundo.
+
+05:30.300 --> 05:35.300
+Entonces, yo puedo poner aquí el asterisco
+diagonal 12,
+
+05:35.300 --> 05:37.300
+que representa las
+horas.
+
+05:37.300 --> 05:43.300
+Es decir, días, horas, minutos, segundos o
+microsegundos.
+
+05:43.300 --> 05:47.800
+En mi caso, no creo tener tanta actividad
+dentro de GitHub,
+
+05:47.800 --> 05:50.800
+así que con 12 horas es más que suficiente.
+
+05:50.800 --> 05:55.800
+Este desencadenante va a ejecutar el
+siguiente flujo.
+
+05:55.800 --> 05:59.300
+Gracias a Jobs voy a saber que se van a
+ejecutar
+
+05:59.300 --> 06:03.300
+dos pasos dentro del agente de Ubuntu.
+
+06:03.300 --> 06:07.300
+Es decir, este agente es una pequeña
+máquina virtual
+
+06:07.300 --> 06:10.800
+con Ubuntu que va a ejecutar todos los pasos.
+
+06:10.800 --> 06:15.300
+Los pasos que va a ejecutar están aquí,
+en Steps.
+
+06:15.300 --> 06:19.300
+El primer paso utiliza un
+Checkout.
+
+06:19.300 --> 06:23.800
+El Checkout no es nada más que esta
+pequeña máquina virtual
+
+06:23.800 --> 06:26.800
+o agente ejecutando la GitHub Action,
+
+06:26.800 --> 06:31.300
+accediendo a tu repositorio y teniendo
+todos tus archivos
+
+06:31.300 --> 06:35.300
+para naturalmente poder ejecutar lo que
+necesites.
+
+06:35.300 --> 06:37.800
+El segundo paso que voy a
+ejecutar
+
+06:37.800 --> 06:42.300
+es el de Readme, Workflows, Recent Activity.
+
+06:42.300 --> 06:44.300
+¿De dónde saqué este
+paso?
+
+06:44.300 --> 06:45.300
+Muy
+simple.
+
+06:45.300 --> 06:47.800
+En el Marketplace yo tengo la
+opción
+
+06:47.800 --> 06:49.800
+de buscar diferentes
+tareas
+
+06:49.800 --> 06:52.800
+que ya están previamente construidas.
+
+06:52.800 --> 06:54.800
+Aquí puedes encontrar
+tareas
+
+06:54.800 --> 06:57.300
+como compilar una aplicación de Java,
+
+06:57.300 --> 07:00.800
+como agregar paquetes a una aplicación de.
+NET,
+
+07:00.800 --> 07:03.800
+como desplegar un contenedor de
+Docker
+
+07:03.800 --> 07:07.300
+y un largo, larguísimo,
+etc.
+
+07:07.300 --> 07:09.800
+Todas estas tareas están previamente
+creadas
+
+07:09.800 --> 07:12.300
+para que tú simplemente las puedas
+jalar
+
+07:12.300 --> 07:15.300
+y agregar dentro de tu GitHub Action.
+
+07:15.300 --> 07:18.300
+Con estos dos pasos que por ahora me
+interesan,
+
+07:18.300 --> 07:20.300
+solamente antes de
+avanzar,
+
+07:20.300 --> 07:24.800
+te muestro que el paso de Readme, Workflows,
+Recent Activity
+
+07:24.800 --> 07:27.800
+tiene una palabra que se llama
+ENV.
+
+07:27.800 --> 07:31.300
+Es como los archivos ENV de Node, Python o
+Java.
+
+07:31.300 --> 07:33.800
+Es un variables de
+ambiente.
+
+07:33.800 --> 07:36.300
+Este variables de
+ambiente
+
+07:36.300 --> 07:39.300
+ahora solo necesita un GitHub
+Token
+
+07:39.300 --> 07:42.800
+y dado que la GitHub Action está dentro de
+nuestra cuenta,
+
+07:42.800 --> 07:45.800
+no tenemos que hacer nada más por el momento.
+
+07:45.800 --> 07:48.300
+Ya que esto está todo
+listo,
+
+07:48.300 --> 07:51.800
+voy a, primero, cambiar el archivo de
+YAML
+
+07:51.800 --> 07:54.300
+para que no sea
+blank.yaml.
+
+07:54.300 --> 07:56.300
+Quiero
+ponerle
+
+07:56.300 --> 08:01.800
+E-Update-Readme.yaml.
+
+08:01.800 --> 08:06.800
+Con estos cambios, presiona el botón de
+Commit Changes.
+
+08:06.800 --> 08:09.800
+Aparecerá la típica ventanita de
+GitHub
+
+08:09.800 --> 08:13.800
+diciéndote que si quieres hacer el commit,
+directamente a main.
+
+08:13.800 --> 08:16.800
+Presiona Commit
+Changes.
+
+08:19.300 --> 08:22.300
+Ahora ya aparece dentro de Workflows,
+
+08:22.300 --> 08:25.800
+pero necesitamos correr a la sección de
+Actions.
+
+08:27.800 --> 08:29.800
+Actualizar Readme
+2.
+
+08:29.800 --> 08:31.800
+Con nuestro archivo ya
+guardado,
+
+08:31.800 --> 08:34.800
+y mira mi originalidad, guión bajo y guión
+medio,
+
+08:34.800 --> 08:36.800
+este es el archivo que acabo de crear.
+
+08:36.800 --> 08:39.800
+De hecho, aquí aparece hace un minuto.
+
+08:39.800 --> 08:42.800
+Voy a irme a la sección de
+Actions.
+
+08:43.800 --> 08:46.800
+Y tengo aquí todos los flujos de
+trabajo
+
+08:46.800 --> 08:49.300
+que ya previamente había
+creado.
+
+08:49.300 --> 08:52.800
+Ahorita puedo seleccionar Update Readme 2.
+
+08:54.800 --> 08:57.800
+Me muestra que todavía no tiene ninguna
+ejecución,
+
+08:57.800 --> 09:01.800
+así que es momento de desplegar mi GitHub
+Action.
+
+09:01.800 --> 09:04.300
+Voy a ejecutar este flujo
+ahora.
+
+09:04.300 --> 09:07.800
+Me aparece una pestañita diciéndome que la
+rama sea main.
+
+09:07.800 --> 09:11.800
+Sí, presiona Run Workflow, que es el
+botoncito que aparece ahí.
+
+09:11.800 --> 09:14.800
+Solo es cuestión de esperar unos segundos.
+
+09:14.800 --> 09:17.300
+Si eres un poco desesperado como yo,
+
+09:17.300 --> 09:19.800
+puedes darle clic en Update
+Readme.
+
+09:19.800 --> 09:21.300
+Sin embargo,
+aparece,
+
+09:21.300 --> 09:24.300
+y va a ser un flujo de trabajo demasiado
+rápido,
+
+09:24.300 --> 09:26.800
+así que solo esperamos que se
+concluya
+
+09:26.800 --> 09:29.300
+para ver nuestra actividad del repositorio.
+
+09:29.300 --> 09:30.800
+Y hay un
+error.
+
+09:30.800 --> 09:32.800
+Voy a seleccionar el
+Readme,
+
+09:32.800 --> 09:35.300
+y esta parte me gusta
+muchísimo.
+
+09:35.300 --> 09:38.300
+Si algo disfruto de las GitHub
+Actions
+
+09:38.300 --> 09:41.800
+es su capacidad de poder mostrarte los
+errores.
+
+09:41.800 --> 09:44.300
+Si yo selecciono aquí el
+clic,
+
+09:44.300 --> 09:47.300
+te darás cuenta que hay algunos pasos que
+se ejecutaron.
+
+09:47.300 --> 09:51.300
+Te muestra el paso en color rojo que está
+fallando.
+
+09:53.300 --> 09:56.300
+Desplázate un poquito para
+abajo,
+
+09:56.300 --> 09:58.300
+y el error
+fatal
+
+09:58.300 --> 10:02.300
+es que no pudo encontrar esta parte de
+comentario
+
+10:02.300 --> 10:05.300
+dentro del repositorio de
+Readme,
+
+10:05.300 --> 10:07.800
+o dentro del archivo
+Readme.
+
+10:07.800 --> 10:09.300
+Eso está
+raro.
+
+10:09.300 --> 10:11.800
+Vamos a verificar que esté
+ahí.
+
+10:11.800 --> 10:13.800
+Regreso a
+Code.
+
+10:15.300 --> 10:18.300
+Pongo el Readme en modo de
+edición,
+
+10:18.300 --> 10:22.300
+y me desplazo a la parte del código que pegué.
+
+10:22.300 --> 10:24.300
+Y no puede
+ser.
+
+10:24.300 --> 10:27.300
+Dirían que hasta para copiar hay que ser
+bueno.
+
+10:27.300 --> 10:30.800
+El archivo del Markdown que tú tienes en
+los recursos
+
+10:30.800 --> 10:34.300
+tiene la parte correcta, que es Recent
+Activity.
+
+10:34.300 --> 10:35.800
+Y agrego algo de
+más.
+
+10:35.800 --> 10:38.300
+No importa, vamos a eliminar esa parte.
+
+10:38.300 --> 10:39.300
+Ahí
+está.
+
+10:39.300 --> 10:42.300
+Con Recent Activity y no tantos
+espacios
+
+10:42.300 --> 10:44.300
+para la siguiente
+sección,
+
+10:44.300 --> 10:47.800
+ya estaré listo para que aquí se coloque
+mi actividad.
+
+10:47.800 --> 10:50.800
+No necesito espacio entre estos dos
+comentarios.
+
+10:50.800 --> 10:52.800
+Guardo los
+cambios.
+
+10:52.800 --> 10:54.300
+Dentro de
+Main.
+
+10:56.300 --> 10:59.300
+Y ahora puedes regresar a tu acción.
+
+10:59.300 --> 11:01.800
+Hay que mencionar que por primera
+vez
+
+11:01.800 --> 11:03.800
+la acción tú la
+ejecutas.
+
+11:03.800 --> 11:07.300
+A partir de su última ejecución exitosa,
+
+11:07.300 --> 11:10.300
+ya cada 12 horas lo va a hacer por sí misma.
+
+11:10.300 --> 11:12.300
+No tienes que hacer nada
+más.
+
+11:12.300 --> 11:15.300
+Regreso a Update Readme
+2,
+
+11:15.300 --> 11:17.800
+y aquí en donde tuvimos la
+falla,
+
+11:17.800 --> 11:20.300
+vuelve a ejecutar este flujo de trabajo,
+
+11:20.300 --> 11:24.300
+es decir, Run en Main y Run Workflow.
+
+11:25.300 --> 11:28.300
+Aparece el nuevo flujo de
+trabajo,
+
+11:28.300 --> 11:31.800
+y de hecho, no tienes que esperar aquí la
+palomita.
+
+11:31.800 --> 11:35.800
+Puedes ir y ver los pasos en la secuencia
+esperada.
+
+11:35.800 --> 11:38.300
+Listo, ahora sí está en color verde,
+
+11:38.300 --> 11:40.300
+duró solo cinco
+segundos,
+
+11:40.300 --> 11:42.300
+y todo está en
+orden.
+
+11:42.300 --> 11:44.300
+Regreso a
+Code,
+
+11:45.300 --> 11:48.300
+me desplazo un poco hacia
+abajo,
+
+11:48.300 --> 11:51.300
+y ahora sí, ya está mi actividad
+reciente
+
+11:51.300 --> 11:54.300
+y todos los commits que acabo de
+realizar
+
+11:54.300 --> 11:56.300
+en este mismo
+repositorio.
+
+11:56.300 --> 11:59.300
+Como puedes ver, las GitHub Actions son
+una herramienta
+
+11:59.300 --> 12:02.300
+que además de CI,
+CD,
+
+12:02.300 --> 12:06.300
+que representan un amplio tema del cual
+podemos aprender,
+
+12:06.300 --> 12:09.300
+también son una herramienta un poco
+divertida
+
+12:09.300 --> 12:13.300
+para actualizar tu portada dentro del
+perfil de GitHub.
+
+12:13.300 --> 12:16.800
+Te invito a que pruebes muchas opciones
+que hay aquí.
+
+12:16.800 --> 12:18.800
+Dentro de los recursos de la
+clase,
+
+12:18.800 --> 12:22.300
+te voy a dejar el enlace a dos o tres
+portadas de perfil
+
+12:22.300 --> 12:24.300
+que son bastante
+atractivas
+
+12:24.300 --> 12:26.300
+y donde puedes aprender
+muchísimo.
+
+12:26.300 --> 12:30.300
+En mi caso, yo puse, además de la sección
+de la actividad reciente,
+
+12:30.300 --> 12:32.300
+mis videos publicados de
+YouTube.
+
+12:32.300 --> 12:34.300
+Puedes ir a mi
+perfil,
+
+12:34.300 --> 12:38.300
+descargar el archivo YAML y hacer
+exactamente lo mismo.
+
+12:38.300 --> 12:41.300
+Te invito a que pruebes para que mejores
+tu perfil de GitHub
+
+12:41.300 --> 12:54.300
+y después nos compartas todas tus
+actualizaciones en los comentarios.
+
diff --git "a/Curso de Git y GitHub/06-Administraci\303\263n de GitHub/02-Lecturas recomendadas.txt" "b/Curso de Git y GitHub/06-Administraci\303\263n de GitHub/02-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..d5d2302d1f8405e11a2a5bb6b19e48a0e23344a4
--- /dev/null
+++ "b/Curso de Git y GitHub/06-Administraci\303\263n de GitHub/02-Lecturas recomendadas.txt"
@@ -0,0 +1 @@
+https://platzi.com/cursos/github-actions/
diff --git "a/Curso de Git y GitHub/06-Administraci\303\263n de GitHub/02-Resumen.html" "b/Curso de Git y GitHub/06-Administraci\303\263n de GitHub/02-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..0e7e3f20d9513393fd54be1dbf12355496154ffe
--- /dev/null
+++ "b/Curso de Git y GitHub/06-Administraci\303\263n de GitHub/02-Resumen.html"
@@ -0,0 +1,131 @@
+
+
+
+
+
+
+ Automatización de GitHub Actions para Actualizar Perfil
+
+
+
+
+
+
Resumen
Optimizar tu perfil de GitHub puede marcar una gran diferencia al mostrar tus habilidades y actividad de desarrollo, y GitHub Actions es la herramienta ideal para automatizar tareas que mantengan tu perfil siempre actualizado. A continuación, te explicamos cómo crear una GitHub Action que muestre tu actividad reciente directamente en tu portada de perfil.
+
¿Qué es GitHub Actions y cómo puede ayudarte?
+
GitHub Actions permite automatizar diversos flujos de trabajo, desde revisiones de seguridad con Dependabot hasta integraciones continuas y despliegues (CI/CD). Con una GitHub Action, puedes extraer automáticamente tu actividad más reciente y mostrarla en tu perfil. Esto ayuda a que otros vean tu progreso y compromiso en tus repositorios.
+
¿Cómo configurar tu repositorio de portada en GitHub?
+
+
Selecciona tu repositorio de perfil: Este suele llevar el nombre de usuario como nombre de repositorio.
+
Edita el README: Abre el archivo README.md en modo edición y asegúrate de contar con una sección específica para la actividad reciente.
+
Agrega un título personalizable: Por ejemplo, “Actividad reciente” o “Últimos commits”, para que la sección tenga un toque personal.
+
+
¿Cómo crear una GitHub Action para actualizar tu actividad?
+
+
Accede a la sección de Actions en el repositorio de tu perfil.
+
Elige una plantilla básica para crear un flujo de trabajo simple.
+
Configura el archivo YAML:
+
+
Ubicación: Guarda el archivo como .github/workflows/update-readme.yml.
+
Cron Job: Programa la frecuencia de actualización. Un formato común es */12 * * * * para actualizar cada 12 horas.
+
Paso de checkout: Este paso accede a tus archivos.
+
Recent Activity Workflow: Incluye el paso para extraer tu actividad reciente desde un flujo preconstruido disponible en el Marketplace de GitHub Actions.
+
+
+
+
¿Cómo asegurarte de que tu GitHub Action funcione correctamente?
+
+
Guarda y ejecuta la acción: Haz un commit directo en la rama principal.
+
Verifica el estado: Si ocurre algún error, GitHub Actions lo destacará en rojo, señalando el paso problemático.
+
Ajustes finales: Corrige cualquier error en el archivo YAML o en los comentarios del README, y vuelve a ejecutar el flujo de trabajo.
+
+
¿Qué opciones adicionales puedes explorar en GitHub Actions?
+
+
Marketplace: Encuentra acciones preconfiguradas para desplegar en Docker, compilar aplicaciones en Java, entre otras.
+
Variables de ambiente: Usa GITHUB_TOKEN para autenticar la Action y mantenerla segura.
+
Contenido personalizado: Puedes agregar secciones adicionales en tu perfil, como listas de videos de YouTube o portafolios enlazados.
+
+
¿Cómo hacer que tu perfil destaque con otras personalizaciones?
+
GitHub Actions ofrece un sinfín de posibilidades para personalizar tu perfil y mostrar contenido relevante. Explora perfiles inspiradores en los recursos de esta clase, descarga archivos YAML, y pruébalos en tu repositorio para continuar optimizando tu presencia profesional.
+
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/06-Administraci\303\263n de GitHub/03-Lecturas recomendadas.txt" "b/Curso de Git y GitHub/06-Administraci\303\263n de GitHub/03-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..0cc0e8e70ad1aea2f5f8af5e06d48672524d94da
--- /dev/null
+++ "b/Curso de Git y GitHub/06-Administraci\303\263n de GitHub/03-Lecturas recomendadas.txt"
@@ -0,0 +1,2 @@
+https://cli.github.com/
+https://cli.github.com/manual/gh
diff --git "a/Curso de Git y GitHub/06-Administraci\303\263n de GitHub/03-Resumen.html" "b/Curso de Git y GitHub/06-Administraci\303\263n de GitHub/03-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..d4b505e1964b235474dad0dae7f7e27c99f1de6d
--- /dev/null
+++ "b/Curso de Git y GitHub/06-Administraci\303\263n de GitHub/03-Resumen.html"
@@ -0,0 +1,193 @@
+
+
+
+
+
+
+ Uso de GitHub CLI: instalación y comandos básicos
+
+
+
+
+
+
Resumen
¿Qué es GitHub CLI y cómo se utiliza?
+
GitHub CLI es una herramienta poderosa y versátil que ofrece GitHub para interactuar no solo con los comandos habituales de Git como commit o push, sino también para gestionar desde la terminal características del propio GitHub como pull requests, issues y mucho más. Su propósito es simplificar y automatizar las tareas que normalmente realizaríamos en el sitio web de GitHub. Con GitHub CLI, puedes optimizar tu flujo de trabajo y centrarte en el desarrollo.
+
¿Cómo instalar GitHub CLI?
+
Para comenzar a usar GitHub CLI, lo primero es instalarlo en tu máquina. La instalación varía según el sistema operativo, pero el proceso es bastante simple y similar entre ellos. Aquí te dejo los pasos esenciales:
+
+
+
Descargar la Herramienta:
+
+
Dirígete al repositorio de GitHub CLI para acceder a la documentación y los recursos de instalación.
+
Selecciona tu sistema operativo (Windows, Mac o Linux) para obtener las instrucciones precisas.
+
+
+
+
Instalación en Consola:
+
+
Si estás en Linux, por ejemplo, puedes copiar el comando de instalación proporcionado y ejecutarlo en tu terminal.
+
Una vez completado, verifica que la instalación sea exitosa utilizando el comando gh --version.
+
+
+
+
¿Cómo iniciar sesión en GitHub CLI?
+
Después de la instalación, el siguiente paso es iniciar sesión, lo cual te permitirá autenticarte y usar todas las funciones disponibles:
+
+
+
Autenticación Inicial:
+
+
Escribe el comando gh auth login en la terminal.
+
El asistente te pedirá que elijas entre github.com o github-enterprise.
+
+
+
+
Configuración del Protocolo y Llave SSH:
+
+
Selecciona el protocolo preferido, generalmente SSH.
+
El sistema te permitirá crear una nueva llave SSH para esta aplicación específica.
+
+
+
+
Autenticación mediante Browser o Token:
+
+
Puedes autenticarte a través de un navegador web o usando un token de autenticación, y luego seguir las instrucciones en pantalla para finalizar la conexión.
+
+
+
+
¿Cómo crear un repositorio usando GitHub CLI?
+
Una de las funcionalidades más útiles de GitHub CLI es la capacidad de crear repositorios desde la línea de comandos. Puedes emplear un asistente interactivo o ejecutar comandos detallados:
+
+
+
Crear Repositorio con Asistente:
+
+
Utiliza gh repo create y sigue las indicaciones para elegir opciones como nombre del repositorio, visibilidad, adición de README y gitignore.
+
+
+
+
Modos para Detallar la Creación:
+
+
También puedes especificar parámetros desde el inicio, como:
+
Una vez creado, GitHub CLI te pregunta si deseas clonar automáticamente el repositorio recién creado, simplificando aún más el esquema.
+
+
+
+
¿Cómo gestionar issues y pull requests con GitHub CLI?
+
GitHub CLI facilita la administración de issues y pull requests directamente desde la terminal, maximizando el control sobre tus proyectos sin dejar la línea de comandos:
+
+
Creación de Issues:
+
+
Usa gh issue create para abrir un nuevo issue en un repositorio determinado. Puedes añadir título y descripción si deseas.
+
+
+
Estado de Issues y Pull Requests:
+
+
Con gh issue status puedes revisar los issues asignados, abiertos y mencionados, facilitando el seguimiento de tareas y pendientes.
+
De manera similar, también puedes administrar pull requests con comandos como gh pr create.
+
+
+
+
¿Por qué usar GitHub CLI?
+
GitHub CLI mejora el flujo de trabajo desarrollador, permitiéndote personalizar y automatizar cada aspecto de tu interacción con GitHub. Es una herramienta ergonómica y flexible que puede orientarse para necesidades específicas mediante scripts que automatizan tareas rutinarias, como:
+
+
Automatización de Creación de Repositorios:
+
+
Scripts programados para crear y configurar nuevas estructuras de repositorios diarios.
+
+
+
Monitoreo Eficiente:
+
+
Acceso directo al estado de tus proyectos y fuentes a través de GitHub Actions y más.
+
+
+
+
En conclusión, GitHub CLI es una herramienta crucial en el arsenal de todo desarrollador que busca eficiencia y personalización en su flujo de trabajo, animando a explorar sus funcionalidades y a integrar esta potente herramienta en proyectos futuros.
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/06-Administraci\303\263n de GitHub/03-Uso de GitHub CLI instalaci\303\263n y comandos b\303\241sicos.mp4" "b/Curso de Git y GitHub/06-Administraci\303\263n de GitHub/03-Uso de GitHub CLI instalaci\303\263n y comandos b\303\241sicos.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..278e6745bc34b246708b7873a80f328152ad675f
--- /dev/null
+++ "b/Curso de Git y GitHub/06-Administraci\303\263n de GitHub/03-Uso de GitHub CLI instalaci\303\263n y comandos b\303\241sicos.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ff6a18686dd2e1b191a05266a2e4787d3e698832734f035b35e41a6ccfd4f497
+size 97160059
diff --git "a/Curso de Git y GitHub/06-Administraci\303\263n de GitHub/03-Uso de GitHub CLI instalaci\303\263n y comandos b\303\241sicos.vtt" "b/Curso de Git y GitHub/06-Administraci\303\263n de GitHub/03-Uso de GitHub CLI instalaci\303\263n y comandos b\303\241sicos.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..ced7b8feac335928790e21bbfe71ce92b4990a78
--- /dev/null
+++ "b/Curso de Git y GitHub/06-Administraci\303\263n de GitHub/03-Uso de GitHub CLI instalaci\303\263n y comandos b\303\241sicos.vtt"
@@ -0,0 +1,433 @@
+WEBVTT
+
+00:00.000 --> 00:04.320
+Dentro de las miles de herramientas que
+GitHub tiene por ahí escondidas,
+
+00:04.320 --> 00:10.320
+hay una que vale mucho la pena, GitHub CLI
+o Línea de Comandos de GitHub.
+
+00:10.320 --> 00:16.200
+La intención de esta herramienta es que tú
+puedas no solo hacer lo que puedes hacer hasta ahora con
+
+00:16.200 --> 00:21.960
+Git, es decir, un commit, push, cosas por
+el estilo, sino que también tengas la capacidad de manipular
+
+00:21.960 --> 00:27.520
+muchas características de GitHub desde tu
+línea de comandos, como por ejemplo los pull requests,
+
+00:27.520 --> 00:32.640
+los issues y muchas herramientas más que
+hasta ahora hemos visto en el sitio web.
+
+00:32.640 --> 00:35.240
+Vamos a ver cómo funciona esto en pantalla.
+
+00:35.240 --> 00:40.440
+Lo primero que tienes que hacer es ir a la
+dirección que está en los recursos de esta clase.
+
+00:40.440 --> 00:45.320
+Aquí vas a poder llegar al repositorio de
+CLI CLI.
+
+00:45.320 --> 00:47.400
+Súper largo el
+repositorio.
+
+00:47.400 --> 00:53.760
+Si te desplazas un poco hacia abajo,
+vas a ver un poco de la documentación de esta línea de comandos.
+
+00:53.760 --> 01:00.880
+Puedes buscar la sección principalmente
+por ahora de instalación y seleccionar el sistema operativo
+
+01:00.880 --> 01:08.680
+que más te guste. En mi caso me voy a
+desplazar un poquito para abajo aquí a Linux, en donde yo voy
+
+01:08.680 --> 01:13.840
+a poder instalar mi línea de comandos en
+el subsistema de Windows, que es el que he estado
+
+01:13.840 --> 01:16.800
+usando hasta este momento. Voy a
+seleccionar este link.
+
+01:16.800 --> 01:24.680
+Y aquí me voy a desplazar a este fragmento
+de código. Puedo seleccionarlo todo por completo
+
+01:24.680 --> 01:32.720
+y moverme a mi consola. Pego todo lo que
+acabo de copiar desde GitHub y probablemente a mí me
+
+01:32.720 --> 01:36.120
+aparezca que ya está todo instalado.
+Vamos a ver.
+
+01:36.120 --> 01:44.880
+Hace su proceso, hace la actualización de
+APT y aquí está el mensaje de que ya la tenía instalada.
+
+01:44.880 --> 01:50.440
+Para poder ahorrar algo de tiempo. Sin
+embargo, el proceso va a ser exactamente el mismo en
+
+01:50.440 --> 01:55.960
+cualquiera de todos los casos. No importa
+si seleccionas Windows, Mac o Linux. Es básicamente
+
+01:55.960 --> 02:02.840
+el mismo. Limpio mi terminal y ahora lo
+primero que tengo que hacer, como cualquier aplicación
+
+02:02.840 --> 02:11.240
+de terminal, es escribir gh-version para
+ver que ya está instalada. La verdad es que yo nunca me
+
+02:11.240 --> 02:16.360
+preocupo por la última versión.
+Simplemente escribo este comando para ver que mi herramienta
+
+02:16.360 --> 02:21.800
+ya está funcionando. Asumiré que es la
+última versión y de hecho por aquí aparece que es la
+
+02:21.800 --> 02:26.600
+fecha de hace como 10 días. Entonces no
+hay ningún problema. Estoy en la última versión.
+
+02:26.600 --> 02:34.360
+Ahora que ya sé que estoy en esa versión,
+voy a escribir gh-auth-login y comenzará un asistente
+
+02:34.360 --> 02:41.320
+muy divertido. Dentro de este asistente me
+empieza a preguntar qué tipo de cuenta voy a utilizar.
+
+02:41.320 --> 02:48.040
+Si github.com o github enterprise. Voy a
+seleccionar github.com. Después, cuál es el protocolo
+
+02:48.040 --> 02:55.720
+preferido para Git para hacer operaciones
+en esta máquina. Voy a presionar SSH. Me pregunta si
+
+02:55.720 --> 03:02.120
+quiero subir la llave a mi cuenta de github.
+Ojo, esta llave que me está preguntando qué quiere
+
+03:02.120 --> 03:07.840
+utilizar dentro de github no es la misma
+llave que he estado utilizando en todos mis repositorios
+
+03:07.840 --> 03:13.640
+anteriores. Se tiene que crear una llave
+porque esta es una aplicación que se está conectando
+
+03:13.640 --> 03:19.400
+a github. Entiendo, es mi misma computadora,
+pero son de alguna forma dos aplicaciones diferentes,
+
+03:19.400 --> 03:27.240
+así que toca crearla. Voy a seleccionar la
+misma por ahora y el título de mi llave SSH. Le voy a
+
+03:27.240 --> 03:34.280
+poner nada más SSH key. Puedo agregarle el
+CLI para acordarme dentro del portal de github,
+
+03:34.280 --> 03:41.720
+que es una CLI. Enter. ¿Cómo te gustaría
+autenticarte con la github CLI? Loguearme con un
+
+03:41.720 --> 03:47.240
+browser o pegar un token de autenticación.
+¿Te acuerdas que creamos un token de autenticación
+
+03:47.240 --> 03:53.520
+hace tiempo? Bueno, aquí podrías crear uno
+nuevo para esto. Yo voy a ir por el loguearme con un
+
+03:53.520 --> 04:05.400
+web browser. Y me dice que primero debo de
+copiar este código. Lo copio y después voy a crear un
+
+04:05.400 --> 04:16.080
+nuevo. Y me dice que primero debo de
+copiar este código. Lo copio y después enter para entrar a
+
+04:16.080 --> 04:22.040
+mi explorador. Me aparece un mensaje de
+que el explorador no puede ser abierto, pero lo puedo
+
+04:22.040 --> 04:33.880
+abrir desde aquí. Así que pongo continuar.
+Pego ese código que me mostraron y los permisos que
+
+04:33.880 --> 04:43.440
+me ofrece el explorador. Me aparece el acceso,
+autorizo a github y listo. Mi dispositivo debería
+
+04:43.440 --> 04:50.280
+estar ahora conectado. Regreso a mi
+terminal y voy a limpiar esta para poder hacer el primer
+
+04:50.280 --> 05:03.640
+comando. Es decir, ver que todo esté en orden.
+Escribiré gh-repo create. Y me aparece un
+
+05:03.640 --> 05:09.760
+mensaje de que me está preguntando si
+quiero crear un nuevo repositorio en github desde el
+
+05:09.760 --> 05:17.520
+inicio, si quiero crear un nuevo
+repositorio desde una plantilla o si quiero enviar un repositorio
+
+05:17.520 --> 05:25.560
+desde mi entorno local a github. Voy a
+seleccionar la primera opción. El nombre del repositorio le
+
+05:25.560 --> 05:38.000
+voy a decir github. El nombre o el
+propietario de este repositorio es Amin Espinosa. Descripción
+
+05:38.000 --> 05:49.080
+desde mi CLI. Visibilidad va a ser público
+y me gustaría agregar un readme. Me gustaría agregar
+
+05:49.080 --> 05:55.840
+un gitignore. El gitignore va a ser de
+Terraform porque es lo primero que me acaba de llegar a la
+
+05:55.840 --> 06:07.400
+cabeza. Me gustaría agregar una licencia. No.
+Y esto va a crear un mithes repositivo. Ya el
+
+06:07.400 --> 06:13.400
+asistente me dice que ese repositorio ha
+sido creado. Soy muy escéptico. Vamos a ver primero
+
+06:13.400 --> 06:20.680
+que ya está ahí. Me moví a la sección de
+mithes repositorios dentro de mi perfil de github y aquí
+
+06:20.680 --> 06:28.520
+se aparece un updated now y que mi tercer
+repo ya está como público. Debe de tener aquí un gitignore
+
+06:28.520 --> 06:35.880
+de Terraform que insisto fue lo primero
+que se me ocurrió y debe de tener un readme que ya está
+
+06:35.880 --> 06:42.200
+desplegándose. Regreso a la terminal y
+además el asistente me dice ¿quieres que clonen por ti este
+
+06:42.200 --> 06:52.320
+nuevo repositorio? Lo que hace mi vida muy
+feliz. Le digo que sí. Necesito la llave de lssh. Y listo.
+
+06:52.320 --> 07:02.400
+Ahora tengo que ver que se dé mi tercer repo.
+Este por ahí. Y ahí está. Mi tercer repo se
+
+07:02.400 --> 07:09.920
+está mostrando. Obviamente si pongo ls
+solo tiene ese readme. Voy a limpiar la pantalla y si te das
+
+07:09.920 --> 07:17.040
+cuenta el asistente con el github repo
+create fue muy muy inductivo. Es decir me iba haciendo las
+
+07:17.040 --> 07:22.240
+preguntas que necesitaba para crearlo de
+la forma que yo quisiera. Sin embargo hay ciertos parámetros
+
+07:22.240 --> 07:32.480
+que podría escribir. Es decir puedo poner
+un comando que me explique todo esto sin tanta ayuda
+
+07:32.480 --> 07:41.080
+de mi asistente. ¿A qué me refiero? Hace
+un rato acabo de crear gh-repo-create y mi tercer repo.
+
+07:41.080 --> 07:47.600
+Hasta ahí todo era felicidad. De hecho ni
+siquiera puse el nombre del repositorio. Ahora sí lo estoy
+
+07:47.600 --> 07:53.840
+poniendo y estoy poniendo como parámetros
+que sea público, que agregue un readme, que tenga
+
+07:53.840 --> 08:00.600
+una descripción que diga repo desde CLI y
+que además lo clone. Si te das cuenta esto haría
+
+08:00.600 --> 08:07.680
+exactamente lo mismo que el comando.
+Vamos a hacerlo pero con mi cuarto repo para que no haya
+
+08:07.680 --> 08:13.360
+ningún problema con los nombres de los
+repositorios. De esta forma el asistente lo está haciendo
+
+08:13.360 --> 08:19.480
+digamos un poco más rápido. Me pide de
+nuevo las llaves de ssh porque todavía no las tengo
+
+08:19.480 --> 08:26.560
+agregadas y ahí está mi cuarto repo.
+Lo cloné dentro de mi tercer repo. En fin tengo que poner
+
+08:26.560 --> 08:36.800
+ls y aquí está cd mi cuarto repositorio ls
+y ahí está el readme. Entonces si te das cuenta puedes
+
+08:36.800 --> 08:43.440
+hacer una de dos opciones. Puedes utilizar
+la github CLI para crear un repositorio desde cero
+
+08:43.440 --> 08:49.280
+o también puedes utilizarla con el
+asistente para que tú vayas definiendo qué es lo que necesitas.
+
+08:49.280 --> 08:55.160
+Básicamente las dos opciones te van a
+llevar a lo mismo. Como puedes ver crear repositorios es
+
+08:55.160 --> 09:01.720
+mucho más sencillo con la github CLI y de
+hecho hasta lo podrías automatizar. Sin embargo vamos
+
+09:01.720 --> 09:08.920
+a ir un pasito más adelante. Dentro de mi
+cuarto repo que es una especie de repo dentro de un repo
+
+09:08.920 --> 09:18.640
+por haberlo hecho un poco diferente voy a
+escribir gh issue create y desde mi línea de comandos puedo
+
+09:18.640 --> 09:26.680
+crear un issue para ese repositorio.
+Me dice el asistente de la github CLI cuál es el título y
+
+09:26.680 --> 09:35.880
+le voy a poner problemas con mi proyecto.
+Me pregunta si quiero poner una descripción. Le
+
+09:35.880 --> 09:42.160
+voy a poner enter para omitir esa
+descripción y solamente me pregunta qué es lo que sigue. Si lo
+
+09:42.160 --> 09:47.840
+quiero crear, continuar en un explorador,
+agregar metas datos o cancelar. Voy a seleccionar la
+
+09:47.840 --> 09:56.080
+primera que es crear. Listo mi issue fue
+creado y más bonito la línea de comandos me está poniendo
+
+09:56.080 --> 10:05.600
+aquí la url para llegar a ese issue.
+Dentro de mi cuarto repo yo ya tengo creado un issue. Este
+
+10:05.600 --> 10:14.440
+issue solamente para referencias lo voy a
+cerrar. Ahí está en morado y cerrado. Esto significa que
+
+10:14.440 --> 10:20.400
+ahora con el número uno voy a poder buscar
+cuál es su estatus dentro de mi línea de comandos.
+
+10:22.520 --> 10:33.800
+Es decir regreso a mi línea de comandos
+presionó clear y voy a poner gh issue status y me aparecen
+
+10:33.800 --> 10:39.280
+a David no haberlo cerrado porque no
+estaba asignado para mí. Pero bueno me aparecen aquí
+
+10:39.280 --> 10:45.320
+todos los issues que están en ese repositorio.
+Es decir me aparece una opción que dice issues
+
+10:45.320 --> 10:51.560
+asignados a ti, los que te mencionan y los
+que han sido abiertos por ti. No aparece la opción
+
+10:51.560 --> 10:57.240
+de los cerrados por mí que es la opción
+más heroica de un desarrollador. Sin embargo ya están
+
+10:57.240 --> 11:03.200
+aquí todas las opciones para poder hacer
+un track de esos issues. De esta manera también puedo
+
+11:03.200 --> 11:09.720
+monitorear los pull request, los
+repositorios que ya están creados, las actions y todo dentro de
+
+11:09.720 --> 11:15.920
+mis proyectos utilizando la línea de
+comandos de CLI. Como puedes ver los potenciales usos de
+
+11:15.920 --> 11:21.440
+la línea de comandos de GitHub son muchísimos.
+De hecho te mencioné en alguna parte que los
+
+11:21.440 --> 11:27.640
+puedes automatizar. Imagínate crear un
+script para que cada día se cree un nuevo repositorio
+
+11:27.640 --> 11:33.640
+en donde tú puedas poner tus actividades o
+se clone un nuevo repositorio para que tú sepas
+
+11:33.640 --> 11:39.120
+cómo está funcionando ese proyecto. Hay
+muchos escenarios en donde la línea de comandos de
+
+11:39.120 --> 11:46.120
+GitHub te ayuda bastante y de hecho como
+pequeño tip puedes darte cuenta que en el botón verde de
+
+11:46.120 --> 11:52.240
+code que siempre utilizamos para clonar
+nuestros repositorios, ahí viene una tercera opción que es
+
+11:52.240 --> 11:57.760
+la GitHub CLI, lo que también te puede
+hacer las cosas mucho más cómodas. Una de las desventajas
+
+11:57.760 --> 12:04.880
+que tienes o creo que la única que
+podríamos encontrar si quisiéramos encontrar un problema
+
+12:04.880 --> 12:12.280
+en la línea de comandos de la GitHub CLI
+es que conforme más la usamos más dependencia y arraigo
+
+12:12.280 --> 12:18.400
+tenemos a GitHub. Cuando Git es universal
+y lo podemos utilizar con otros productos, así que
+
+12:18.400 --> 12:23.520
+sólo hace falta cambiar ese switch. Si
+estamos con otros productos podemos seguir trabajando con
+
+12:23.520 --> 12:30.560
+Git sin problemas. Si estamos con GitHub
+sería fantástico utilizar las herramientas como la CLI
+
+12:30.560 --> 12:48.960
+para poder sacarle el máximo provecho a
+nuestra terminal.
+
diff --git "a/Curso de Git y GitHub/06-Administraci\303\263n de GitHub/04-Quiz.mhtml" "b/Curso de Git y GitHub/06-Administraci\303\263n de GitHub/04-Quiz.mhtml"
new file mode 100644
index 0000000000000000000000000000000000000000..dbaf3aaea7c25ec2a3cb7f9554c3f31154ebb847
--- /dev/null
+++ "b/Curso de Git y GitHub/06-Administraci\303\263n de GitHub/04-Quiz.mhtml"
@@ -0,0 +1,13243 @@
+From:
+Snapshot-Content-Location: https://platzi.com/clases/quiz/21263/
+Subject:
+Date: Sat, 8 Nov 2025 19:38:32 -0500
+MIME-Version: 1.0
+Content-Type: multipart/related;
+ type="text/html";
+ boundary="----MultipartBoundary--pZiguGJZE4BlWR3hSwdFSHKhKkE0woAca6xkt78brU----"
+
+
+------MultipartBoundary--pZiguGJZE4BlWR3hSwdFSHKhKkE0woAca6xkt78brU----
+Content-Type: text/html
+Content-ID:
+Content-Transfer-Encoding: quoted-printable
+Content-Location: https://platzi.com/clases/quiz/21263/
+
+
+ =20
+
+ =20
+
+
+
+
+
+
+
+
+
+
+
+ =20
+
+ =20
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ =20
+ =20
+ =20
+
+ =20
+
+ =20
+
+
+ =20
+
+ =20
+
+
+
+ =20
+
+
+ =20
+ =20
+ =20
+
+
+
¿Cómo integrar herramientas de Git y GitHub en un proyecto real?
+
El mundo del desarrollo de software se enriquece con herramientas colaborativas que facilitan el trabajo en equipo y la gestión de proyectos. Git y GitHub son dos de estos recursos esenciales que, cuando se integran correctamente, facilitan la colaboración y aseguran un flujo de trabajo eficiente. Aquí exploraremos cómo aprovechar al máximo estas herramientas y unirlas en un proyecto real.
+
¿Cómo crear un repositorio en GitHub y clonarlo de manera local?
+
Para comenzar, necesitas crear un repositorio en GitHub y clonarlo en tu entorno local. Asegúrate de contar con un README.md para documentar tu proyecto desde el inicio. Una vez en tu máquina local, abre el repositorio en un editor de código como Visual Studio Code. Este será el punto de partida para organizar tu desarrollo.
+
+
Crear el directorio .github: Usa este directorio para almacenar plantillas y otras configuraciones.
+
Agregar plantillas: Añade un archivo como pull-request-template.md para formalizar los procesos colaborativos y asegurarte de que todos los miembros del equipo siguen las mismas pautas al crear un pull request.
¿Cómo gestionar ramas y commits de manera efectiva?
+
En Git, siempre es recomendable trabajar en ramas diferentes al main para evitar conflictos y mantener el código base seguro. Crea una nueva rama para cada característica o tarea que estés desarrollando.
+
+
Crear una nueva rama:
+
+
Siempre asegúrate de estar fuera de la rama principal cuando desarrolles nuevas características.
+
Usa un nombre descriptivo para la rama que refleje la tarea que estás realizando.
+
+
+
+
git checkout -b mi-nueva-rama
+
+
+
Realizar commits: Asegúrate de que cada commit describa claramente los cambios realizados.
+
+
gitadd.
+git commit -m"Implementación de nueva API"
+
+
¿Cómo desarrollar y probar una API en Python?
+
Hemos hablado sobre la configuración del entorno de desarrollo; ahora, toca desarrollar una simple API en Python.
+
+
+
Configurar la estructura del proyecto:
+
+
Crea una carpeta dedicada para tu API, por ejemplo, api.
+
Añade un archivo app.py y requirements.txt en la raíz de tu carpeta de API.
+
+
+
+
Instalar las dependencias necesarias:
+
+
Asegúrate de que requirements.txt contenga todos los paquetes necesarios.
+
+
+
+
pip3 install-r requirements.txt
+
+
+
Desplegar la API:
+
+
Usa herramientas como uvicorn para lanzar tu servidor y verificar que todo funcione correctamente.
+
+
+
+
uvicorn app:app --reload
+
+
¿Cómo efectuar un pull request en GitHub?
+
Al finalizar tus cambios y haberlos probado adecuadamente, es hora de subirlos a GitHub y abrir un pull request. Esto no solo integra tus cambios al repositorio principal, sino que también permite revisiones de tus compañeros de equipo.
+
+
Subir cambios a GitHub:
+
+
Asegúrate de estar en la rama correcta y empuja tus cambios.
+
+
+
+
git push -u origin mi-nueva-rama
+
+
+
Crear un pull request:
+
+
Utiliza el archivo pull-request-template.md para seguir una guía estructurada en el momento de realizar el pull request.
+
+
+
+
Compartir una base común, usando las plantillas y el flujo de trabajo explicados, asegura que todos los miembros del equipo estén alineados y que el proyecto avance sin contratiempos.
+
Consejos adicionales
+
+
Nunca trabajes directamente en main: Esto protege la integridad del proyecto principal y permite un flujo de desarrollo más organizado.
+
Utiliza plantillas: Tanto para issues como para pull requests, asegurando que toda la comunicación sea clara y relevante.
+
Revisión de código colaborativo: Anima a tus compañeros a revisar el código antes de fusionarlo en el main, esto ayuda a detectar errores más temprano y aprender de los diferentes enfoques en el equipo.
+
+
Este proceso asegura no solo una correcta integración de herramientas, sino que también fomenta un ambiente de trabajo colaborativo y organizado, esencial en todo proyecto de software.
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/07-Gesti\303\263n de Cambios con Pull Requests/02-Creaci\303\263n y Gesti\303\263n de Branches y Pull Requests en GitHub.mp4" "b/Curso de Git y GitHub/07-Gesti\303\263n de Cambios con Pull Requests/02-Creaci\303\263n y Gesti\303\263n de Branches y Pull Requests en GitHub.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..a5799370897031eec87ca0937c3152091591527a
--- /dev/null
+++ "b/Curso de Git y GitHub/07-Gesti\303\263n de Cambios con Pull Requests/02-Creaci\303\263n y Gesti\303\263n de Branches y Pull Requests en GitHub.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c78aac58b7eb40a8c49fe0c3fa0eded71b1e656818a49ee9f74007a241692b5a
+size 84419543
diff --git "a/Curso de Git y GitHub/07-Gesti\303\263n de Cambios con Pull Requests/02-Creaci\303\263n y Gesti\303\263n de Branches y Pull Requests en GitHub.vtt" "b/Curso de Git y GitHub/07-Gesti\303\263n de Cambios con Pull Requests/02-Creaci\303\263n y Gesti\303\263n de Branches y Pull Requests en GitHub.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..c5f42c5e63a9b6cda8981f1e5a65e9784272d4d3
--- /dev/null
+++ "b/Curso de Git y GitHub/07-Gesti\303\263n de Cambios con Pull Requests/02-Creaci\303\263n y Gesti\303\263n de Branches y Pull Requests en GitHub.vtt"
@@ -0,0 +1,890 @@
+WEBVTT
+
+00:00.000 --> 00:01.600
+Ahora es un día
+nuevo.
+
+00:01.600 --> 00:04.400
+He terminado mi trabajo de mis actividades.
+
+00:04.400 --> 00:07.800
+Esperaría que alguien haya aprobado el
+pull request
+
+00:07.800 --> 00:11.400
+que hice en la clase anterior y poder
+continuar con mi trabajo.
+
+00:11.400 --> 00:15.700
+En esta ocasión, necesito agregar un nuevo
+método a mi API.
+
+00:15.700 --> 00:17.900
+El método se va a llamar Cursos
+Platzi
+
+00:17.900 --> 00:21.400
+y va a mostrar algunos de los cursos que
+hay dentro de Platzi.
+
+00:21.400 --> 00:24.100
+Vamos a ver primero qué es lo que debo de
+hacer
+
+00:24.100 --> 00:26.900
+para antes de escribir una línea de código,
+
+00:26.900 --> 00:28.700
+saber que todo va en
+orden.
+
+00:28.700 --> 00:30.900
+Dentro de mi rutina
+habitual,
+
+00:30.900 --> 00:33.400
+lo primero que hago es entrar al
+depositorio
+
+00:33.400 --> 00:36.300
+y ver que hay un pull request activo.
+
+00:36.600 --> 00:38.600
+Selecciono esta
+categoría
+
+00:38.800 --> 00:41.300
+y aquí hay un pull request
+de
+
+00:41.300 --> 00:44.600
+Agregué los métodos de los mejores
+superhéroes de Marvel.
+
+00:44.600 --> 00:45.600
+OK.
+
+00:45.600 --> 00:46.600
+Lo
+selecciono
+
+00:46.800 --> 00:50.300
+y veo que fue Miguel quien creó este pull
+request.
+
+00:50.600 --> 00:51.700
+¿Qué es lo que puedo
+hacer?
+
+00:51.700 --> 00:53.700
+Primero, reviso los
+cambios.
+
+00:54.900 --> 00:56.500
+Voy a esta
+sección
+
+00:56.500 --> 00:58.500
+y me doy cuenta
+que...
+
+00:58.500 --> 01:00.300
+Perfecto, me hizo el enorme
+favor
+
+01:00.300 --> 01:02.800
+de acomodar algunos espacios que tenía por
+ahí
+
+01:03.000 --> 01:06.000
+y agregó lo que tú estás viendo en verde,
+
+01:06.300 --> 01:07.800
+es lo que él
+agregó.
+
+01:08.100 --> 01:10.300
+Lo que tú estás viendo en
+rojo
+
+01:10.300 --> 01:14.300
+es lo que él eliminó o simplemente modificó.
+
+01:14.500 --> 01:17.400
+Como te puedes dar cuenta, eliminó esta
+parte de rows,
+
+01:17.400 --> 01:18.800
+pero la volvió a
+ajustar.
+
+01:18.800 --> 01:22.500
+Entonces, veo que el archivo tiene todo lo
+necesario.
+
+01:22.700 --> 01:25.300
+El método está bien, todo se ve en orden.
+
+01:25.300 --> 01:27.800
+Así que puedo regresar a la conversación,
+
+01:28.500 --> 01:32.200
+ver si puso la plantilla bien llena y
+completa
+
+01:32.400 --> 01:34.000
+sin ningún
+problema.
+
+01:35.000 --> 01:39.900
+Y está un comentario muy bueno de que todo
+está listo.
+
+01:40.100 --> 01:42.200
+Lamentablemente, el presupuesto no nos
+alcanza
+
+01:42.200 --> 01:43.400
+para que Cheyenne lo
+pruebe,
+
+01:43.400 --> 01:46.400
+pero yo puedo aprobar este pull
+request
+
+01:46.600 --> 01:48.100
+y fusionarlo con
+Mame.
+
+01:48.700 --> 01:50.500
+Ahí está. Está
+listo.
+
+01:50.700 --> 01:54.700
+Y también no solo es la responsabilidad de
+Cheyenne,
+
+01:54.700 --> 01:56.900
+es la responsabilidad de otro programador.
+
+01:57.100 --> 01:58.200
+También fue la
+mía.
+
+01:58.200 --> 02:01.100
+Si yo fusioné este pull
+request,
+
+02:01.300 --> 02:03.700
+sé que esta rama ya no debe de existir,
+
+02:03.700 --> 02:05.000
+así que la
+eliminó.
+
+02:05.800 --> 02:07.100
+Todo está en
+orden.
+
+02:07.100 --> 02:08.900
+Me desplazo hacia
+arriba,
+
+02:09.400 --> 02:10.500
+voy a
+Code
+
+02:10.900 --> 02:13.800
+y veo que hay una rama de
+más.
+
+02:13.800 --> 02:15.800
+Sin embargo, dentro de
+Mame,
+
+02:16.300 --> 02:18.300
+aquí está, agregué
+método
+
+02:18.700 --> 02:20.700
+de los mejores superhéroes de Marvel.
+
+02:20.900 --> 02:23.900
+Todo está aprobado y de cualquier
+manera
+
+02:23.900 --> 02:24.900
+podrías
+ir,
+
+02:25.800 --> 02:29.200
+seleccionar API y ver que aquí está
+superhéroes de Marvel.
+
+02:29.400 --> 02:30.600
+Todo está dentro de
+Mame.
+
+02:30.600 --> 02:32.200
+Su trabajo está
+concluido.
+
+02:32.500 --> 02:34.300
+Puedo arrancar con el
+mío.
+
+02:34.800 --> 02:38.100
+De nuevo, voy a regresar ahora a Visual
+Studio,
+
+02:39.000 --> 02:41.700
+presionar Enter un par de
+espacios
+
+02:41.700 --> 02:44.600
+porque ya me regañaron que Python necesita
+tener
+
+02:44.900 --> 02:46.900
+dos espacios entre cada
+método
+
+02:47.200 --> 02:50.500
+y aquí voy a colocar el nuevo método que
+me corresponde,
+
+02:50.800 --> 02:52.200
+cursos
+Platzi.
+
+02:52.200 --> 02:54.300
+De hecho, no dice Get
+superhéroes,
+
+02:54.300 --> 02:57.300
+lo vamos a poner como Get
+cursos.
+
+02:58.300 --> 02:59.300
+Y
+está.
+
+02:59.300 --> 03:01.300
+Docker, Bash,
+Linux,
+
+03:02.300 --> 03:04.300
+algunos de los cursos de
+Platzi.
+
+03:04.300 --> 03:06.300
+Entonces, yo quedé
+listo.
+
+03:06.500 --> 03:09.300
+Recuerda, terminaste de escribir el código.
+
+03:09.300 --> 03:11.500
+Antes de cualquier otra
+cosa,
+
+03:12.400 --> 03:14.400
+abrimos una nueva
+rama
+
+03:14.600 --> 03:15.800
+y esta se va a
+llamar
+
+03:15.800 --> 03:16.800
+Amin
+
+03:17.000 --> 03:18.000
+diagonal
+
+03:18.900 --> 03:19.900
+tarea
+
+03:19.900 --> 03:21.900
+16.
+
+03:22.100 --> 03:23.600
+Espero que mi rama se
+cree.
+
+03:23.600 --> 03:25.100
+Ya me aparece por
+aquí.
+
+03:25.400 --> 03:27.900
+Está ya tarea
+16
+
+03:28.200 --> 03:31.900
+y, de hecho, VS Code me dice que ya hay un
+commit.
+
+03:32.400 --> 03:34.200
+Puedes hacer el commit desde
+aquí.
+
+03:34.200 --> 03:35.900
+A lo mejor, por la
+costumbre,
+
+03:35.900 --> 03:38.200
+yo suelo hacerlo desde mi línea de comandos,
+
+03:38.200 --> 03:40.200
+así que me moveré para
+allá.
+
+03:41.000 --> 03:42.500
+En mi línea de
+comandos,
+
+03:42.500 --> 03:45.600
+primero hago exactamente el mismo
+ritual
+
+03:45.600 --> 03:47.800
+que cuando hice la creación de mi API.
+
+03:47.800 --> 03:51.800
+Get branch, para confirmar que sí estoy en
+la rama que necesito.
+
+03:51.800 --> 03:53.800
+Ahí está, tarea
+16.
+
+03:54.400 --> 03:55.900
+Get
+status.
+
+03:58.200 --> 04:00.100
+API fue
+modificado,
+
+04:00.100 --> 04:02.100
+app.py fue
+modificado
+
+04:02.100 --> 04:05.800
+y soy muy valiente, no necesito verificar
+el método.
+
+04:06.000 --> 04:07.800
+Vamos a poner
+Get
+
+04:08.300 --> 04:09.300
+add.
+
+04:09.300 --> 04:12.900
+Y después, Get status para ver que ya
+cambio de color
+
+04:12.900 --> 04:15.400
+de no estar
+agregado
+
+04:15.400 --> 04:17.600
+a ya estar
+agregado.
+
+04:17.800 --> 04:19.600
+Aquí, Get
+commit.
+
+04:21.500 --> 04:23.700
+Yon m, y puedo
+poner
+
+04:24.500 --> 04:27.300
+método de platzi
+agregado.
+
+04:31.500 --> 04:34.900
+Listo, ya tengo mi commit, ya tengo mis
+cambios.
+
+04:35.300 --> 04:38.400
+Limpio mi terminal para poder tener un
+poco más de espacio
+
+04:38.400 --> 04:40.300
+e irme por el comando
+final.
+
+04:40.300 --> 04:42.400
+Get
+push
+
+04:42.600 --> 04:43.800
+yon
+u
+
+04:43.800 --> 04:45.000
+origin.
+
+04:47.100 --> 04:49.300
+Y pongo a min,
+diagonal,
+
+04:49.500 --> 04:51.300
+tarea
+16.
+
+04:52.400 --> 04:55.000
+Ya están mis cambios
+realizados.
+
+04:55.000 --> 04:57.400
+Hay una parte muy
+importante,
+
+04:57.400 --> 04:58.900
+si te das
+cuenta,
+
+04:58.900 --> 05:02.500
+no hay ningún problema de que yo suba mis
+cambios.
+
+05:02.500 --> 05:06.000
+Sin embargo, debo de ser un poquito
+observador
+
+05:06.000 --> 05:08.500
+y darme cuenta de que
+main
+
+05:08.500 --> 05:11.100
+tiene ya algunos cambios realizados.
+
+05:11.100 --> 05:13.900
+Antes de que yo suba mis
+cambios,
+
+05:13.900 --> 05:16.700
+lo ideal es que empate con
+main,
+
+05:16.700 --> 05:20.100
+que fue un comando que omití en este
+ejercicio
+
+05:20.100 --> 05:23.600
+a propósito para no tener dentro de mi cuenta.
+
+05:23.600 --> 05:26.300
+Voy a ver cómo puedo solucionar esto.
+
+05:26.300 --> 05:29.600
+Primero, me paso a Get
+branch
+
+05:30.600 --> 05:33.100
+y selecciono main, es
+decir,
+
+05:33.600 --> 05:34.800
+Get
+
+05:35.600 --> 05:36.800
+switch
+
+05:37.100 --> 05:38.300
+main.
+
+05:38.300 --> 05:40.900
+Listo. Ahora, ya que estoy
+aquí,
+
+05:40.900 --> 05:42.500
+limpio mi
+terminal
+
+05:43.500 --> 05:44.900
+y
+escribo
+
+05:45.300 --> 05:46.900
+Get
+pull.
+
+05:48.100 --> 05:51.300
+Me aparecen algunas actualizaciones,
+
+05:51.300 --> 05:52.600
+es
+decir,
+
+05:52.600 --> 05:56.700
+app.py con las 23 líneas o
+modificaciones
+
+05:56.700 --> 05:58.400
+que hizo
+Miguel.
+
+05:58.400 --> 06:01.500
+Quiere decir que ahorita podría
+empezar
+
+06:01.500 --> 06:03.600
+a tener un pequeño
+conflicto
+
+06:03.600 --> 06:07.900
+y tengo que solucionarlo antes de que me
+suba el comando final.
+
+06:07.900 --> 06:10.700
+Tengo que solucionarlo antes de que ese
+conflicto
+
+06:10.700 --> 06:12.700
+se vaya hacia
+GitHub.
+
+06:12.700 --> 06:16.700
+Para ello, me regreso a mi rama, a min16.
+
+06:17.000 --> 06:18.200
+Get
+
+06:18.900 --> 06:20.200
+switch
+
+06:20.400 --> 06:23.000
+a
+min16.
+
+06:23.800 --> 06:28.500
+Ah, claro, la tarea es a minTarea16.
+
+06:29.300 --> 06:31.300
+Ahora escribo
+Get
+
+06:31.900 --> 06:33.200
+merge
+
+06:34.200 --> 06:35.200
+main.
+
+06:35.200 --> 06:38.700
+Y cierro los ojos para ver que no haya
+ningún conflicto.
+
+06:39.700 --> 06:41.200
+Sí lo
+hay.
+
+06:41.200 --> 06:43.900
+Voy a regresar a Visual Studio
+Code
+
+06:43.900 --> 06:46.400
+para resolver ese
+conflicto.
+
+06:50.000 --> 06:54.700
+En Visual Studio me aparece que tengo
+ambos problemas.
+
+06:55.200 --> 06:59.200
+Entonces voy a seleccionar la opción
+Resolver en el editor.
+
+06:59.600 --> 07:02.700
+Es decir, ¿cuál opción quiero
+quedarme?
+
+07:02.700 --> 07:07.200
+¿La de superhéroes de
+Marvel?
+
+07:07.200 --> 07:08.700
+Aquí
+está.
+
+07:08.700 --> 07:10.900
+¿O el de cursos de
+Platzi?
+
+07:10.900 --> 07:14.400
+La realidad es que necesito a
+ambos
+
+07:14.400 --> 07:17.600
+porque no voy a afectar el trabajo de
+Miguel
+
+07:17.600 --> 07:21.200
+y tampoco quiero que mi trabajo se vea
+afectado.
+
+07:21.200 --> 07:25.200
+Así que seleccionaré la opción de Aceptar
+combinación.
+
+07:25.200 --> 07:30.200
+Aquí está la combinación y puedo hacer
+este merge.
+
+07:33.000 --> 07:38.000
+Puedes ver que ya está dentro de mi rama a
+minTarea16
+
+07:38.000 --> 07:41.000
+la información que Miguel
+subió
+
+07:41.000 --> 07:44.000
+y también está mi
+información.
+
+07:44.000 --> 07:46.500
+Puedo hacer un commit y ya que estoy
+aquí
+
+07:46.500 --> 07:49.000
+lo hago desde Visual Studio
+Code.
+
+07:49.000 --> 07:53.000
+VS Code me dice que ya aquí está la fusión
+de las ramas,
+
+07:53.000 --> 07:57.000
+que ya todo está en orden, así que puedo
+sincronizar los cambios,
+
+07:57.000 --> 08:00.000
+que es exactamente el git push que acabo
+de hacer
+
+08:00.000 --> 08:04.000
+hace apenas unos segundos, pero desde VS Code.
+
+08:06.000 --> 08:11.000
+Me aparece que voy a hacer un pull y push
+del commit.
+
+08:11.000 --> 08:13.000
+Está
+bien.
+
+08:13.000 --> 08:15.000
+Y listo, todo está en
+orden.
+
+08:15.000 --> 08:17.000
+Regreso a mi portal de
+GitHub.
+
+08:17.000 --> 08:20.000
+Cuando yo regreso a mi portal y en mi
+repositorio,
+
+08:20.000 --> 08:25.000
+ya está a minTarea16 con todos los cambios.
+
+08:27.000 --> 08:29.000
+Creo este nuevo pull
+request.
+
+08:29.000 --> 08:32.000
+Y como no tengo tanto tiempo, nada más le
+diré,
+
+08:32.000 --> 08:37.000
+ya aprueba, apruébame
+Miguel.
+
+08:37.000 --> 08:39.000
+No debería de poder títulos
+así.
+
+08:39.000 --> 08:42.000
+La idea es hacerlo muy descriptivo, pero
+bueno.
+
+08:42.000 --> 08:45.000
+Lo voy a poner, tengo la
+fusión.
+
+08:45.000 --> 08:48.000
+Siempre es importante ver que la fusión de
+las ramas
+
+08:48.000 --> 08:52.000
+sea la esperada,
+minTarea16,
+
+08:52.000 --> 08:55.000
+y creo un pull request esperando
+únicamente
+
+08:55.000 --> 08:58.000
+a que Miguel me
+apruebe.
+
+08:58.000 --> 09:01.000
+Listo, el estado de mi sitio ya cambió,
+
+09:01.000 --> 09:03.000
+ya está como
+merged.
+
+09:03.000 --> 09:06.000
+Me desplazo hacia
+abajo,
+
+09:06.000 --> 09:09.000
+y Miguel me hizo exactamente el mismo
+favor
+
+09:09.000 --> 09:11.000
+que yo con su pull
+request.
+
+09:11.000 --> 09:14.000
+Me hizo el enorme favor de eliminar mi rama.
+
+09:14.000 --> 09:16.000
+Ya no la
+necesito.
+
+09:16.000 --> 09:18.000
+No es necesario que esté
+ahí,
+
+09:18.000 --> 09:20.000
+así que el pull request está
+listo.
+
+09:20.000 --> 09:23.000
+Voy a
+Code,
+
+09:24.000 --> 09:26.000
+selecciono
+API,
+
+09:26.000 --> 09:30.000
+y dentro de app.py, en la rama de Main,
+
+09:30.000 --> 09:34.000
+debo de tener SuperHeroes Marvel y Curso
+Platzi.
+
+09:34.000 --> 09:37.000
+Se me fue una línea, podría hacer una
+corrección de ello,
+
+09:37.000 --> 09:39.000
+pero todo está en
+orden.
+
+09:39.000 --> 09:42.000
+Así es como puedo concluir el
+proceso
+
+09:42.000 --> 09:45.000
+de contribución de código de mi trabajo.
+
+09:45.000 --> 09:47.000
+Con el de los
+demás.
+
+09:47.000 --> 09:49.000
+Como te puedes dar
+cuenta,
+
+09:49.000 --> 09:52.000
+la relación de los pull requests y las
+ramas
+
+09:52.000 --> 09:54.000
+es como estar jugando ping
+pong.
+
+09:54.000 --> 09:56.000
+Yo le paso mi rama a alguien
+más,
+
+09:56.000 --> 09:59.000
+alguien la revisa, esta se fusiona con Main,
+
+09:59.000 --> 10:02.000
+y el proceso se reinicia una y otra vez.
+
+10:02.000 --> 10:05.000
+Al principio, sin mucha
+práctica,
+
+10:05.000 --> 10:08.000
+puede parecer un proceso muy burocrático,
+
+10:08.000 --> 10:11.000
+pero creo que te puedes dar cuenta en el
+ejercicio
+
+10:11.000 --> 10:14.000
+que incluso ya estamos todos
+mecanizados
+
+10:14.000 --> 10:17.000
+a saber qué comandos tenemos que escribir
+dentro de Git
+
+10:17.000 --> 10:20.000
+o qué secuencia debemos de
+hacer.
+
+10:20.000 --> 10:23.000
+Date cuenta como lo ideal es empezar con
+una rutina.
+
+10:23.000 --> 10:26.000
+Puedes iniciar tu día viendo los pull
+requests pendientes
+
+10:26.000 --> 10:28.000
+de todos los
+demás.
+
+10:28.000 --> 10:32.000
+Después, puedes jalar todos los cambios a
+tu rama principal
+
+10:32.000 --> 10:35.000
+y por último, ya puedes empezar a
+hacer
+
+10:35.000 --> 10:38.000
+en una rama por separado todo tu trabajo.
+
+10:38.000 --> 10:41.000
+De esta forma y con esta
+secuencia,
+
+10:41.000 --> 10:44.000
+es casi imposible que te encuentres algún
+conflicto
+
+10:44.000 --> 10:47.000
+como el que yo cause en esta
+clase.
+
+10:47.000 --> 10:50.000
+Sin embargo, aún cuando eso sucediera,
+
+10:50.000 --> 11:11.000
+bueno, ya estás capacitado para poder
+resolverlo.
+
diff --git "a/Curso de Git y GitHub/07-Gesti\303\263n de Cambios con Pull Requests/02-Lecturas recomendadas.txt" "b/Curso de Git y GitHub/07-Gesti\303\263n de Cambios con Pull Requests/02-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..dd99bfa2c63e46d7984bd67020c2ac6457183296
--- /dev/null
+++ "b/Curso de Git y GitHub/07-Gesti\303\263n de Cambios con Pull Requests/02-Lecturas recomendadas.txt"
@@ -0,0 +1,2 @@
+https://git-scm.com/docs/git-merge
+https://git-scm.com/docs/git-rebase
diff --git "a/Curso de Git y GitHub/07-Gesti\303\263n de Cambios con Pull Requests/02-Resumen.html" "b/Curso de Git y GitHub/07-Gesti\303\263n de Cambios con Pull Requests/02-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..a524ead29cdce66d3416d87075674998ad05f6d2
--- /dev/null
+++ "b/Curso de Git y GitHub/07-Gesti\303\263n de Cambios con Pull Requests/02-Resumen.html"
@@ -0,0 +1,113 @@
+
+
+
+
+
+
+ Creación y Gestión de Branches y Pull Requests en GitHub
+
+
+
+
+
+
Resumen
¿Cómo gestionar eficazmente los pull requests en un proyecto colaborativo?
+
La gestión correcta de los pull requests es fundamental para el flujo de trabajo en un proyecto de desarrollo colaborativo. Iniciamos cada día revisando los pull requests activos, como el de la clase anterior donde Miguel agregó métodos para los mejores superhéroes de Marvel. Es vital revisar cambios, como espacios ajustados o el código en verde que indica adiciones y en rojo que marca eliminaciones. Así, garantizamos que el código está limpio y bien organizado.
+
¿Cuál es la importancia de revisar y aprobar cambios?
+
La revisión minuciosa y aprobación de cambios en el código asegura que todo esté en orden antes de fusionar con la rama principal. Este proceso no solo depende de Cheyenne o cualquier otro colega, sino que compartimos esta responsabilidad. Una vez aprobado, fusionamos y eliminamos la rama si ya no es necesaria para mantener el repositorio organizado.
+
¿Cómo agregar nuevos métodos a una API existente?
+
Cuando se necesita añadir un nuevo método, como el método "Cursos Platzi" a la API, es crucial seguir ciertos pasos. Primero, abres una nueva rama y verificas estar en ella con git branch. Posteriormente, realizas los cambios en tu entorno de trabajo, por ejemplo, Visual Studio Code, asegurándote de seguir las convenciones del lenguaje, como dejar dos espacios entre métodos en Python.
+
¿Cómo realizar las commisiones y cambios en la API?
+
A continuación, ejecutas los siguientes comandos para realizar el commit de tus cambios:
+
gitadd.
+git commit -m"método de platzi agregado"
+
+
Luego, haces un push de los cambios para que puedan ser revisados.
+
¿Cuál es el proceso para manejar conflictos de código?
+
Sin embargo, antes de subir cambios es prudente asegurarte de que tu rama esté alineada con la rama principal para evitar conflictos. Esto implica realizar un git pull en la rama main, aplicar los cambios de la rama a tu nueva rama a través de git merge main, y resolver cualquier conflicto que surja en herramientas como Visual Studio Code.
+
¿Cómo resolver conflictos en Visual Studio Code?
+
En caso de conflictos, Visual Studio te permite seleccionar qué cambios conservar o combinar. Al resolverlos, haces un commit que confirma que has integrado tanto tus contribuciones como las de tus colegas.
+
¿Qué sigue después de resolver conflictos y fusionar cambios?
+
Finalmente, una vez certeros de que todos los cambios están fusionados y en orden, regresas a GitHub, creas un nuevo pull request pidiendo la aprobación de tus colegas. Este ciclo se repite, permitiendo una colaboración efectiva y un código base limpio y funcional.
+
La interacción regular con pull requests no solo fomenta el trabajo en equipo, sino que también mantiene la calidad del código. Aunque al inicio parezca complejo, con práctica, se convierte en un proceso casi automático, asegurando que todos los desarrolladores involucrados estén coordinados.
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Git y GitHub/07-Gesti\303\263n de Cambios con Pull Requests/03-Estrategias de Fusi\303\263n de Ramas en Git.mhtml" "b/Curso de Git y GitHub/07-Gesti\303\263n de Cambios con Pull Requests/03-Estrategias de Fusi\303\263n de Ramas en Git.mhtml"
new file mode 100644
index 0000000000000000000000000000000000000000..bb50d5d9fe1ecdc49c564d965d2df38b8edc1450
--- /dev/null
+++ "b/Curso de Git y GitHub/07-Gesti\303\263n de Cambios con Pull Requests/03-Estrategias de Fusi\303\263n de Ramas en Git.mhtml"
@@ -0,0 +1,21768 @@
+From:
+Snapshot-Content-Location: https://platzi.com/cursos/gitgithub/git-rebase/
+Subject: =?utf-8?Q?Estrategias=20de=20Fusi=C3=B3n=20de=20Ramas=20en=20Git?=
+Date: Sat, 8 Nov 2025 19:39:30 -0500
+MIME-Version: 1.0
+Content-Type: multipart/related;
+ type="text/html";
+ boundary="----MultipartBoundary--jw4DMeT2nsnGZQ3vyN4lHdKwjjMGdo4vqyJaYWDDJa----"
+
+
+------MultipartBoundary--jw4DMeT2nsnGZQ3vyN4lHdKwjjMGdo4vqyJaYWDDJa----
+Content-Type: text/html
+Content-ID:
+Content-Transfer-Encoding: quoted-printable
+Content-Location: https://platzi.com/cursos/gitgithub/git-rebase/
+
+Estrategias de Fusi=C3=B3n de =
+Ramas en Git
Muy buen=
+ curso, me sirvi=C3=B3 para complementar lo que ya sabia
Diego Alejandro C=C3=A1rdenas Garc=C3=ADa
@dcardenas=
+al=C2=B7
..
Ca=
+rlos Alberto Montoya Caicedo
@charlietoya=C2=B7
Me gusto el curso, aprend=C3=AD, s=C3=A9 =
+que no me va a servir para donde trabajo, pero si para la vida y quien sabe=
+ para despu=C3=A9s, entonces, me gust=C3=B3 mucho
Andrea Carolina Cas=
+tillo Penagos
@acastillo5712=C2=B7
Muy buen curso, recomendado tanto contenido como docente=
+.
EDDIN MARTINEZ ARIAS
@auxiliar.desarrollo273503=
+=C2=B7
Estuvo interesante=
+ el curso, se aprendi=C3=B3 cosas nuevas
Aprender el uso completo de git y no solo q=
+uedarme con lo b=C3=A1sico, git checkout, git branch, git merge, git push, =
+git pull, etc.
Richard Diaz
@rdiza_metroplan=C2=B7
Un paso m=C3=A1s cerca...
Gabriel Farias
@gfarias=
+=C2=B7
Muy bueno
0
Albert Jo=
+se Salas Yustiz
@albertjosalas=C2=B7
Este curso de Github esta muy actualizado con relaciona =
+a las herramientas que ofrece Github en el =C3=A1rea laboral, y ademas perm=
+ite refrescar conocimientos previos ya adquridos.
ursula ramirez
@innovatic.2=
+56=C2=B7
calidad aprendi mu=
+cho.
Carlos Eduardo Hernandez Carreno
@crloshernndez=C2=B7
exc=
+elente profesor
Diego Adri=C3=A1n Romero Almeida
@dromero9=
+3=C2=B7
El mejor curso de =
+todos
Ruben Dario Leon Rivera
@leon1989=C2=B7<=
+div class=3D"">
Excelente profesor y contenido p=
+ara el curso, aplicare el conocimiento en mi trabajo!
=
+=
+
Cesar Augusto Avenda=C3=B1o Gamboa
@cegav=C2=B7
Excelente curso para aprender o retomar n=
+uevamente comandos esenciales de git y el uso de herramientas nuevas que te=
+ proporciona Github
Ronaldo Jim=C3=A9nez
@JimcostDev=C2=
+=B7
Excelente curso, se aprende=
+ mucho, as=C3=AD tengas experiencia con git, recomendado para todos
Establece las b=
+ases esenciales de la inform=C3=A1tica, el desarrollo web con HTML, CSS, Ja=
+vaScript, el manejo de herramientas como Git y la terminal, y los principio=
+s de ingenier=C3=ADa de software.
El lenguaje de programación C es uno de los pilares en el mundo de la informática. No solo te servirá para aprender aspectos básicos de la programación, sino que te abrirá las puertas hacia campos apasionantes como la robótica. Ricardo Célis, instructor del curso introductorio en C, comparte su amor por este lenguaje, que le permitió participar en competencias de robótica y descubrir un mundo lleno de posibilidades.
+
C es un lenguaje tipado, esto significa que las variables deben declararse con un tipo de dato específico, permitiendo a la máquina saber cuánta memoria necesita. Aprender C te proporcionará las bases necesarias para programar en microcontroladores y sistemas embebidos, además de darte una comprensión profunda de cómo funcionan los lenguajes de programación.
+
¿Cómo está estructurado el aprendizaje del lenguaje C?
+
Platzi ha entendido que un solo curso no es suficiente para abarcar todo un lenguaje de programación en su complejidad. Por ello, la ruta de aprendizaje del lenguaje C está dividida en varios cursos, cada uno enfocado en diferentes niveles de dificultad y profundidad del tema.
+
+
Curso introductorio a C: Aprenderás lo básico del lenguaje, como la estructura típica de un programa en C, declaraciones de variables y tipos de datos.
+
Curso de programación en C: Este curso te enseñará a utilizar estructuras de control como ciclos if, for, while, además de importantes estructuras de datos, para que puedas escribir código más complejo.
+
Curso sobre bibliotecas en C: Explora las funciones estándar del lenguaje y bibliotecas predefinidas que enriquecerán tu conocimiento y habilidades en C.
+
Curso avanzado de C: Aquí aprenderás sobre manejo de memoria dinámica y punteros, llevándote a un nivel experto en este lenguaje.
+
+
¿Qué beneficios ofrece aprender C en la robótica?
+
C es una herramienta poderosa en el campo de la robótica, ideal para programar microcontroladores cruciales en sistemas robóticos. Su eficiencia y cercanía al hardware lo hacen perfecto para tareas que requieren manejar recursos limitados, como en los robots. Además, el aprendizaje de C te permitirá entender la base de lenguajes más modernos, permitiéndote adaptarte con facilidad a nuevas tecnologías.
+
¿Cómo puede ayudar aprender C a mejorar mi carrera profesional?
+
Aprender C puede significativamente mejorar tu perfil profesional. Este lenguaje es ampliamente utilizado en la industria, especialmente en áreas que demandan programación eficiente y optimizada como:
+
+
Desarrollo de sistemas embebidos: Aprenderás a programar dispositivos que interactúan directamente con el hardware.
+
Ingeniería de sistema y hardware: C se utiliza en el diseño de sistemas operativos y drivers de dispositivos.
+
Investigación y desarrollo: Profesionales con conocimientos en C son esenciales para innovar y crear soluciones en sectores de alta tecnología.
+
+
Este curso introductorio y los siguientes están diseñados no solo para enriquecer tu conocimiento técnico, sino para motivarte a seguir aprendiendo y expandiendo tus horizontes. ¡Anímate a embarcarte en el conocimiento y dominar el lenguaje C!
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/01-presentacion-curso-de-introduccion-a-c_03d52e2b-ae7d-4f48-a639-97796abeae8f.pdf" "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/01-presentacion-curso-de-introduccion-a-c_03d52e2b-ae7d-4f48-a639-97796abeae8f.pdf"
new file mode 100644
index 0000000000000000000000000000000000000000..6a0ef9602d58719e25c6f216a719b094002d2834
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/01-presentacion-curso-de-introduccion-a-c_03d52e2b-ae7d-4f48-a639-97796abeae8f.pdf"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d3b2a04587f96a45f194f18308485d5238f9c1037eff93ca8213af59ef68e475
+size 287073
diff --git "a/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/02-Lecturas recomendadas.txt" "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/02-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..6bcf0a828656df7681b77e79c2b4901b9a405d05
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/02-Lecturas recomendadas.txt"
@@ -0,0 +1 @@
+https://platzi.com/clases/pic/
diff --git "a/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/02-Programaci\303\263n en C Estructuras Funciones y Memoria.mp4" "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/02-Programaci\303\263n en C Estructuras Funciones y Memoria.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..0bbb62f5da07ca97c5673dfe220de33a7e7e3e84
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/02-Programaci\303\263n en C Estructuras Funciones y Memoria.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1a78588c1f2d67a1a3a1996561ae58d20ca2a7ab769b52c1552d24cf9f0df741
+size 176823214
diff --git "a/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/02-Programaci\303\263n en C Estructuras Funciones y Memoria.vtt" "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/02-Programaci\303\263n en C Estructuras Funciones y Memoria.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..4ad4a0d29af0c9486b9160758a33b282ef55370b
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/02-Programaci\303\263n en C Estructuras Funciones y Memoria.vtt"
@@ -0,0 +1,1536 @@
+WEBVTT
+
+00:00.000 --> 00:03.000
+¿Cómo ejecutar un código en
+C?
+
+00:03.500 --> 00:06.200
+El lenguaje C es un lenguaje de
+programación
+
+00:06.200 --> 00:07.900
+de tipo
+estructurada,
+
+00:07.900 --> 00:10.200
+es decir, vamos a ir ejecutando las
+instrucciones
+
+00:10.200 --> 00:13.500
+de nuestro código en una orden
+específico
+
+00:13.500 --> 00:14.700
+que nosotros
+tengamos.
+
+00:14.700 --> 00:16.900
+Suele ser, comienza en la primera
+línea
+
+00:16.900 --> 00:19.000
+y de ahí para abajo,
+simplemente,
+
+00:19.000 --> 00:21.300
+vamos a ir ejecutando línea a
+línea
+
+00:21.300 --> 00:22.900
+todo el código que
+tengamos.
+
+00:22.900 --> 00:25.400
+Obviamente, vamos a poder utilizar librerías,
+
+00:25.400 --> 00:26.800
+vamos a poder
+utilizar...
+
+00:26.800 --> 00:29.300
+Aquí no existe tal cosa como, por ejemplo,
+
+00:29.300 --> 00:30.800
+las clases y los
+objetos,
+
+00:30.800 --> 00:32.300
+pero existen los
+structs,
+
+00:32.300 --> 00:35.100
+que puedes verlo como los abuelitos de
+clases y objetos
+
+00:35.100 --> 00:37.500
+si vienes del paradigma orientado a objetos.
+
+00:37.500 --> 00:39.700
+Vamos a poder también crear
+funciones
+
+00:39.700 --> 00:42.100
+y todo esto nos va a permitir hacer
+programas
+
+00:42.100 --> 00:44.900
+que tengan el flujo que nosotros querramos.
+
+00:44.900 --> 00:47.200
+Ahora, C es un lenguaje, como te digo,
+
+00:47.200 --> 00:50.600
+de programación con el paradigma estructurado.
+
+00:50.600 --> 00:53.300
+Este es un lenguaje que soporta
+recursividad
+
+00:53.300 --> 00:55.300
+o
+recursión,
+
+00:55.300 --> 00:58.400
+es un lenguaje que también tiene un estado,
+
+00:58.400 --> 01:01.300
+un tipo estático de
+tipado,
+
+01:01.300 --> 01:03.600
+es un lenguaje que se podría
+considerar
+
+01:03.600 --> 01:04.900
+fuertemente
+tipado.
+
+01:04.900 --> 01:06.100
+Tienes que
+decirle
+
+01:06.100 --> 01:08.300
+de qué tipo de datos van a ser tus variables,
+
+01:08.300 --> 01:11.300
+cuánta capacidad de memoria vas a poder
+almacenar,
+
+01:11.300 --> 01:14.000
+qué tamaño van a tener tus
+datos
+
+01:14.000 --> 01:15.000
+que vas a estar
+manejando.
+
+01:15.000 --> 01:16.100
+Eso es muy
+maravilloso
+
+01:16.100 --> 01:18.400
+y lo vamos a ver en cursos más avanzados,
+
+01:18.400 --> 01:20.200
+todo lo que tiene que ver con manejo de
+memoria.
+
+01:20.200 --> 01:22.000
+De hecho, ese va a ser un curso
+entero
+
+01:22.000 --> 01:24.500
+de la ruta de estudio que yo te
+propongo
+
+01:24.500 --> 01:26.100
+que tomes para aprender en
+C.
+
+01:26.100 --> 01:29.600
+Y es un lenguaje que se ocupa
+muchísimo
+
+01:29.600 --> 01:33.500
+en aplicaciones como sistemas operativos,
+
+01:33.500 --> 01:35.300
+software de
+aplicación,
+
+01:35.300 --> 01:38.100
+se ocupa muchísimo en drivers, por ejemplo,
+
+01:38.100 --> 01:40.700
+se ocupa mucho en algunas
+supercomputadoras
+
+01:40.700 --> 01:42.200
+para hacer cálculos
+veloces,
+
+01:42.200 --> 01:45.200
+se ocupa sobre todo en sistemas embebidos,
+
+01:45.200 --> 01:47.900
+es el rey que tú vas a
+encontrar.
+
+01:47.900 --> 01:50.500
+Por ejemplo, el firmware del tablero de tu
+coche,
+
+01:50.500 --> 01:52.100
+de tu
+vehículo,
+
+01:52.100 --> 01:54.700
+ves que el tablero ya son
+digitales
+
+01:54.700 --> 01:58.200
+y tienen pantallitas y tienen el tacómetro
+digital
+
+01:58.200 --> 02:00.700
+y tienen el sensor que mide cuánta
+gasolina te queda
+
+02:00.700 --> 02:02.800
+y tienen el sensor de temperatura en el motor,
+
+02:02.800 --> 02:04.800
+todo eso, ¿adivina quién lo
+coordina?
+
+02:04.800 --> 02:08.100
+Lo coordina un código en C de bajo
+nivel
+
+02:08.100 --> 02:09.800
+que se comunica con los
+sensores,
+
+02:09.800 --> 02:12.900
+los puede leer y te puede mostrar luego la
+información
+
+02:12.900 --> 02:15.200
+comunicándose con las
+pantallas.
+
+02:15.200 --> 02:18.700
+C es un lenguaje que de verdad está en
+todos lados,
+
+02:18.700 --> 02:19.900
+en todo lo que
+ocupas,
+
+02:19.900 --> 02:25.100
+muy probablemente algunos firmware o sistemas,
+
+02:25.100 --> 02:27.700
+código de bajo nivel dentro de tu
+celular
+
+02:27.700 --> 02:29.900
+va a estar escrito con
+C.
+
+02:30.800 --> 02:32.400
+En la industria, los
+PLCs,
+
+02:32.400 --> 02:34.900
+que son Programmable Logic
+Controller
+
+02:34.900 --> 02:36.900
+o controlador lógico
+programable,
+
+02:36.900 --> 02:40.300
+son microcontroladores que tienen
+circuitos específicos
+
+02:40.300 --> 02:43.000
+para poder ser
+circuitos
+
+02:43.000 --> 02:44.800
+que le permiten ser
+industriales,
+
+02:44.800 --> 02:46.300
+soportar voltajes más
+altos,
+
+02:46.300 --> 02:49.500
+soportar ciertos entornos, temperaturas,
+humedades,
+
+02:49.500 --> 02:51.700
+que el fabricante te va a permitir decir.
+
+02:51.700 --> 02:53.900
+También tienen firmware
+específico
+
+02:53.900 --> 02:56.400
+para que estos te permitan ser
+programados
+
+02:56.400 --> 02:58.900
+con el propio software que te da el
+fabricante.
+
+02:58.900 --> 03:01.200
+Muchas veces no tienes que escribir
+directamente
+
+03:01.200 --> 03:02.300
+código como
+tal,
+
+03:02.300 --> 03:03.600
+no tienes que escribir código en
+C
+
+03:03.600 --> 03:05.500
+porque ya te dan una simplificación,
+
+03:05.500 --> 03:08.000
+un nivel arriba que algunos de forma
+gráfica
+
+03:08.000 --> 03:09.200
+puedes ir
+escribiendo,
+
+03:09.200 --> 03:12.700
+otros muy tradicionalmente en el famoso
+lenguaje
+
+03:12.700 --> 03:15.200
+o del sistema de programación de escalera,
+
+03:15.200 --> 03:17.600
+en donde vas poniendo las instrucciones
+que quieres que haga,
+
+03:17.600 --> 03:19.600
+haces los bucles y eso es
+todo.
+
+03:19.600 --> 03:25.200
+También estos son el pan de cada día en la
+industria.
+
+03:25.200 --> 03:26.500
+Muchos
+sistemas,
+
+03:26.500 --> 03:28.800
+o yo diría que la gran mayoría de los
+sistemas,
+
+03:28.800 --> 03:29.900
+si no es que
+todos,
+
+03:29.900 --> 03:32.100
+hoy en día están en las
+industrias,
+
+03:32.100 --> 03:33.600
+en las
+fábricas,
+
+03:33.600 --> 03:35.900
+en las tiras de
+ensamblaje,
+
+03:35.900 --> 03:37.400
+están hechos con
+PLCs,
+
+03:37.400 --> 03:39.100
+están controlando todo
+esto
+
+03:39.100 --> 03:42.300
+y C, obviamente, está adentro de ellos.
+
+03:42.300 --> 03:44.800
+Muchas veces no programas directamente en C,
+
+03:44.800 --> 03:46.600
+pero el software que te da el fabricante,
+
+03:46.600 --> 03:49.700
+lo que hace es pasar ese código a un
+lenguaje intermedio
+
+03:49.700 --> 03:50.800
+que podría ser
+C
+
+03:50.800 --> 03:53.000
+y después a el lenguaje
+máquina
+
+03:53.000 --> 03:55.700
+que va a entender nuestro
+microcontrolador
+
+03:55.700 --> 03:57.100
+adentro del
+PLC.
+
+03:57.100 --> 03:59.900
+Ahora, si te interesa todo este mundo de
+hardware,
+
+03:59.900 --> 04:01.000
+tengo un curso para
+ti
+
+04:01.000 --> 04:03.200
+que es el curso de programación de
+microcontroladores.
+
+04:03.200 --> 04:06.000
+Dicho esto, veamos más sobre
+C.
+
+04:06.000 --> 04:09.200
+Este lenguaje fue creado por el genio de
+la computación,
+
+04:09.200 --> 04:11.900
+conocido como de las ciencias de la
+computación
+
+04:11.900 --> 04:12.900
+para hacer de
+honor,
+
+04:12.900 --> 04:14.900
+conocido como Dennis
+Ritchie.
+
+04:14.900 --> 04:17.200
+Él trabajaba en los laboratorios de
+Bell
+
+04:17.200 --> 04:21.900
+y lo desarrolló durante 1972 y 1973.
+
+04:21.900 --> 04:24.300
+La idea era que él quería un
+lenguaje
+
+04:24.300 --> 04:25.800
+que fuera más
+comprensible,
+
+04:25.800 --> 04:29.100
+que fuera principalmente
+útil
+
+04:29.100 --> 04:30.500
+para desarrollar
+aplicaciones
+
+04:30.500 --> 04:32.700
+en el sistema operativo
+Unix,
+
+04:32.700 --> 04:35.800
+que se podría decir es el papá de sistemas
+operativos
+
+04:35.800 --> 04:38.200
+que conocemos hoy en día como Linux,
+por ejemplo,
+
+04:38.200 --> 04:39.900
+si estás familiarizado con
+ellos,
+
+04:39.900 --> 04:42.000
+muchas cosas del mundo corren en Linux,
+
+04:42.000 --> 04:43.200
+sobre todo
+servidores
+
+04:43.200 --> 04:46.800
+y cuestiones más de computación
+profesional
+
+04:46.800 --> 04:48.100
+y de alto
+rendimiento,
+
+04:48.100 --> 04:49.600
+o inclusive de algunas
+personas
+
+04:49.600 --> 04:52.300
+que simplemente no quieren utilizar
+software privativo,
+
+04:52.300 --> 04:54.400
+sino que prefieren utilizar software libre,
+
+04:54.400 --> 04:56.800
+como Ubuntu, por poner algún ejemplo,
+
+04:56.800 --> 05:00.100
+o cualquiera de las algunas otras
+distribuciones Linux
+
+05:00.100 --> 05:03.000
+que cumplen con la licencia
+GNU.
+
+05:03.000 --> 05:06.000
+Dicho esto, el señor Dennis
+Ritchie
+
+05:06.000 --> 05:07.900
+fue el creador de este
+lenguaje.
+
+05:07.900 --> 05:09.000
+Él quería hacer un
+lenguaje
+
+05:09.000 --> 05:11.800
+que también fuera compatible con otros
+sistemas operativos
+
+05:11.800 --> 05:13.800
+y que permitiera la
+portabilidad.
+
+05:13.800 --> 05:16.600
+Y aquí quiero darte una información muy
+importante.
+
+05:16.600 --> 05:19.300
+El lenguaje C es un lenguaje compilado.
+
+05:19.300 --> 05:20.500
+¿Qué quiere decir
+esto?
+
+05:20.500 --> 05:23.600
+Es un lenguaje que tú necesitas pasar por
+el compilador,
+
+05:23.600 --> 05:24.600
+decirle al
+compilador
+
+05:24.600 --> 05:27.000
+a qué sistema operativo quieres que apunte,
+
+05:27.000 --> 05:28.600
+si quieres que sea para
+Unix
+
+05:28.600 --> 05:29.900
+o para alguna otra
+distribución
+
+05:29.900 --> 05:31.500
+de algún otro sistema
+operativo.
+
+05:31.500 --> 05:33.800
+Por ejemplo, hoy en día podemos
+decir
+
+05:33.800 --> 05:35.100
+si quieres que sea para
+Linux,
+
+05:35.100 --> 05:36.600
+si quieres que sea para
+Windows,
+
+05:36.600 --> 05:38.300
+tienes que decirle al
+compilador
+
+05:38.300 --> 05:39.700
+y el compilador se va a
+encargar
+
+05:39.700 --> 05:41.700
+de agarrar tu código escrito en lenguaje
+C
+
+05:41.700 --> 05:45.300
+y vas a poder generar un
+ejecutable
+
+05:45.300 --> 05:47.200
+ya sea para el sistema operativo
+Windows
+
+05:47.200 --> 05:49.400
+o para el sistema operativo
+Linux.
+
+05:49.400 --> 05:52.100
+Ahora, muchas veces el
+código
+
+05:52.100 --> 05:53.900
+no va a funcionar
+directamente
+
+05:53.900 --> 05:56.500
+en los otros sistemas operativos sin cambios.
+
+05:57.000 --> 06:00.400
+Hay que ser conscientes de que para que un
+código en C
+
+06:00.400 --> 06:02.500
+pueda usarse en otros sistemas operativos,
+
+06:02.500 --> 06:05.600
+tienes que diseñar el código con
+portabilidad en mente.
+
+06:05.600 --> 06:08.400
+Y ahí es que sigas los estándares de ANSI
+C
+
+06:08.400 --> 06:10.500
+y que seas capaz de
+decidir,
+
+06:10.500 --> 06:12.100
+ah, ok, esta es una
+librería
+
+06:12.100 --> 06:14.300
+que me va a funcionar específicamente en
+Windows,
+
+06:14.300 --> 06:17.200
+ok, entonces voy a escribir una función
+para Windows
+
+06:17.200 --> 06:19.100
+y puedo escribir con
+portabilidad,
+
+06:19.100 --> 06:21.400
+puedo decir que según el
+código,
+
+06:21.400 --> 06:23.800
+el sistema operativo que estoy compilando
+en este momento,
+
+06:23.800 --> 06:27.600
+entonces utilice esta función o utilice
+esta función.
+
+06:27.600 --> 06:29.300
+Son cosas que se pueden hacer en
+C,
+
+06:29.300 --> 06:32.000
+lo vamos a ver de nuevo en los cursos más
+avanzados.
+
+06:32.000 --> 06:33.900
+Ahora, con esto
+dicho,
+
+06:33.900 --> 06:37.400
+no quiere decir que sea como por ejemplo
+JavaScript
+
+06:37.400 --> 06:39.000
+que lo puedes ejecutar en el
+navegador
+
+06:39.000 --> 06:40.800
+de cualquier sistema
+operativo,
+
+06:40.800 --> 06:43.700
+porque JavaScript tiene su
+motor,
+
+06:43.700 --> 06:46.100
+su runtime en donde se va a ejecutar.
+
+06:46.100 --> 06:49.300
+Por ejemplo, Node.js es un runtime
+environment,
+
+06:49.300 --> 06:52.400
+un ambiente de tiempo de ejecución para
+JavaScript,
+
+06:52.400 --> 06:56.600
+o V8, que es el motor con el que los
+navegadores como Chrome
+
+06:56.600 --> 07:00.100
+pueden utilizar o pueden ejecutar código
+JavaScript, ok.
+
+07:00.100 --> 07:03.200
+Eso es lo que se encarga de traducir ese
+código
+
+07:03.200 --> 07:05.800
+a tu computadora, el motor del navegador.
+
+07:05.800 --> 07:08.500
+¿Por qué? Porque JavaScript no es un
+lenguaje
+
+07:08.500 --> 07:10.000
+que necesite ser
+compilado.
+
+07:10.000 --> 07:11.400
+En cambio C,
+sí.
+
+07:11.400 --> 07:14.000
+Esta compilación simplemente es que le das
+clic a un botón,
+
+07:14.000 --> 07:17.000
+el compilador se va a encargar de traducir
+tu código en C
+
+07:17.000 --> 07:20.200
+al código máquina del sistema al que tú le
+estás apuntando,
+
+07:20.200 --> 07:22.400
+y entonces te va a permitir ejecutarlo.
+
+07:22.400 --> 07:25.700
+Ese paso de compilación hay muchos
+lenguajes
+
+07:25.700 --> 07:27.700
+que no necesariamente lo van a tener.
+
+07:27.700 --> 07:31.900
+Por ejemplo, Java es un lenguaje que es
+mucho más portable
+
+07:31.900 --> 07:36.600
+porque se ejecuta en la Java Virtual Machine,
+JVM.
+
+07:36.600 --> 07:38.700
+Y eso le permite que un solo código,
+
+07:38.700 --> 07:40.900
+sin ningún cambio en su
+escritura,
+
+07:40.900 --> 07:43.400
+se pueda ejecutar en varios sistemas
+operativos.
+
+07:43.400 --> 07:45.200
+Eso es una de las claves que hizo que
+Java
+
+07:45.200 --> 07:47.800
+se volviera muy, muy popular en su
+tiempo
+
+07:47.800 --> 07:49.200
+y hasta hoy en
+día.
+
+07:49.200 --> 07:53.000
+Tenemos otros casos de lenguajes, como por
+ejemplo C Sharp,
+
+07:53.000 --> 07:56.300
+que buscan cierto nivel de
+equilibrio
+
+07:56.300 --> 07:59.700
+entre rendimiento y entre tiempo de
+ejecución
+
+07:59.700 --> 08:00.900
+y facilidad de
+escribir.
+
+08:00.900 --> 08:04.200
+Ahora, C, ¿qué gana al ser un lenguaje
+compilado?
+
+08:04.200 --> 08:07.800
+¿Qué es un lenguaje que te permite tener
+mucho control de la memoria?
+
+08:07.800 --> 08:09.700
+¿Es un lenguaje que te permite
+tener
+
+08:09.700 --> 08:11.800
+mucha velocidad en tiempo de
+ejecución?
+
+08:11.800 --> 08:14.200
+Y justo vamos a ver eso volviendo a mis
+slides.
+
+08:14.200 --> 08:18.600
+Quiero empezar diciéndote que C es un
+lenguaje de nivel intermedio.
+
+08:18.600 --> 08:22.400
+Es decir, aquí quiero repasar un
+poquito
+
+08:22.400 --> 08:24.400
+los niveles de los lenguajes de programación.
+
+08:24.400 --> 08:27.400
+Recuerda que los lenguajes de más alto
+nivel
+
+08:27.400 --> 08:29.600
+van a ser los lenguajes más fáciles de
+entender
+
+08:29.600 --> 08:31.200
+para los humanos, para
+nosotros.
+
+08:31.200 --> 08:34.800
+Por ejemplo, aquí tenemos Perl, Python, Shell,
+JavaScript.
+
+08:34.800 --> 08:38.400
+Son lenguajes que generalmente son
+interpretados.
+
+08:38.400 --> 08:41.100
+Es decir, van a correr en su propio
+intérprete
+
+08:41.100 --> 08:44.400
+que luego se va a encargar de pasarlo a la
+computadora.
+
+08:44.400 --> 08:45.600
+Hablemos de
+JavaScript.
+
+08:45.600 --> 08:49.200
+Y es que aquí quiero que veas cómo C y C++
+existen en todo.
+
+08:49.200 --> 08:51.700
+JavaScript es un lenguaje interpretado.
+
+08:51.700 --> 08:53.900
+Ya te dije, se interpreta por su motor.
+
+08:53.900 --> 08:54.500
+¿Ok?
+
+08:54.500 --> 08:57.700
+Este intérprete, el intérprete de JavaScript,
+
+08:57.700 --> 08:59.300
+o el motor que nos va a permitir ejecución,
+
+08:59.300 --> 09:01.100
+¿en qué lenguaje crees que esté
+escrito?
+
+09:01.100 --> 09:02.200
+Pues
+sí.
+
+09:02.200 --> 09:04.900
+Por ejemplo, el motor B8 que utiliza
+Chrome
+
+09:04.900 --> 09:07.500
+para poder interpretar el JavaScript del
+navegador
+
+09:07.500 --> 09:11.900
+está escrito en el lenguaje
+C++,
+
+09:11.900 --> 09:15.400
+que es como una evolución que existió más
+adelante.
+
+09:15.400 --> 09:17.500
+Eso te dice mucho,
+¿no?
+
+09:17.500 --> 09:19.600
+De por qué pasan estas
+cosas,
+
+09:19.600 --> 09:22.700
+por qué JavaScript no puede correr
+directamente en el hardware.
+
+09:22.700 --> 09:24.100
+Necesita ser
+interpretado.
+
+09:24.100 --> 09:25.300
+Así es como
+funciona.
+
+09:25.300 --> 09:27.900
+Tenemos lenguajes de alto o medio nivel,
+
+09:27.900 --> 09:29.700
+como C y
+C++,
+
+09:29.700 --> 09:32.700
+que son lenguajes ya mucho más abstractos.
+
+09:32.700 --> 09:34.800
+Estos no se ocupan tanto en
+aplicaciones
+
+09:34.800 --> 09:37.300
+que son gráficas o para el
+usuario.
+
+09:37.300 --> 09:40.400
+En el caso de C, en el caso de C++, sí,
+
+09:40.400 --> 09:42.300
+porque tiene muchas facilidades para esto.
+
+09:42.300 --> 09:43.400
+Tiene más
+librerías,
+
+09:43.400 --> 09:44.800
+tiene
+más...
+
+09:44.800 --> 09:47.500
+Como todo el paradigma orientado a
+objetos
+
+09:47.500 --> 09:49.200
+ya está implementado en
+C++.
+
+09:49.200 --> 09:51.600
+Y, de hecho, es un lenguaje que siguen
+manteniendo.
+
+09:51.600 --> 09:54.800
+Y, bueno, simplemente Bjorn Strostrup,
+
+09:54.800 --> 09:56.400
+que es el creador de
+C++,
+
+09:56.400 --> 09:59.700
+todavía sigue trabajando en él y creando
+nuevos features.
+
+09:59.700 --> 10:01.300
+No salen cada
+año.
+
+10:01.300 --> 10:04.200
+Salen cada cuatro a veces los años que les
+tomen,
+
+10:04.200 --> 10:07.000
+pero pueden seguir generando nuevas cosas.
+
+10:07.000 --> 10:08.700
+Esto es, por
+ejemplo,
+
+10:08.700 --> 10:11.700
+el lenguaje en el que está escrito la
+mayoría del malware.
+
+10:11.700 --> 10:12.900
+¿Por
+qué?
+
+10:12.900 --> 10:14.500
+Y aquí quiero que
+pienses.
+
+10:15.500 --> 10:17.600
+Simple y sencillamente porque son
+lenguajes
+
+10:17.600 --> 10:19.300
+que te dejan acceder a la
+memoria,
+
+10:19.300 --> 10:20.700
+que te dejan acceder a
+cosas
+
+10:20.700 --> 10:23.800
+muy, muy adentro de tu
+computadora
+
+10:23.800 --> 10:25.600
+que estos otros lenguajes
+no.
+
+10:25.600 --> 10:27.800
+¿Y para qué sirve acceder a la
+memoria?
+
+10:27.800 --> 10:31.400
+Bueno, con estos lenguajes un hacker puede
+hacer cosas increíbles,
+
+10:31.400 --> 10:34.700
+como detectar si un software que estás
+corriendo, digamos, un...
+
+10:35.400 --> 10:37.500
+Hablemos de un software general que te
+bajaste
+
+10:37.500 --> 10:40.300
+para poder grabar tu
+pantalla.
+
+10:40.300 --> 10:43.200
+Ahorita está de moda esto de capturar
+pantalla,
+
+10:43.200 --> 10:44.200
+generar
+video.
+
+10:44.200 --> 10:45.900
+Bueno, estás capturando tu pantalla,
+
+10:45.900 --> 10:48.600
+bajaste un software que fue desarrollado
+sin buenas prácticas
+
+10:48.600 --> 10:51.100
+y ese software tiene un leak de memoria.
+
+10:51.100 --> 10:52.600
+¿Qué significa un leak de
+memoria?
+
+10:52.600 --> 10:56.200
+Que hay ciertas variables que habían
+declarado
+
+10:56.200 --> 10:57.400
+o algo por el
+estilo
+
+10:57.400 --> 11:01.200
+y no estaban
+entrando
+
+11:01.200 --> 11:03.900
+en la cantidad de memoria reservado para
+esas variables.
+
+11:03.900 --> 11:06.000
+O algún error como que, por ejemplo,
+
+11:06.000 --> 11:09.800
+el software tenía o accedía a un permiso
+que no debería
+
+11:09.800 --> 11:13.100
+y dejaba guardadas las credenciales en la
+memoria.
+
+11:13.100 --> 11:15.100
+¿Por qué? Porque no estaban con la buena
+práctica
+
+11:15.100 --> 11:16.800
+de tenerlo encriptado, lo que
+sea.
+
+11:16.800 --> 11:18.100
+¿Qué pasa
+ahí?
+
+11:18.100 --> 11:21.300
+Bueno, tú con C puedes acceder a la
+memoria de la computadora,
+
+11:21.300 --> 11:24.900
+empezar a buscar y puedes encontrar estos
+exploits,
+
+11:24.900 --> 11:26.400
+puedes abusar de
+ellos
+
+11:26.400 --> 11:28.700
+y puedes generar un caos en las computadoras.
+
+11:28.700 --> 11:32.700
+De hecho, muchos hackers que de verdad
+encuentran exploits
+
+11:32.700 --> 11:35.700
+a nivel como los que han pasado con los
+CPUs Intel,
+
+11:35.700 --> 11:39.000
+en donde son cosas que pasan durante el
+tiempo de ejecución
+
+11:39.000 --> 11:42.100
+dentro del caché del CPU, cosas de ese estilo,
+
+11:42.100 --> 11:46.300
+se hacen con mucho código directo, código C,
+
+11:46.300 --> 11:48.000
+que es de mucho más bajo
+nivel
+
+11:48.000 --> 11:50.500
+y les permite tener acceso a estas
+cosas
+
+11:50.500 --> 11:52.700
+que normalmente nunca tendrías
+acceso
+
+11:52.700 --> 11:54.300
+con un lenguaje de alto
+nivel.
+
+11:54.300 --> 11:57.900
+¿Por qué? Porque el intérprete no te
+dejaría pasar a ello.
+
+11:57.900 --> 12:01.700
+Luego, tenemos lenguaje de montaje o
+lenguaje ensamblador.
+
+12:01.700 --> 12:05.200
+El lenguaje ensamblador puede ser el Intel
+x86,
+
+12:05.200 --> 12:10.400
+que son los sets de instrucciones que da
+el fabricante del CPU.
+
+12:10.400 --> 12:12.200
+Entonces, aquí por
+suerte,
+
+12:12.200 --> 12:14.200
+hubo una época en donde se
+estandarizó
+
+12:14.200 --> 12:16.200
+e Intel sacó
+x86,
+
+12:16.200 --> 12:19.100
+que es un set de instrucciones para sus CPUs,
+
+12:19.100 --> 12:20.800
+principalmente de 32
+bits,
+
+12:20.800 --> 12:22.500
+y AMD lo adaptó
+también,
+
+12:22.500 --> 12:24.500
+que eran los principales fabricantes de CPUs.
+
+12:24.500 --> 12:26.700
+AMD sacó
+AMD64,
+
+12:26.700 --> 12:28.700
+que era una extensión a los
+sets
+
+12:28.700 --> 12:32.700
+o a todo lo que tenían como set de
+instrucciones de x86,
+
+12:32.700 --> 12:34.600
+que había sacado originalmente Intel,
+
+12:34.600 --> 12:38.500
+y se volvió el estándar para CPUs de 64 bits.
+
+12:38.500 --> 12:40.600
+El hecho de que esto sea
+estándar
+
+12:40.600 --> 12:43.800
+permite que tú tengas una computadora con
+un CPU AMD
+
+12:43.800 --> 12:45.400
+o con un CPU
+Intel
+
+12:45.400 --> 12:47.000
+y que no pase
+nada
+
+12:47.000 --> 12:49.300
+de que tú simplemente puedes instalarle
+Windows
+
+12:49.300 --> 12:50.600
+a cualquiera de las
+dos
+
+12:50.600 --> 12:52.800
+y no tienes que bajarte una versión de
+Windows
+
+12:52.800 --> 12:55.200
+para AMD y una versión de Windows para Intel.
+
+12:55.200 --> 12:55.900
+¿Por
+qué?
+
+12:55.900 --> 12:58.300
+Porque todos los CPUs modernos hoy en
+día
+
+12:58.300 --> 13:01.800
+ocupan el set de instrucciones AMD64.
+
+13:01.800 --> 13:04.100
+Simple y sencillamente, ese es el estándar.
+
+13:04.100 --> 13:06.100
+Tienen interfaces de 64
+bits
+
+13:06.100 --> 13:09.100
+y es lo que tenemos hoy en
+día.
+
+13:09.100 --> 13:12.400
+Antes, cuando existían CPUs en el mercado
+de 32 bits
+
+13:12.400 --> 13:15.400
+y de 64 bits, sí existe
+software.
+
+13:15.400 --> 13:18.600
+De hecho, todavía existe software que te
+pide forzosamente
+
+13:18.600 --> 13:21.700
+que tengas instalado un CPU de 64 bits,
+
+13:21.700 --> 13:24.000
+pero no importa si es AMD o
+Intel.
+
+13:24.000 --> 13:26.100
+Aquí quiero que veas la maravilla que
+pasó
+
+13:26.100 --> 13:28.400
+de que se lograron poner de acuerdo dos
+compañías
+
+13:28.400 --> 13:29.800
+que son
+competencia
+
+13:29.800 --> 13:31.100
+y tuvieron un
+estándar.
+
+13:31.100 --> 13:33.200
+Esto nos permite mucha
+portabilidad
+
+13:33.200 --> 13:35.500
+en software a nivel sistema operativo.
+
+13:35.500 --> 13:38.800
+Repito, si tú tienes un CPU Intel o un AMD,
+
+13:38.800 --> 13:41.200
+no importa, te bajas Windows 10 y lo instalas.
+
+13:41.200 --> 13:43.400
+Te bajas Ubuntu y lo
+instalas.
+
+13:43.400 --> 13:46.200
+Ahí, si tienes una computadora muy
+vieja
+
+13:46.200 --> 13:47.700
+que es de 32
+bits,
+
+13:47.700 --> 13:49.400
+entonces sí tienes que
+buscar
+
+13:49.400 --> 13:52.100
+sistemas operativos compatibles a 32 bits,
+
+13:52.100 --> 13:54.400
+pero de nuevo, dentro de los de 32 bits,
+
+13:54.400 --> 13:56.000
+es decir, de
+x86,
+
+13:56.000 --> 13:58.500
+no importa si es AMD o
+Intel,
+
+13:58.500 --> 14:00.300
+si te bajas un Windows de 32
+bits,
+
+14:00.300 --> 14:01.900
+lo vas a poder instalar
+ahí.
+
+14:01.900 --> 14:04.300
+¿Ok? Todo en orden
+entonces.
+
+14:04.300 --> 14:07.200
+Por último, tenemos representación
+hexadecimal,
+
+14:07.200 --> 14:08.400
+que es el lenguaje
+máquina.
+
+14:08.400 --> 14:11.900
+Esto ya es lo que directamente termina en
+los archivos finales
+
+14:11.900 --> 14:13.800
+para que nuestro sistema
+operativo
+
+14:13.800 --> 14:15.500
+lo pueda
+interpretar.
+
+14:15.500 --> 14:17.500
+Y tenemos el código
+binario,
+
+14:17.500 --> 14:20.300
+que ya es lo único que pueden leer los CPUs.
+
+14:20.300 --> 14:23.600
+Los CPUs funcionan a base de
+transistores
+
+14:23.600 --> 14:25.800
+y a base de código binario, ceros y unos.
+
+14:25.800 --> 14:29.100
+Eso es todo lo que mueve nuestro mundo actual.
+
+14:29.100 --> 14:33.200
+La tecnología, el software, todo es ceros
+y unos.
+
+14:33.200 --> 14:35.500
+Y eso se llama código
+binario.
+
+14:36.100 --> 14:39.200
+Ahora, aquí quiero que veas esta imagen de
+apoyo.
+
+14:39.200 --> 14:41.000
+Recuerda que puedes descargar estos slides.
+
+14:41.000 --> 14:43.500
+Aquí tenemos como el nivel del lenguaje,
+
+14:43.500 --> 14:45.200
+si es de bajo o alto
+nivel.
+
+14:45.200 --> 14:47.800
+Esto no quiere decir que es un lenguaje
+malo o bueno, para nada.
+
+14:47.800 --> 14:49.800
+Hay un lenguaje para cada aplicación.
+
+14:49.800 --> 14:51.800
+Por ejemplo, C y C++ para videojuegos,
+
+14:51.800 --> 14:54.000
+C para hardware
+embedido,
+
+14:54.000 --> 14:55.600
+para todo lo que ya te
+dije,
+
+14:55.600 --> 14:58.000
+sistema de desarrollo de drivers para tu
+computadora,
+
+14:58.000 --> 15:00.100
+cuestiones de alto
+rendimiento.
+
+15:00.100 --> 15:04.100
+Y tenemos como Python para todo lo que es
+data science,
+
+15:04.100 --> 15:06.900
+tenemos Python para desarrollo web, sobre
+todo backend.
+
+15:06.900 --> 15:08.800
+Tenemos JavaScript para desarrollo web,
+
+15:08.800 --> 15:11.100
+principalmente frontend, también se puede
+backend.
+
+15:11.100 --> 15:13.900
+Tenemos un lenguaje para cada aplicación.
+
+15:13.900 --> 15:16.300
+Por favor, nunca te cierres a aprender un
+solo lenguaje
+
+15:16.300 --> 15:18.300
+y querer hacer todo con ese lenguaje.
+
+15:18.300 --> 15:19.300
+No.
+
+15:19.300 --> 15:22.000
+Aprende un lenguaje según la aplicación
+que tú tengas.
+
+15:22.000 --> 15:24.500
+Total, si entiendes de verdad de computación,
+
+15:24.500 --> 15:27.000
+vas a poder entender cualquier
+lenguaje
+
+15:27.000 --> 15:29.900
+porque todos tienen muchos principios muy
+similares.
+
+15:29.900 --> 15:31.600
+Entonces, siguiendo con
+esto,
+
+15:31.600 --> 15:34.700
+vamos a tener que la velocidad de
+ejecución del programa,
+
+15:34.700 --> 15:37.100
+mientras más cercano al
+hardware,
+
+15:37.100 --> 15:41.100
+mientras más cercano al fierro, al CPU de
+tu computadora,
+
+15:41.100 --> 15:42.900
+pues mucho más rápido va a
+ser
+
+15:42.900 --> 15:47.100
+y también la lectura humana más difícil va
+a ser,
+
+15:47.100 --> 15:50.600
+mientras más de bajo nivel sea el lenguaje
+de programación.
+
+15:50.600 --> 15:52.400
+Y mientras más de alto
+nivel,
+
+15:52.400 --> 15:54.200
+la lectura humana va a ser más fácil,
+
+15:54.200 --> 15:57.000
+pero el programa va a ser más lento en
+tiempo de ejecución
+
+15:57.000 --> 16:00.200
+y el nivel de lenguaje va a ser más
+alto
+
+16:00.200 --> 16:01.800
+porque así se les denomina.
+Punto.
+
+16:01.800 --> 16:03.100
+En la siguiente
+clase,
+
+16:03.100 --> 16:05.800
+vamos a ver por qué a mí en particular me
+gusta C
+
+16:05.800 --> 16:09.100
+y luego de eso vamos a comenzar a preparar
+nuestro entorno.
+
+16:09.100 --> 16:11.100
+Hasta ahorita, déjame qué dudas tienes,
+
+16:11.100 --> 16:38.100
+cuéntame si te emociona el curso y nos
+vemos en la próxima.
+
diff --git "a/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/02-Resumen.html" "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/02-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..aa91bf8860e2e6661d0db8c45c70fe48654effcf
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/02-Resumen.html"
@@ -0,0 +1,125 @@
+
+
+
+
+
+
+ Programación en C: Estructuras, Funciones y Memoria
+
+
+
+
+
+
Resumen
¿Qué es el lenguaje C y por qué es importante?
+
El lenguaje C es un lenguaje de programación estructurado que ejecuta instrucciones de manera secuencial, comenzando desde la primera línea del código. A pesar de que no cuenta con características de programación orientada a objetos, como clases y objetos, ofrece estructuras como los structs, que son los predecesores de estas características en otros lenguajes. C se caracteriza por su tipado estático y fuerte, lo que significa que debes definir cuidadosamente el tipo y tamaño de datos que manejarás. Este lenguaje permite control total sobre la memoria, lo cual es esencial para aplicaciones que requieren eficiencia y velocidad.
+
C es muy utilizado en el desarrollo de sistemas operativos, software de aplicación, drivers, cálculo científico y sistemas embebidos, como el firmware de los vehículos. Gracias a su naturaleza compilada, permite especificar a qué sistema operativo apuntar, ya sea Windows, Linux, entre otros, garantizando así su portabilidad.
+
¿Por qué fue creado el lenguaje C?
+
El lenguaje C fue desarrollado por Denis Ritchie en los Laboratorios Bell entre 1972 y 1973. Su objetivo era crear un lenguaje comprensible y útil para desarrollar aplicaciones en el sistema operativo Unix, precursor de muchas de las plataformas actuales. Ritchie quería un lenguaje portable, capaz de ser ejecutado en diversos sistemas operativos. Para lograrlo, C se convierte en un lenguaje compilado que, al pasar por un compilador, se traduce al lenguaje máquina del sistema seleccionado.
+
¿Qué hace especial al lenguaje C?
+
+
Control de la memoria: Permite a los programadores manipular direcciones y bloques de memoria, maximizar recursos y controlar la eficiencia de los programas.
+
Portabilidad: Al ser un lenguaje compilado, ofrece la capacidad de crear ejecutables para diferentes sistemas operativos, aunque puede requerir ajustes para lograr compatibilidad completa.
+
Amplio uso en sistemas embebidos: Es la elección predominante para programar firmware y sistemas integrados debido a su eficiencia y control de hardware.
+
Capacidad de bajo nivel: Proporciona acceso directo a memoria y hardware, convirtiéndolo en la opción predilecta para el desarrollo de controladores y software de sistema.
+
Versatilidad: Utilizado en diversos campos, desde la programación de videojuegos hasta aplicaciones científicas de alto rendimiento.
+
+
¿Cómo se compara C con otros lenguajes de programación?
+
Niveles de abstracción en lenguajes de programación
+
Al estudiar lenguajes de programación, es vital entender que existe una escala de abstracción. Los lenguajes de alto nivel, como Python o JavaScript, son más fácilmente comprensibles para los humanos y suelen ser interpretados. Por el contrario, lenguajes como C se ubican en un nivel intermedio entre lo abstracto y el hardware, proporcionando un balance entre eficiencia y accesibilidad.
+
+
Lenguajes de alto nivel: Fáciles de entender pero más lentos en tiempo de ejecución. Ejemplos incluyen Perl, Python y Shell.
+
Lenguajes de nivel intermedio: Balance de accesibilidad y rendimiento. Aquí encontramos C y C++, ambos ofreciendo capacidades relativamente accesibles y salidas de alto rendimiento.
+
Lenguajes de bajo nivel: Permiten un acceso detallado a los procesos internos del hardware, ejemplos incluyen el lenguaje ensamblador.
+
+
Comparación con lenguajes interpretados
+
Lenguajes como JavaScript funcionan a través de motores de ejecución como V8, que permite interpretar el código en tiempo real sin necesidad de pasar por un proceso de compilación. Esto los hace más flexibles para el desarrollo web, mientras que C, al ser compilado, destaca en eficiencia y control del hardware, ideal para aplicaciones críticas y sistemas integrados.
+
Lenguajes para cada aplicación
+
Un principio fundamental al elegir un lenguaje es reconocer que cada uno tiene su espacio ideal de aplicación:
+
+
C: Ideal para sistemas de bajo nivel y aplicaciones embebidas.
+
Python: Preferible para ciencia de datos y desarrollo web.
+
JavaScript: Óptimo para aplicaciones web, principalmente del lado del cliente.
+
+
¡El aprendizaje del lenguaje adecuado depende del contexto y aplicación deseada! Por lo tanto, expandir tus habilidades hacia múltiples lenguajes te prepara mejor para una amplia variedad de desafíos en el mundo de la programación.
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/03-C\303\263mo una computadora interpreta datos binarios.mp4" "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/03-C\303\263mo una computadora interpreta datos binarios.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..607041a9e24e26909af23987f282a517dd73bcfd
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/03-C\303\263mo una computadora interpreta datos binarios.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:23c5fedcccadfed370c23e1cd80fedd47234dc8fe530ee6e2de540b8c7ef1d02
+size 87873198
diff --git "a/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/03-C\303\263mo una computadora interpreta datos binarios.vtt" "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/03-C\303\263mo una computadora interpreta datos binarios.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..20e6e6802b7ab13f2fac81ccf6e7c58f0e7be307
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/03-C\303\263mo una computadora interpreta datos binarios.vtt"
@@ -0,0 +1,503 @@
+WEBVTT
+
+00:00.000 --> 00:08.000
+¡Hey! Bienvenido o bienvenido a esta clase
+pública de nuestro curso de algoritmos en Platzi.
+
+00:08.000 --> 00:12.000
+Yo, Ricardo Celis, tu profesor, te voy a
+enseñar en esta clase
+
+00:12.000 --> 00:17.000
+cómo entiende las cosas una computadora de
+una forma súper gráfica y rápida.
+
+00:17.000 --> 00:19.000
+¿Qué esperas? ¡Comienza a aprender
+ya!
+
+00:19.000 --> 00:22.000
+Antes de que comiences este increíble
+curso de algoritmos,
+
+00:22.000 --> 00:25.000
+hablemos de para quién le hacemos los
+programas,
+
+00:25.000 --> 00:28.000
+quién se va a encargar de ejecutar este
+código que escribimos.
+
+00:28.000 --> 00:32.000
+Ese es el hardware o, más específicamente,
+la computadora.
+
+00:32.000 --> 00:36.000
+Las computadoras nacen de esta necesidad
+humana
+
+00:36.000 --> 00:42.000
+de tener herramientas que nos van a
+permitir hacer nuestros trabajos del día a día más fácilmente,
+
+00:42.000 --> 00:48.000
+como las armas para cazar, las
+herramientas para sembrar y construir
+
+00:48.000 --> 00:53.000
+que nos permitieron tener mejores
+alimentos y asentarnos como humanidad
+
+00:53.000 --> 00:58.000
+o, inclusive, más adelante, como la
+electricidad.
+
+00:58.000 --> 01:02.000
+En un principio, las computadoras nos
+ayudaban a trabajar con números
+
+01:02.000 --> 01:06.000
+de forma mucho más rápida y eficiente de
+la que nosotros podríamos hacerlo.
+
+01:06.000 --> 01:10.000
+Simplemente les dábamos un input, un
+número de input a calcular.
+
+01:10.000 --> 01:12.000
+Esta sería la
+entrada.
+
+01:12.000 --> 01:15.000
+La computadora almacenaba la información,
+
+01:15.000 --> 01:18.000
+le solicitábamos las operaciones que
+necesitamos,
+
+01:18.000 --> 01:22.000
+luego, con una serie de pasos previamente
+definidos,
+
+01:22.000 --> 01:27.000
+procesaban la información y nos generaban
+un resultado de salida.
+
+01:27.000 --> 01:31.000
+Hoy en día, las computadoras han avanzado
+a pasos agigantados,
+
+01:31.000 --> 01:34.000
+permitiéndonos tener teléfonos inteligentes,
+
+01:34.000 --> 01:38.000
+altavoces con asistentes de voz, vehículos
+que se manejan solos
+
+01:38.000 --> 01:42.000
+e, inclusive, robots que llegan a Marte.
+
+01:42.000 --> 01:47.000
+Estos dispositivos que mencionamos no
+manejan solamente números y operaciones matemáticas.
+
+01:47.000 --> 01:52.000
+No, puedes manejar foto, video, juegos,
+música, etc.
+
+01:52.000 --> 01:54.000
+¿Cómo lo hacen?
+Veamos.
+
+01:54.000 --> 01:57.000
+Hablemos de lo que ocurre dentro de una
+computadora.
+
+01:57.000 --> 02:01.000
+Y seguramente has visto en películas o
+series que cuando está ocurriendo
+
+02:01.000 --> 02:04.000
+algún proceso en la pantalla, puedes ver
+ceros y unos.
+
+02:04.000 --> 02:07.000
+Esto que has visto son los números binarios.
+
+02:07.000 --> 02:10.000
+Y aunque ya nadie escribe programas en
+binario,
+
+02:10.000 --> 02:14.000
+estos son el tipo de señales que existen
+dentro de tu computadora.
+
+02:14.000 --> 02:19.000
+Piensa en el cable que conecta el
+interruptor de luz de tu habitación con la lámpara.
+
+02:19.000 --> 02:22.000
+Este cable puede tener dos
+estados.
+
+02:22.000 --> 02:25.000
+Este puede ser ON, que sería un
+1,
+
+02:25.000 --> 02:28.000
+u OFF, que sería un
+0.
+
+02:28.000 --> 02:32.000
+Así puedes representar un sí o un no,
+un ON o un OFF,
+
+02:32.000 --> 02:34.000
+un true o false en
+computación.
+
+02:34.000 --> 02:38.000
+Dentro de una computadora tenemos millones
+de dispositivos electrónicos,
+
+02:38.000 --> 02:40.000
+conocidos como
+transistores,
+
+02:40.000 --> 02:46.000
+que van a almacenar estos ceros o unos,
+tal como lo hiciera el cable en nuestro ejemplo anterior.
+
+02:46.000 --> 02:49.000
+A este dato que puede valer 0 o
+1,
+
+02:49.000 --> 02:52.000
+se le conoce en computación como un
+bit
+
+02:52.000 --> 02:55.000
+y es la unidad mínima de información que
+podemos manejar.
+
+02:55.000 --> 02:58.000
+Y los cables, bueno, los cables dentro de
+un circuito
+
+02:58.000 --> 03:02.000
+solamente se van a encargar de llevar la
+información de un lado a otro.
+
+03:02.000 --> 03:07.000
+Las computadoras utilizan transistores en
+diferentes acomodos
+
+03:07.000 --> 03:11.000
+para poder hacer todas las funcionalidades
+que necesitan,
+
+03:11.000 --> 03:14.000
+almacenar información, hacer operaciones y
+más.
+
+03:14.000 --> 03:17.000
+A continuación veremos cómo ocurre eso.
+
+03:17.000 --> 03:23.000
+La base que se utiliza para poder tener
+números, imágenes, textos y audios
+
+03:23.000 --> 03:27.000
+con este sistema de sólo valores como 0 y 1,
+es el sistema binario.
+
+03:27.000 --> 03:29.000
+Vamos a ver cómo
+funciona.
+
+03:29.000 --> 03:33.000
+Nosotros estamos acostumbrados a trabajar
+con el número decimal.
+
+03:33.000 --> 03:36.000
+Por ejemplo, este número sería el número 12.
+
+03:36.000 --> 03:40.000
+O este otro número sería el número 48.
+
+03:40.000 --> 03:44.000
+En número binario nosotros no vamos a
+funcionar así.
+
+03:44.000 --> 03:47.000
+En número decimal tenemos, por ejemplo,
+los miles,
+
+03:47.000 --> 03:52.000
+tenemos cientos, tenemos decimales y
+tenemos unidades.
+
+03:52.000 --> 03:59.000
+Entonces este número son mil, doscientos,
+cuarenta y ocho unidades.
+
+03:59.000 --> 04:05.000
+En el sistema binario, en cambio, nosotros
+solamente vamos a poder utilizar 0 y 1.
+
+04:05.000 --> 04:11.000
+Entonces podemos tener combinaciones
+numéricas que sean como la siguiente.
+
+04:11.000 --> 04:13.000
+1, 1,
+1.
+
+04:13.000 --> 04:18.000
+En sistema binario la primera posición
+vale 1 y se van multiplicando por 2 cada vez.
+
+04:18.000 --> 04:21.000
+Entonces la segunda posición son 2, la
+tercera posición son 4
+
+04:21.000 --> 04:25.000
+y la cuarta posición sería
+8.
+
+04:25.000 --> 04:29.000
+Por ejemplo, este número binario que acabo
+de formar aquí sería 8,
+
+04:29.000 --> 04:34.000
+más 4, 12, más 2, 14, más 1,
+15.
+
+04:34.000 --> 04:37.000
+Hemos formado el número 15 en binario.
+
+04:37.000 --> 04:41.000
+Ahora que ya sabes cómo la computadora
+puede entender los números binarios,
+
+04:41.000 --> 04:44.000
+quizás te estás preguntando, ¿y las letras
+de dónde salen?
+
+04:44.000 --> 04:47.000
+Existen convenciones, como el código ASCII,
+
+04:47.000 --> 04:51.000
+que nos dice que cada letra va a tener un
+valor numérico.
+
+04:51.000 --> 04:54.000
+Por ejemplo, la letra T en valor decimal
+va a ser 84
+
+04:54.000 --> 04:58.000
+y si tú presionas Alt 84 en tu computadora,
+
+04:58.000 --> 05:01.000
+vas a poder ver cómo se escribe el carácter T.
+
+05:01.000 --> 05:06.000
+Luego, la computadora no entiende el
+número 84 porque está usando el sistema decimal,
+
+05:06.000 --> 05:09.000
+pero la computadora sí va a entender el
+siguiente número,
+
+05:09.000 --> 05:20.000
+que sería 0, 0, 1, 0, 1, 0,
+1.
+
+05:20.000 --> 05:26.000
+Este número decimal de 8 bits, 1, 2, 3, 4, 5,
+6, 7
+
+05:26.000 --> 05:30.000
+y un bit de más que no estamos ocupando,
+un 0 a la izquierda que no cuenta,
+
+05:30.000 --> 05:34.000
+es un número que nos permite almacenar un
+carácter.
+
+05:34.000 --> 05:37.000
+Entonces, acabas de ver cómo las
+computadoras manejan
+
+05:37.000 --> 05:40.000
+de binario a
+letras.
+
+05:40.000 --> 05:45.000
+Ahora, un documento de texto no es otra
+cosa más que una colección de caracteres
+
+05:45.000 --> 05:49.000
+que no son otra cosa más que ceros y unos
+que la computadora puede entender.
+
+05:49.000 --> 05:54.000
+Una imagen va a ser la representación de
+muchos pixeles juntos
+
+05:54.000 --> 05:58.000
+y cada uno de estos pixeles va a tener
+ciertas características.
+
+05:58.000 --> 06:01.000
+Así como existe el estándar para los
+caracteres,
+
+06:01.000 --> 06:03.000
+tenemos estándares para las imágenes,
+
+06:03.000 --> 06:08.000
+que te van a decir que vas a tener una
+colección de, por ejemplo,
+
+06:08.000 --> 06:11.000
+imagínate que cada una de estas líneas es
+un pixel
+
+06:11.000 --> 06:13.000
+y este pixel va a tener
+colores.
+
+06:13.000 --> 06:17.000
+Estos colores van a estar representados
+con ceros y unos
+
+06:17.000 --> 06:21.000
+que la computadora puede almacenar y
+entender el mismo.
+
+06:21.000 --> 06:25.000
+Entonces, ahora cuando escuches una imagen
+que tiene tantos megapixeles,
+
+06:25.000 --> 06:28.000
+eso significa tantos millones de
+pixeles
+
+06:28.000 --> 06:33.000
+y cada uno de esos millones de pixeles va
+a ser información en binario
+
+06:33.000 --> 06:37.000
+que pintan la imagen de un color y la
+colección de todos los colores
+
+06:37.000 --> 06:40.000
+forman la fotografía, el dibujo o el diseño.
+
+06:40.000 --> 06:43.000
+Esto mismo aplica, por ejemplo, para un video,
+
+06:43.000 --> 06:47.000
+que además de que tiene imágenes una por una,
+
+06:47.000 --> 06:51.000
+junta 24 imágenes por segundo al menos,
+o 60 o 120
+
+06:51.000 --> 06:54.000
+y las guarda en otro formato
+más.
+
+06:54.000 --> 06:56.000
+Pero al final, ¿qué está usando? Imágenes.
+
+06:56.000 --> 07:00.000
+Y al final, cada una de esas imágenes se
+descompone en ceros y unos.
+
+07:00.000 --> 07:03.000
+¿Y la música? ¿Qué pasa con la
+música?
+
+07:03.000 --> 07:07.000
+Bueno, la música son archivos que tú
+almacenas en tu computadora
+
+07:07.000 --> 07:10.000
+que son representaciones, efectivamente,
+en binario
+
+07:10.000 --> 07:14.000
+de cuál es el valor que debe estar
+reproduciendo la computadora.
+
+07:14.000 --> 07:17.000
+Ahora, con todo esto claro, hablemos de
+los programas.
+
+07:17.000 --> 07:20.000
+El software son las series de
+instrucciones
+
+07:20.000 --> 07:22.000
+que tú le vas a dar a la
+computadora
+
+07:22.000 --> 07:25.000
+para que esta pueda llevar a cabo los
+procesos.
+
+07:25.000 --> 07:28.000
+El flujo que todo programa va a
+seguir
+
+07:28.000 --> 07:31.000
+es el de tener un input, una entrada,
+¿cierto?
+
+07:31.000 --> 07:35.000
+Vamos a tener un CPU y una
+memoria
+
+07:35.000 --> 07:38.000
+que se van a encargar de comunicar para
+hacer todo el trabajo
+
+07:38.000 --> 07:40.000
+de procesar la información, guardar variables,
+
+07:40.000 --> 07:42.000
+mantener la información
+correcta
+
+07:42.000 --> 07:46.000
+y después procesar un resultado final.
+
+07:46.000 --> 07:49.000
+Estos resultados finales son los que vas a
+aprender a generar
+
+07:49.000 --> 07:52.000
+en el curso de Algoritmos y Estructuras de
+Datos.
+
+07:52.000 --> 07:55.000
+En este curso aprenderás a enseñarle a la
+computadora
+
+07:55.000 --> 07:59.000
+los pasos a seguir para resolver problemas
+simples o complejos
+
+07:59.000 --> 08:02.000
+y quitarte el miedo a cualquier
+desafío
+
+08:02.000 --> 08:04.000
+que tengas en tu vida
+profesional.
+
+08:04.000 --> 08:19.000
+Nos vemos en el curso de Algoritmos.
+
diff --git "a/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/03-Lecturas recomendadas.txt" "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/03-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..37263575728954b75163b0314954e60d60dec73e
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/03-Lecturas recomendadas.txt"
@@ -0,0 +1 @@
+https://platzi.com/clases/ordenamiento/
diff --git "a/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/03-Resumen.html" "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/03-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..3270696e42971e8f31d8bc1e585c90cb8f57755e
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/03-Resumen.html"
@@ -0,0 +1,96 @@
+
+
+
+
+
+
+ Cómo una computadora interpreta datos binarios
+
+
+
+
+
+
Resumen
El profesor Ricardo Celis nos cuenta la historia y evolución de las computadoras, cómo funcionan y cómo pueden procesar información con el sistema binario para entender los documentos, textos, vídeos, imágenes, sonidos o algoritmos que vamos a programar para agilizar nuestro trabajo de todos los días.
+
Las computadoras nos ayudan a trabajar con mayor velocidad y eficiencia porque pueden generar un resultado para resolver nuestras operaciones a partir de un conjunto de instrucciones previamente definidas. Además, así como en las películas, las computadoras tienen millones de dispositivos electrónicos que conocemos como transistores y se encargan de convertir la electricidad en bits: el sistema binario de ceros y unos, la menor expresión de información de las computadoras.
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/04-Fundamentos del Lenguaje C para Microcontroladores.mp4" "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/04-Fundamentos del Lenguaje C para Microcontroladores.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..40080de886b3ae478979a6c4cd5b902dfac1679b
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/04-Fundamentos del Lenguaje C para Microcontroladores.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5c08b6bfd2b8ccbd30a7358aa43f9fab84019a462cd0e8de1dfb492da87907f1
+size 57208899
diff --git "a/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/04-Fundamentos del Lenguaje C para Microcontroladores.vtt" "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/04-Fundamentos del Lenguaje C para Microcontroladores.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..7d4ab8440e289ad8108ac6adcb4cdeb931d43835
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/04-Fundamentos del Lenguaje C para Microcontroladores.vtt"
@@ -0,0 +1,230 @@
+WEBVTT
+
+00:00.000 --> 00:08.580
+Hola, aquí te quiero contar porque a mí me
+parece que sé, deberías aprenderlo y aquí
+
+00:08.580 --> 00:13.700
+esta es la clase que yo digo quiero que
+digas ok, me quedo aquí. A partir de esta clase todo va a
+
+00:13.700 --> 00:17.640
+ser práctico, vamos a aprender todo sobre
+el lenguaje, pero de verdad quiero contarte esto
+
+00:17.640 --> 00:23.100
+porque tiene mucho valor. Lo primero que
+te quiero decir es que sé es un lenguaje que ayuda a entender
+
+00:23.100 --> 00:28.660
+los fundamentos de teoría de computación.
+¿Cómo así? Y mira, aquí te quiero hablar desde mi
+
+00:28.660 --> 00:35.220
+experiencia. Yo aprendí computación,
+aprendí sobre desarrollo de software, aprendí todo esto,
+
+00:35.220 --> 00:40.540
+aprendí sobre programación porque
+programaba microcontroladores. Los microcontroladores son
+
+00:40.540 --> 00:45.980
+estas pequeñas computadoras que valen
+desde 20 centavos de dólar hasta 10, 15 o 20 dólares,
+
+00:45.980 --> 00:51.820
+que se ocupan en todo. Por ejemplo, en el
+control de tu lavadora, en una cámara, en celulares, en
+
+00:51.820 --> 00:57.140
+tableros de coches, de verdad están en
+todo lado que tenga cierto código, que tenga cierto nivel
+
+00:57.140 --> 01:01.660
+de software en donde puedas configurar algo,
+presionar botones, pero que no llegue a tener
+
+01:01.660 --> 01:07.300
+la necesidad de mucho procesamiento.
+Por ejemplo, la cámara, una cámara fotográfica va a tener un
+
+01:07.300 --> 01:13.340
+CPU muy poderoso que se encarga de
+procesar las imágenes digitales de vídeo que capta el sensor,
+
+01:13.340 --> 01:17.420
+pero además puede tener microcontroladores
+para todo lo que es el manejo de botones,
+
+01:17.420 --> 01:22.340
+un microcontrolador podría sin problema
+controlar el motor que se encarga del autofocus en una
+
+01:22.340 --> 01:27.660
+cámara, detectar cuando se presionó el
+obturador, porque son cámaras digitales hoy en día y aunque
+
+01:27.660 --> 01:32.780
+el obturador te da una sensación de ser
+algo mecánico, en realidad es 100% digital y esto
+
+01:32.780 --> 01:40.700
+te permite tener mucho código en las cosas,
+te permite meterle el código a lo que sea,
+
+01:40.700 --> 01:44.500
+casi de verdad podrías hacer con un
+microcontrolador un regador de plantas automático,
+
+01:44.500 --> 01:49.380
+un alimentador de gatos automático, o que
+tu refrigerador se conecte a wifi, o que tu
+
+01:49.380 --> 01:53.980
+refrigerador se conecte a bluetooth y te
+avise cuál es la temperatura y si hay partículas
+
+01:53.980 --> 02:00.340
+contaminantes ahí a través de sensores o
+gases, lo que quieras. Y estos microcontroladores son
+
+02:00.340 --> 02:05.260
+como computadoras a escala pero que no
+tienen un sistema operativo y al no tener un sistema
+
+02:05.260 --> 02:09.660
+operativo yo tenía que programar todo,
+yo tenía que programar cómo iba a accesar a la memoria,
+
+02:09.660 --> 02:14.540
+cuáles iban a ser las entradas, cuáles
+iban a ser las salidas de mi programa, todo esto lo
+
+02:14.540 --> 02:21.620
+hacía yo a través de puro código C y el
+hecho de que se utilice C es porque se te permite tener
+
+02:21.620 --> 02:26.780
+acceso al control de memoria de un programa,
+por ejemplo tiene muchas cosas de bajo nivel que son
+
+02:26.780 --> 02:32.300
+excelentes para esto y por eso aquí quiero
+decirte que C es un lenguaje que te va a ayudar a entender
+
+02:32.300 --> 02:37.340
+los fundamentos de teoría de computación,
+si te sigues con este curso y los siguientes de lenguaje
+
+02:37.340 --> 02:43.140
+te aseguro que vas a entender mucho más a
+fondo cómo funciona la memoria, qué es un stack overflow,
+
+02:43.140 --> 02:49.540
+que estoy muy seguro que has escuchado ese
+sitio web cuando tienes algún bug en tu código o algo
+
+02:49.540 --> 02:54.500
+por el estilo, vas a stack overflow,
+revisas qué está pasando, encuentras la solución, la copias,
+
+02:54.500 --> 03:00.980
+la pegas en tu programa, se vale y ya,
+pero qué significa un stack overflow, con C puedes entender
+
+03:00.980 --> 03:06.380
+de verdad qué significa un stack overflow
+y verlo verlo suceder, vamos a entender cuestiones como
+
+03:06.380 --> 03:11.220
+todo lo que son apuntadores, todo lo que
+son operadores a nivel de bits, vamos a entender
+
+03:11.220 --> 03:17.340
+cosas de teoría de computación que un
+lenguaje de alto nivel no nos permite porque no se meten con
+
+03:17.340 --> 03:23.260
+estas cosas y te van a servir muchísimo si
+quieres de verdad, no sé, en un futuro llegar a ser
+
+03:23.260 --> 03:28.480
+compiladores, en un futuro de ser un
+verdadero científico de computación, así que eso es lo que
+
+03:28.480 --> 03:34.260
+vamos a ir logrando con estos cursos de C.
+Luego C tiene pocas librerías principalmente porque
+
+03:34.260 --> 03:39.500
+cuando se desarrolló no existía todo esto,
+lo que son comunidades de desarrollo, muchos conceptos,
+
+03:39.500 --> 03:46.180
+por ejemplo yo aprendí en un libro todavía
+y creo que es una gran forma de aprenderlo, pero no tiene
+
+03:46.180 --> 03:51.140
+muchas librerías, es decir, si tú quieres
+desarrollar una aplicación específica probablemente te toque
+
+03:51.140 --> 03:56.540
+hacer las librerías a ti y eso es lo que a
+nosotros justo nos pasaba cuando programamos robots o con
+
+03:56.540 --> 04:01.300
+microcontroladores y es que no había una
+librería para control de motores, no había una librería
+
+04:01.300 --> 04:06.780
+para control de sensores y nosotros
+aprendíamos cómo desarrollar esto desde cero, es maravilloso,
+
+04:06.780 --> 04:13.140
+porque de verdad entiendes más cómo están
+pasando las cosas, llegas a tener mucho mayor comprensión
+
+04:13.140 --> 04:17.940
+de lo que está pasando adentro de, que de
+hecho en Platzi nos encanta que tú sepas qué hay detrás
+
+04:17.940 --> 04:22.940
+de las cosas, por eso tenemos un curso
+como el curso taller de creación de single page
+
+04:22.940 --> 04:27.700
+application router en donde te enseño cómo
+funcionaría un router por dentro sin utilizar
+
+04:27.700 --> 04:32.700
+ninguna librería, utilizando javascript puro,
+si te interesa javascript pues vete para allá, bueno,
+
+04:32.700 --> 04:38.340
+además C es el lenguaje más utilizado en
+programación de circuitos embebidos, lo que ya te
+
+04:38.340 --> 04:43.500
+hablé mucho en este curso, todo lo que son
+microcontroladores hasta arduino lo puedes programar
+
+04:43.500 --> 04:48.940
+con este lenguaje de programación C que de
+verdad es maravilloso y te va a permitir hacer cosas que
+
+04:48.940 --> 04:53.420
+no te imaginas gracias a poder trabajar
+con hardware y aquí te recomiendo el curso de
+
+04:53.420 --> 04:59.140
+microcontroladores con C. Por último C es
+muy rápido en tiempo de ejecución, si de verdad tienes
+
+04:59.140 --> 05:05.020
+que hacer algo en donde el tiempo es
+crucial entonces deberías irte por el lenguaje C,
+
+05:05.020 --> 05:30.020
+no hay de otra, con esto dicho nos vemos
+en la próxima clase.
+
diff --git "a/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/04-Lecturas recomendadas.txt" "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/04-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..0dbc861ec05378cd3ab8a3fa57fe4d313899cb7f
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/04-Lecturas recomendadas.txt"
@@ -0,0 +1 @@
+https://platzi.com/clases/singlepage-app/
diff --git "a/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/04-Resumen.html" "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/04-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..b7bc1b7bbc17c18a697bc0f983276330ea406c1a
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/04-Resumen.html"
@@ -0,0 +1,83 @@
+
+
+
+
+
+
+ Fundamentos del Lenguaje C para Microcontroladores
+
+
+
+
+
+
Resumen
¿Por qué aprender el lenguaje de programación C?
+
El lenguaje de programación C es una herramienta poderosa que todo programador debería considerar aprender. Pero, ¿por qué exactamente es tan importante? En este artículo, exploraremos las ventajas de aprender C, desde una perspectiva práctica y teórica que enriquecerá tus conocimientos en computación.
+
¿Cómo ayuda C a entender los fundamentos de la teoría de computación?
+
El lenguaje C es esencial para quienes desean comprender los fundamentos de la teoría de computación. Esto se debe a que C permite a los programadores un acceso profundo al control de memoria y aspectos de bajo nivel del hardware de la computadora.
+
+
Microcontroladores: C es fundamental en la programación de microcontroladores, pequeños dispositivos que controlan todo, desde electrodomésticos hasta teléfonos inteligentes. Estos dispositivos, sin un sistema operativo tradicional, requieren que el programador gestione directamente la memoria y las entradas/salidas.
+
Conceptos de bajo nivel: Aprender C te permitirá entender conceptos complejos como el desbordamiento de pila (stack overflow), apuntadores y operaciones a nivel de bits. Estos conocimientos son cruciales para el desarrollo de compiladores y te dará las bases para convertirte en un verdadero científico de la computación.
+
+
¿Por qué tiene C pocas librerías y cómo afecta esto al aprendizaje?
+
C fue desarrollado en una época en la que las comunidades de desarrollo y el amplio conjunto de librerías a las que estamos acostumbrados hoy en día no existían. Esto representa un desafío y una oportunidad:
+
+
Desarrollo de librerías propias: Al tener pocas librerías estándar, los programadores frecuentemente deben crear sus propias librerías para tareas específicas, como el control de motores o sensores. Este proceso ofrece una comprensión mucho más profunda de cómo ocurre cada cosa por debajo del capó.
+
Comprensión y creación: La necesidad de escribir código desde cero te enseña cómo funcionan realmente las cosas, algo que en Platzi consideran fundamental para un entendimiento total de la programación.
+
+
¿Por qué C es el lenguaje más usado en programación de circuitos embebidos?
+
El mundo del hardware embebido depende en gran medida de la programación en C. Robots, microcontroladores, y plataformas como Arduino son comúnmente programadas con este lenguaje debido a su eficiencia y control directo sobre el hardware.
+
+
Versatilidad y eficiencia: C proporciona la capacidad de trabajar directamente con hardware gracias a su manejo eficiente de recursos. Esto es crucial cuando se programan dispositivos que deben operar rápidamente y con recursos limitados.
+
Recomendación educativa: Para quienes desean profundizar en este campo, cursos como "Microcontroladores con C" pueden ser un excelente punto de partida para comenzar a aplicarlo en contextos de hardware real.
+
+
¿Qué tan rápido es C en tiempo de ejecución y cuándo es necesario?
+
Otra ventaja notable de C es su velocidad de ejecución. En contextos donde el tiempo es un recurso crítico, C sobresale:
+
+
Alta velocidad: C es uno de los lenguajes más rápidos en cuanto a ejecución se refiere. Si desarrollas aplicaciones donde la ejecución rápida es crucial, C es indudablemente la opción ideal.
+
Aplicaciones sensibles al tiempo: Desde videojuegos hasta simulaciones científicas, cualquier aplicación que necesite un tiempo de respuesta inmediato puede beneficiarse enormemente del uso de C.
+
+
Aprender C no solo abre puertas en el desarrollo de software, sino que proporciona una comprensión profunda de cómo funcionan las computadoras a nivel fundamental. Te animo a continuar explorando este fascinante lenguaje y descubrir el vasto mundo de posibilidades que ofrece. ¡Adelante, el conocimiento y la competencia son herramientas poderosas!
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/05-Configuraci\303\263n de Entorno para Programar en C en Windows.mp4" "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/05-Configuraci\303\263n de Entorno para Programar en C en Windows.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..30d5f615c8c3abd403c074032dc3a71ce22e5885
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/05-Configuraci\303\263n de Entorno para Programar en C en Windows.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b741cf06e400a03e8e70777cae51c6364d780a44d9c4b5da3adf78cca9ffcbd1
+size 106875441
diff --git "a/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/05-Configuraci\303\263n de Entorno para Programar en C en Windows.vtt" "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/05-Configuraci\303\263n de Entorno para Programar en C en Windows.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..2140470db14c197c55a372f5ae302c78dae8318b
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/05-Configuraci\303\263n de Entorno para Programar en C en Windows.vtt"
@@ -0,0 +1,374 @@
+WEBVTT
+
+00:00.000 --> 00:08.440
+Hola, en esta clase vamos a preparar
+nuestro entorno de trabajo para poder programar C,
+
+00:08.440 --> 00:12.360
+para poder ejecutar nuestro código. Ya sabes,
+tenemos que escribirlo,
+
+00:12.360 --> 00:17.600
+luego tendremos que compilarlo y luego
+pasaremos a ver qué nos dice nuestro código cuando se ejecute.
+
+00:17.600 --> 00:21.600
+Para esto, lo primero es que quiero que me
+acompañes a tu navegador y vayas a
+
+00:21.600 --> 00:31.520
+surforge.net slash project slash orwell
+dev c++ o dev cpp. Esta url recuerda que la verás en la
+
+00:31.520 --> 00:37.720
+plataforma en la sección de enlaces.
+Una vez estés aquí, dale al botón de download. Esto va a tener
+
+00:37.720 --> 00:44.240
+un pequeño timer para que comience la
+descarga y una vez la descarga esté arrancando, vamos a darle
+
+00:44.240 --> 00:50.760
+guardar. Es una descarga bastante ligera,
+deben de ser aproximadamente 50 megas y vamos a esperar
+
+00:50.760 --> 00:56.680
+a que termine de descargarse. Una vez se
+termine de descargar, dale clic ejecuta el programa y
+
+00:56.680 --> 01:03.840
+windows te va a preguntar por permisos.
+Dale que sí. Quiero contarte que es dev c++, es una IDE
+
+01:03.840 --> 01:10.000
+integrated development environment
+ambiente de desarrollo integrado que nos va a servir para
+
+01:10.000 --> 01:17.560
+poder desarrollar todo el código en C y
+C++ que queramos. Lo desarrolla esta persona. Muchas
+
+01:17.560 --> 01:24.520
+gracias. Es gratis, portable, fast y simple.
+Es la verdad bueno y funcional. Una vez ya tengas esto
+
+01:24.520 --> 01:31.840
+listo, vamos a darle que sí en inglés.
+Esto nos va a abrir una ventana de license agreement. Es
+
+01:31.840 --> 01:37.240
+una licencia de tipo GNU, está ok.
+Básicamente es software que se está distribuyendo de forma
+
+01:37.240 --> 01:42.560
+gratuita. Recuerda tú deberías de darle a
+aceptar y aquí nos va a decir oye que quieres instalar.
+
+01:42.560 --> 01:50.640
+Bueno vamos a dejarlo todo en standard y
+vamos a proceder a instalar. Vamos a darle install.
+
+01:50.640 --> 01:57.000
+Todo listo, no modifiques nada y vamos a
+esperar a que termine de extraer absolutamente todo y
+
+01:57.000 --> 02:03.120
+tengamos la instalación finalizada. Una
+vez se termine no hace falta que lo ejecutemos, simplemente
+
+02:03.120 --> 02:09.400
+dale clic en finish. Ahora yo voy a hacer
+la instalación un poquito más allá porque quiero
+
+02:09.400 --> 02:17.080
+que tengas facilidad de ejecutar desde la
+terminal código en windows. Para esto vas a ir a tu
+
+02:17.080 --> 02:24.120
+menú windows, vas a apretar la tecla
+windows y esto te va a abrir el menú. Quiero que ahí le busques
+
+02:24.120 --> 02:31.040
+environment variables o variables de entorno,
+variables de ambiente. Vas a darle clic y esto
+
+02:31.040 --> 02:36.080
+te va a abrir esta ventana de system
+properties. Voy a cerrar aquí el navegador para que no nos
+
+02:36.080 --> 02:41.320
+estorbe y en la ventana de system
+properties o propiedades del sistema vamos a darle clic a
+
+02:41.320 --> 02:47.840
+variables de entorno. Vas a hacer clic
+aquí y simple y sencillamente vamos a agregar nuestras
+
+02:47.840 --> 02:56.200
+variables de entorno. Vamos a darle clic
+en new y quiero que escribas el variable name va a ser
+
+02:57.120 --> 03:04.400
+devc y el variable value quiero que sea
+este que vamos a tener aquí que es la ruta en donde
+
+03:04.400 --> 03:10.080
+estamos guardando nuestro software y donde
+estamos guardando nuestro compilador. Vamos a darle ok
+
+03:10.080 --> 03:15.680
+y vamos a darle ok. Con eso ya agregamos
+una variable de entorno esto nos va a servir para
+
+03:15.680 --> 03:22.360
+que ya siempre que llamemos desde otro
+programa o querramos ejecutar un código en C ya vamos a
+
+03:22.360 --> 03:29.120
+saber a dónde debería estar llamando
+nuestro compilador. Eso es todo lo que va a pasar.
+
+03:29.120 --> 03:36.720
+Luego vamos a darle vamos a probar que se
+haya hecho de forma correcta para eso vamos a ir a
+
+03:36.720 --> 03:44.240
+cmd igual aprieta la tecla windows y
+escribe cmd te va a aparecer command prompt y este terminal
+
+03:44.240 --> 03:50.680
+que acabamos de abrir es lo que yo necesitaba.
+Para validar que se configuró correctamente
+
+03:50.680 --> 03:57.600
+nuestro compilador vamos a escribir gcc y
+me dice gcc is not recognized. ¿Por qué no lo reconoce?
+
+03:57.600 --> 04:03.080
+Bueno muy simple vamos a otra vez nuestros
+environment variables vamos a configurar la
+
+04:03.080 --> 04:10.920
+que acabamos de agregar y en variable name
+ponle gcc le damos ok y le damos ok. Muy bien cierras
+
+04:10.920 --> 04:19.440
+tu cmd lo vuelves a abrir vamos a ver
+ahora si funciona gcc luego vas a seleccionar la que dice
+
+04:19.440 --> 04:25.920
+path y le vas a dar doble clic y aquí te
+vas a asegurar de darle new y de pegar esta variable
+
+04:25.920 --> 04:31.000
+que estoy poniendo en pantalla justo así
+como la estoy poniendo a menos que tengas todo instalado
+
+04:31.000 --> 04:36.480
+en otro disco duro entonces tendrías que
+poner la dirección en donde tienes instalado dev cpp min
+
+04:36.480 --> 04:43.640
+gw pin por eso te dije que no lo cambiaras
+ok una vez la agregas simplemente le vas a dar en ok y
+
+04:43.640 --> 04:48.800
+listo yo si te das cuenta quedé con dos
+déjame borrar una no está bien que tengamos dos no hay
+
+04:48.800 --> 04:55.160
+necesidad vamos a dar ok y ok con esto ya
+cerramos todo el siguiente paso es que vuelvas a apretar la
+
+04:55.160 --> 05:01.800
+tecla windows y escribas cmd esto nos va a
+abrir nuestra terminal como decía como command prompt
+
+05:01.800 --> 05:10.160
+y vamos a escribir gcc y perfecto dice gcc
+fatal error no input files compilation terminated pero
+
+05:10.160 --> 05:15.200
+por qué pues porque no le hemos pasado
+ningún archivo en c y esto está bien no lo necesitamos
+
+05:15.200 --> 05:19.920
+aún simplemente quería verificar que en mi
+computadora se había instalado el compilador
+
+05:19.920 --> 05:27.080
+y se llama escribiendo gcc todo está en
+orden todo está maravilloso ahora lo que vamos a hacer
+
+05:27.080 --> 05:36.240
+es ir a nuestro navegador otra vez y
+descargar visual studio code visual estudio code vamos a
+
+05:36.240 --> 05:41.400
+ir a la página de microsoft directo donde
+dice download visual estudio code vamos a darle clic
+
+05:41.400 --> 05:48.680
+aquí en download for windows 10 vamos a
+descargar el instalador de 64 bits muy bien y vamos a darle
+
+05:48.680 --> 05:55.440
+clic acá no ya esto nos lo descarga
+simplemente ya estábamos en esa página vamos a esperar a que
+
+05:55.440 --> 06:00.960
+termine de descargarse esto se descargó
+súper rápido muy bien hacemos doble clic ejecutamos
+
+06:00.960 --> 06:06.080
+nuestro programa y windows nos va a decir
+oye aceptas en la licencia le voy a decir que sí por
+
+06:06.080 --> 06:11.560
+supuesto que acepto vamos a darle a todo
+todo está bien a tu pad absolutamente todo lo tienes que
+
+06:11.560 --> 06:17.920
+dejar marcado le vas a dar en install y
+vamos a esperar a que termine ojo para que termine de
+
+06:17.920 --> 06:23.600
+forma efectiva tienes que reiniciar tu
+computadora así que lo siento tendrás que hacerlo una vez
+
+06:23.600 --> 06:29.200
+termine la instalación nos vemos y
+continuamos exactamente en este instante en esta parte de
+
+06:29.200 --> 06:35.360
+la clase ahora que tenemos listo visual
+estudio code vamos a proceder a ejecutarlo busca visual
+
+06:35.360 --> 06:42.200
+estudio code o visual estudio code como le
+quieras decir no pasa nada se va a abrir esta bella ventana
+
+06:42.200 --> 06:47.600
+y es nuestro editor de código que vamos a
+estar manejando ahora per se este programa no nos permite
+
+06:47.600 --> 06:56.160
+trabajar con código c no para nada para
+eso vamos a buscar una extensión y esta extensión se va a
+
+06:56.160 --> 07:06.040
+llamar c slash c más más esto es si te das
+cuenta es directo de microsoft entonces todo perfecto
+
+07:06.040 --> 07:16.760
+instálala por favor se llama c más más
+también vamos a instalar c c más más compile and run esta
+
+07:16.760 --> 07:22.400
+es una herramienta que nos va a permitir
+hacer la compilación directamente desde aquí con al
+
+07:22.400 --> 07:34.000
+presionar f6 o f7 muy bien vamos a
+instalarlo y listo ya tenemos todo lo que necesitábamos para
+
+07:34.000 --> 07:39.680
+poder comenzar a programar ahora voy a
+cerrar esto no tenemos ningún folder abierto no tenemos
+
+07:39.680 --> 07:46.400
+ningún repositorio no te preocupes
+simplemente quiero que vayas acá a la ventana le des file y
+
+07:46.400 --> 07:52.880
+le des en new file este archivo nuevo
+presiona control s y esto te va a abrir esta ventana yo
+
+07:52.880 --> 08:01.960
+voy a ir a mi escritorio y aquí le voy a
+poner en file name le voy a poner hola hello world
+
+08:01.960 --> 08:10.520
+hello world punto c ya con esto vamos a
+saber que es un archivo de tipo c y nos va a tener el
+
+08:10.520 --> 08:17.800
+highlight de la sintaxis ahora vamos a
+escribir nuestro primer programa en c para esto vamos a
+
+08:17.800 --> 08:23.280
+poner hashtag include esta es una
+instrucción que vamos a utilizar para poder incluir librerías en
+
+08:23.280 --> 08:28.800
+nuestro código vamos a poner nuestro
+teclado en inglés es un tip que yo siempre te paso teclado
+
+08:28.800 --> 08:37.040
+en inglés es lo mejor para programar vamos
+a invocar la librería es stdio punto h estándar
+
+08:37.040 --> 08:45.280
+input output eso es lo que hace esta
+librería manejo de entradas y salidas estándares las
+
+08:45.280 --> 08:49.880
+básicas por decirlo así que quiere decir
+esto que nos va a servir para tener funciones como
+
+08:49.880 --> 08:55.680
+por ejemplo print que es una función que
+nos sirve para hacer un output a la terminal o imprimir
+
+08:55.680 --> 09:01.960
+algo en la terminal vamos a declarar
+nuestro main que es donde va a estar contenido todo nuestro
+
+09:01.960 --> 09:09.360
+código principal del programa vamos a
+abrir y cerrar llavecitas muy bien y vamos a escribir
+
+09:09.360 --> 09:16.520
+print que es la función que nos sirve para
+poder escribir algo a terminal vamos a poner hello
+
+09:16.520 --> 09:24.280
+platzi que es mi versión custom del hello
+world esto es así que punto y coma al final vamos a
+
+09:24.280 --> 09:31.760
+darle el return 0 esto retorcer o
+simplemente es la instrucción que vamos a tener para finalizar
+
+09:31.760 --> 09:38.360
+nuestro programa en c vamos a darle
+control s si te das cuenta no tenemos ningún problema nada que
+
+09:38.360 --> 09:46.400
+nos indique el editor vamos a apretar f6
+que es la extensión que descargamos y veamos lo que pasa
+
+09:46.400 --> 09:51.480
+si te das cuenta después de que apretamos
+f6 se nos abrió la terminal automáticamente dice windows
+
+09:51.480 --> 09:57.760
+power shell copyright a microsoft ok
+saludos a microsoft y dice trae de nucleus platform ok no
+
+09:57.760 --> 10:04.400
+no vamos a hacer eso de momento y vamos a
+ver qué pasa si te das cuenta nuestro programa ejecutó
+
+10:04.400 --> 10:10.160
+directamente todo lo que teníamos que
+hacer y nos dio la salida en terminal y luego se cerró
+
+10:10.160 --> 10:15.600
+maravilloso tenemos listo nuestro entorno
+de desarrollo en windows en la próxima vamos a
+
+10:15.600 --> 10:45.600
+aprender cómo hacerlo en un sistema
+linux
+
diff --git "a/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/05-Lecturas recomendadas.txt" "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/05-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..86314eec287bf3a3da9f4a7c1afb7e574676c4ea
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/05-Lecturas recomendadas.txt"
@@ -0,0 +1,2 @@
+https://sourceforge.net/projects/orwelldevcpp/
+https://code.visualstudio.com/
diff --git "a/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/05-Resumen.html" "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/05-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..7d67325f124fdbd0f6648d808455ce6114ee9a48
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/05-Resumen.html"
@@ -0,0 +1,151 @@
+
+
+
+
+
+
+ Configuración de Entorno para Programar en C en Windows
+
+
+
+
+
+
Resumen
¿Cómo preparar el entorno de desarrollo para programar en C en Windows?
+
Si te apasiona la programación y deseas iniciarte en el lenguaje C, el primer paso es preparar adecuadamente tu entorno de desarrollo. La programación en C requiere de un entorno bien configurado para compilar y ejecutar código de manera eficiente. En este artículo, aprenderás a configurar Dev-C++, un IDE potente y gratuito, así como a integrar Visual Studio Code para optimizar tu flujo de trabajo.
+
¿Cómo instalar Dev-C++?
+
Dev-C++ es un entorno de desarrollo integrado (IDE) que facilita la programación en C y C++. Su descarga e instalación son sencillas y se pueden realizar en pocos pasos:
+
+
+
Descarga de Dev-C++:
+
+
Visita la página surforge.net y haz clic en "Download". Este enlace específico está disponible en la sección de enlaces de la plataforma.
+
Guarda el archivo de descarga (aproximadamente 50 MB) en tu máquina y espera a que finalice la descarga.
+
+
+
+
Instalación de Dev-C++:
+
+
Ejecuta el programa descargado. Windows solicitará permisos administrativos, acepta para continuar.
+
Selecciona el idioma inglés durante la instalación.
+
Revisa y acepta el acuerdo de licencia GNU.
+
Opta por la instalación estándar y deja que el instalador haga su trabajo.
+
+
+
+
¿Cómo configurar las variables de entorno?
+
Configurar correctamente las variables de entorno es clave para que la terminal de Windows pueda reconocer el compilador de C:
+
+
+
Acceso a Variables de Entorno:
+
+
Abre el menú de inicio presionando la tecla Windows y busca "environment variables" o "variables de entorno".
+
En la ventana de propiedades del sistema, haz clic en "Variables de entorno".
+
+
+
+
Agregar Variables:
+
+
Agrega una nueva variable de entorno llamada 'devc' apuntando a la ruta donde se instaló Dev-C++.
+
Repite el proceso para el compilador gcc, asegurándote de validar el camino hacia el directorio dev-cpp\MinGW\bin.
+
+
+
+
Validación:
+
+
Abre cmd (uso de la tecla Windows + cmd) y escribe gcc para verificar que el compilador esté correctamente configurado. Debes ver un mensaje de error relacionado con la falta de archivos de entrada, lo que es normal en este punto.
+
+
+
+
¿Cómo instalar Visual Studio Code y las extensiones necesarias?
+
Visual Studio Code es un editor de código muy popular que ofrece extensiones específicas para C:
+
+
+
Descarga e Instalación:
+
+
Descarga Visual Studio Code desde el sitio oficial de Microsoft.
+
Ejecuta el instalador y sigue las instrucciones para finalizar la instalación. Es necesario reiniciar la computadora para completar el proceso.
+
+
+
+
Configuración de Visual Studio Code:
+
+
Abre Visual Studio Code y busca la extensión "C/C++" desarrollada por Microsoft. Instálala para habilitar el soporte de sintaxis para estos lenguajes.
+
Instala también "C/C++ Compile and Run" para facilitar la compilación y ejecución directamente desde VS Code utilizando las teclas F6 o F7.
+
+
+
+
¿Cómo crear y ejecutar tu primer programa en C?
+
Con el entorno ya configurado, es hora de empezar a programar en C:
+
+
+
Creación de Archivo C:
+
+
En Visual Studio Code, ve a "File" > "New File", nombra el archivo como hello_world.c y guárdalo en el escritorio o en un directorio de tu elección.
Este código simple usa la función printf de la librería stdio.h para imprimir en la terminal.
+
+
+
+
Compilación y Ejecución:
+
+
Guarda los cambios con Ctrl+S. Luego presiona F6 para compilar y ejecutar el programa.
+
Verás la salida en la terminal integrada de Visual Studio Code: "Hello Platzi".
+
+
+
+
Con estos pasos, has configurado exitosamente tu entorno de desarrollo para comenzar a programar en C. ¡Continúa explorando y aprendiendo para dominar este poderoso lenguaje de programación!
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/06-Instalaci\303\263n y Ejecuci\303\263n de Programas C en Linux.mp4" "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/06-Instalaci\303\263n y Ejecuci\303\263n de Programas C en Linux.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..1b9122ace7c707202858f44e42f7bdf12faad7fd
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/06-Instalaci\303\263n y Ejecuci\303\263n de Programas C en Linux.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e505e592952d23f5501436c1e40bcd478c32e2942e7886a0ef1845c46ab649d
+size 54141190
diff --git "a/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/06-Instalaci\303\263n y Ejecuci\303\263n de Programas C en Linux.vtt" "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/06-Instalaci\303\263n y Ejecuci\303\263n de Programas C en Linux.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..bc2711cc5626f0defd89a59f4fdf185ae40b79ba
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/06-Instalaci\303\263n y Ejecuci\303\263n de Programas C en Linux.vtt"
@@ -0,0 +1,214 @@
+WEBVTT
+
+00:00.000 --> 00:08.320
+Hola, en esta clase te voy a enseñar cómo
+instalar C en Linux. Vamos a abrir nuestra
+
+00:08.320 --> 00:16.840
+terminal. Ya la tengo aquí lista. Tengo
+Ubuntu. Si te das cuenta, aquí en la terminal simplemente
+
+00:16.840 --> 00:21.680
+tienes que empezar como administrador y la
+primera instrucción que vamos a utilizar es sudo app.
+
+00:21.680 --> 00:29.400
+Vamos a dar utilizar install y vamos a
+instalar GCC. Aquí en Linux es súper fácil, simplemente
+
+00:29.400 --> 00:30.520
+ponemos nuestro
+password
+
+00:33.120 --> 00:39.880
+y vamos a esperar a que termine. Te dice, oye,
+van a ser 115 megabytes. Pues sí, no hay problema.
+
+00:39.880 --> 00:45.840
+Esperamos a que termine. Vamos a ver qué
+nos arrojan. Todo debería de ser exitoso. Lo estamos
+
+00:45.840 --> 00:52.200
+haciendo con permisos de administrador y
+todo lo que necesitamos. Ahora, para verificar que la
+
+00:52.200 --> 01:01.280
+instalación fue correcta, vamos a escribir
+GCC y veamos qué nos indica. Esto significa que la
+
+01:01.280 --> 01:08.560
+instalación falló. Cuando esto falle en tu
+distribución de Ubuntu o Debian, lo que estés
+
+01:08.560 --> 01:14.480
+utilizando, simplemente vamos a darle
+update que nos va a actualizar todos los enlaces a donde
+
+01:14.480 --> 01:20.680
+podemos descargar información. Vamos a
+esperar a que termine. Listo y ya tenemos nuestros packages
+
+01:20.680 --> 01:27.080
+upgradeados, actualizados. Ahora sí vamos
+a proceder a instalar. Vamos a esperar a que termine. Nos
+
+01:27.080 --> 01:32.360
+vuelve a preguntar que van a ser 118 megas.
+Le volvemos a decir que sí y esperamos a que termine
+
+01:32.360 --> 01:37.560
+la instalación. Una vez se terminó de
+instalar, te recomiendo que aprietes el comando clear para
+
+01:37.560 --> 01:42.320
+que todo esté bien. Regresamos a la parte
+superior de nuestra consola y vamos a escribir el comando
+
+01:42.320 --> 01:51.120
+gcc-version. Esto nos va a decir la
+versión que tenemos instalada de GCC y todo está bien.
+
+01:51.120 --> 01:56.160
+Vemos que tenemos instalado GCC, nos dice
+que está instalado en nuestro Ubuntu, nos dice que tenemos
+
+01:56.160 --> 02:03.880
+un Ubuntu 18.04. Muy bien. Esta es
+información sobre Ubuntu, esta es la información de nuestro
+
+02:03.880 --> 02:14.200
+GCC que es la versión 7.5.0. Muy bien,
+excelente. Ahora vamos a darle y fíjate que dicen que no
+
+02:14.200 --> 02:19.240
+hay garantía, que esto es software gratis.
+A ver, esto es software gratis pero es software muy bueno que
+
+02:19.240 --> 02:24.880
+se ha desarrollado por muchos años pero de
+todos modos ellos hacen el disclaimer de que no te van
+
+02:24.880 --> 02:29.760
+a pagar nada si los demandas porque no
+programaste bien. ¿Qué ha pasado? Te voy a dejar el link a un
+
+02:29.760 --> 02:35.880
+artículo súper interesante de no programar
+bien utilizando los estándares sobre todo en código C
+
+02:35.880 --> 02:41.720
+y lo que permitió que pasara. De hecho lo
+veremos en una clase más adelante en donde hablemos de la
+
+02:41.720 --> 02:48.480
+importancia de ser muy responsables al
+momento de escribir código. Pero con esto dicho vamos a
+
+02:48.480 --> 02:53.040
+escribir nuestro primer programa. Para
+esto voy a utilizar la instrucción touch para crear un nuevo
+
+02:53.040 --> 03:00.240
+archivo y voy a crear un archivo que se
+llame hello.c. Si te das cuenta ahora presionando ls
+
+03:00.240 --> 03:06.200
+aquí aparece nuestro nuevo archivo hello.
+c así que vamos a abrirlo. Voy a abrirlo con beam el editor
+
+03:06.200 --> 03:13.040
+de código que ya trae la terminal de
+ubuntu hello.c. Esto nos abre beam, te recomiendo que presiones
+
+03:13.040 --> 03:20.320
+y para comenzar a insertar caracteres y
+vamos a escribir nuestro código que sería hashtag include
+
+03:20.320 --> 03:29.720
+le vamos a decir que incluya stdio.h es el
+mismo código que hicimos en la clase anterior para el
+
+03:29.720 --> 03:35.280
+hola mundo en windows sólo que ahora desde
+linux luego vamos a declarar nuestro main en donde va
+
+03:35.280 --> 03:41.920
+a estar toda la parte principal de nuestro
+código abrimos y cerramos y abrimos nuestras llaves
+
+03:41.920 --> 03:49.680
+cerramos nuestras llaves muy bien y aquí
+adentro de estas dos llaves va a estar el código. Este
+
+03:49.680 --> 03:57.640
+código bueno pues ya sabes vamos a
+utilizar print y en print vamos a poner hello.c
+
+03:58.560 --> 04:09.040
+cerramos nuestro print punto y coma al
+final y por último un return 0 punto y coma vamos a guardar
+
+04:09.040 --> 04:15.480
+casi presionó control s pero esto es beam
+no se guarda así así que el comando para guardar
+
+04:15.480 --> 04:22.800
+en beam es dos puntos wq no pero no lo voy
+a poner acá uy bueno aquí está bien todo sigue cerrado
+
+04:22.800 --> 04:30.520
+vamos a salir del modo de insertar presión
+escape y ahora escribe dos puntos w q y este es el comando
+
+04:30.520 --> 04:36.720
+para salvar y para salirnos del archivo
+todo bien ya logramos guardar nuestro archivo y logramos
+
+04:36.720 --> 04:45.480
+salirnos ahora tenemos que proceder a
+ejecutar nuestro código en c para esto vamos a utilizar la
+
+04:45.480 --> 04:50.360
+instrucción gcc que es lo que recién
+instalamos nuestro compilador le vamos a pasar el flag de
+
+04:50.360 --> 04:57.320
+o y el archivo que estamos compilando que
+se llama hello este es el archivo de output que vamos a
+
+04:57.320 --> 05:05.040
+tener ok por eso el flag y luego vamos a
+pasarle el archivo que va a compilar que es hello punto c
+
+05:05.040 --> 05:13.960
+vamos a darle enter y listo aquí qué es lo
+que acabamos de hacer aquí compilamos nuestro archivo
+
+05:13.960 --> 05:21.360
+de c hello punto c y lo guardamos en un
+archivo hello veamos con ls y mira que ahora aparece en
+
+05:21.360 --> 05:26.920
+verde nuestro nuevo ejecutable este es el
+archivo en donde está el código el source file el código
+
+05:26.920 --> 05:33.480
+fuente y este es el ejecutable que
+acabamos de compilar así que lo que hay que hacer es ejecutarlo
+
+05:33.480 --> 05:40.720
+como valga la redundancia vamos a poner
+punto y slash hello para ejecutar y mira que nos aparece
+
+05:40.720 --> 05:49.120
+un bellísimo hello platzi muy bien
+logramos terminar la instalación en sistemas de tipo
+
+05:49.120 --> 05:54.000
+linux ya sabes cómo te vas a manejar en la
+terminal de ahora en adelante hiciste tu primer
+
+05:54.000 --> 06:03.600
+hola mundo en la próxima clase
+comenzaremos a aprender todo sobre este lenguaje vamos para allá
+
diff --git "a/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/06-Lecturas recomendadas.txt" "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/06-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..d938c38d408efb6140857e6bcc4fe8868d8f9367
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/06-Lecturas recomendadas.txt"
@@ -0,0 +1 @@
+http://xina.uoc.es/prestatgeries/PV00_75009_00197/mcomplement/faqcerrc.html
diff --git "a/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/06-Resumen.html" "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/06-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..3ac106e1852066f8c90c46bee4966ac5d8fedca7
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/01-Introducci\303\263n al lenguaje C/06-Resumen.html"
@@ -0,0 +1,130 @@
+
+
+
+
+
+
+ Instalación y Ejecución de Programas C en Linux
+
+
+
+
+
+
Resumen
¿Cómo instalar el compilador GCC en Linux?
+
El mundo de la programación en C dentro de Linux empieza con la instalación del compilador GCC. Con Ubuntu, es sorprendentemente sencillo y directo. Veremos cómo manejar la terminal, la instalación del compilador, y finalmente, cómo crear y ejecutar tu primer programa "Hello World". Vamos a sumergirnos en los detalles.
+
¿Cómo se realiza la instalación inicial?
+
La instalación del compilador GNU Compiler Collection (GCC) en Linux puede hacerse rápidamente a través de la terminal. Aquí te mostramos los pasos a seguir:
+
+
Abre la terminal: En Ubuntu, utiliza la terminal que viene preinstalada.
+
Instala GCC:
+
+
Escribe el comando sudo apt install gcc.
+
Introduce tu contraseña cuando se te solicite.
+
El sistema te indicará el tamaño de la descarga necesaria (aproximadamente 115 MB); confirma con "Sí".
+
+
+
+
Estos pasos iniciarán la descarga e instalación del compilador GCC.
+
¿Qué hacer si la instalación falla?
+
En ocasiones, puedes encontrarte con que al intentar verificar la instalación con el comando gcc, el sistema indique un error. En este caso, sigue estos pasos para resolverlo:
+
+
+
Actualiza los enlaces de descarga:
+
+
Usa el comando sudo apt update.
+
Espera la actualización de los paquetes.
+
+
+
+
Instala nuevamente GCC:
+
+
Repite el comando sudo apt install gcc.
+
Acepta la descarga adicional solicitada si es necesario.
+
+
+
+
Con esto, deberías tener GCC instalado correctamente en tu sistema.
+
¿Cómo verificar la instalación?
+
Para asegurarte de que GCC está instalado correctamente, puedes verificar la versión instalada:
+
+
Usa el comando: gcc --version.
+
La terminal debería mostrarte la versión de GCC instalada, además de la información sobre tu distribución de Ubuntu.
+
+
Este paso confirma que el compilador está listo para usarse.
+
¿Cómo crear y compilar un programa en C?
+
Ahora que tienes GCC instalado, es momento de crear tu primer programa "Hola Mundo". Aquí te mostramos cómo hacerlo utilizando el editor de texto Vim desde la terminal.
+
¿Cómo crear un archivo de programa en C?
+
+
+
Crea un nuevo archivo: Utiliza el comando touch hello.c para crear un archivo llamado hello.c.
+
+
+
Abre el archivo en Vim: Escribe vim hello.c para abrir el editor de texto Vim.
+
+
+
Escribe el código: En Vim, presiona i para insertar texto y escribe el siguiente código:
Para guardar y salir del editor Vim, realiza lo siguiente:
+
+
Presiona Esc para salir del modo de inserción.
+
Escribe :wq para guardar y cerrar el archivo.
+
+
¿Cómo compilar y ejecutar el programa en C?
+
Una vez que has guardado el archivo, es momento de compilar y ejecutar tu programa.
+
+
Compila el archivo: Utiliza el comando gcc -o hello hello.c para compilar el archivo y crear un ejecutable.
+
Ejecuta el programa: Escribe ./hello en la terminal. Deberías ver el mensaje "Hello, Platzi" impreso en la pantalla.
+
+
Con estos pasos, no solo has instalado GCC, sino que también has escrito, compilado y ejecutado tu primer programa en C en un entorno Linux. Estás listo para sumergirte más profundamente en este poderoso lenguaje. ¡Adelante, sigue aprendiendo!
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Introducci\303\263n a C/02-Estructura de un programa C/01-Estructura B\303\241sica de un Programa en C.mp4" "b/Curso de Introducci\303\263n a C/02-Estructura de un programa C/01-Estructura B\303\241sica de un Programa en C.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..153c82a6516374c461b3bd2ebc53c3fddbfd1db5
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/02-Estructura de un programa C/01-Estructura B\303\241sica de un Programa en C.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:18bd201e7a8a19b54294a49629c5f8aac34cffb2d150969eb755f83be40408e9
+size 40818360
diff --git "a/Curso de Introducci\303\263n a C/02-Estructura de un programa C/01-Estructura B\303\241sica de un Programa en C.vtt" "b/Curso de Introducci\303\263n a C/02-Estructura de un programa C/01-Estructura B\303\241sica de un Programa en C.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..30a0b437a842a239d2110d3203254c6bc6749899
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/02-Estructura de un programa C/01-Estructura B\303\241sica de un Programa en C.vtt"
@@ -0,0 +1,146 @@
+WEBVTT
+
+00:00.000 --> 00:08.520
+En esta clase vamos a estudiar cómo es la
+estructura de un programa en el lenguaje C.
+
+00:08.520 --> 00:13.280
+Vamos a nuestro Visual Studio Code, si
+estás en Ubuntu igual es compatible, si estás en Mac
+
+00:13.280 --> 00:18.840
+igual es compatible, no te preocupes en
+absoluto que todo va a funcionar perfectamente y quiero
+
+00:18.840 --> 00:24.480
+platicarte justo sobre cómo es la
+estructura general de un programa en el lenguaje C.
+
+00:24.480 --> 00:31.120
+Lo primero que vamos a tener en todo
+programa en C es la zona donde incluimos nuestras librerías.
+
+00:31.120 --> 00:38.880
+Esta zona oficialmente se conoce como
+preprocessor commands, básicamente son comandos que le van a
+
+00:38.880 --> 00:45.480
+decir al compilador que incluyan estos
+archivos antes de comenzar la compilación. ¿Por qué?
+
+00:45.480 --> 00:50.480
+Porque dentro del código hacemos uso de
+una función que está en esta librería.
+
+00:50.480 --> 00:57.200
+Estos se conocen como preprocessor commands.
+Muy bien, la siguiente línea que tenemos es el
+
+00:57.200 --> 01:04.520
+comando main, esta es la función principal
+en donde la ejecución del programa comienza. Todo
+
+01:04.520 --> 01:11.760
+el código que podamos tener va a estar
+aquí adentro, dentro de mi función main. Luego quiero
+
+01:11.760 --> 01:19.360
+poner un pequeño comentario para que sepas
+cómo se usan, esto lo vamos a poner con barra y asterisco,
+
+01:19.360 --> 01:33.520
+adentro vamos a poner first hello world in
+C language. Muy bien y vamos a cerrar nuestro comentario.
+
+01:35.440 --> 01:41.760
+Date cuenta que el comentario se abre con
+este símbolo que se forma de barra y asterisco,
+
+01:41.760 --> 01:47.400
+luego pones lo que sea y de verdad cuando
+digo lo que sea puede ser absolutamente todo el código,
+
+01:47.400 --> 01:53.960
+por ejemplo, si quisiéramos podemos
+comentar esto, copiar nuestro print, vamos a crear una nueva línea,
+
+01:53.960 --> 01:58.680
+vamos a pegarlo, vamos a identarlo, tiene
+que estar bien ordenado, recuerda que la identación
+
+01:58.680 --> 02:04.200
+es bien importante, básicamente cada nivel
+adentro del código hay que hacerlo visual, por eso dejo
+
+02:04.200 --> 02:10.320
+esta tabulación aquí y vamos a cambiarle
+lo que dice de hello platsip for hello student.
+
+02:10.320 --> 02:18.600
+Listo, vamos a guardar y recuerda que para
+compilar tienes que apretar f6, si tienes una laptop en
+
+02:18.600 --> 02:23.400
+donde por defecto hacen otras cosas como
+subirle el volumen, subir el brillo, tienes que utilizar
+
+02:23.400 --> 02:30.480
+la tecla function f6 que es fn y f6,
+vamos a apretarlo, vamos a esperar a que termine de
+
+02:30.480 --> 02:37.960
+compilar y listo compiló y mira que ahora
+dice hello student y el compilador ignora todo
+
+02:37.960 --> 02:43.400
+lo que teníamos por acá. Muy bien, ya
+entendiste cómo funcionan los comentarios, lo siguiente que
+
+02:43.400 --> 02:48.400
+tenemos es la línea del print, si te das
+cuenta estoy haciendo un repaso de toda la estructura
+
+02:48.400 --> 02:53.920
+principal de un programa en C, esto es una
+función que está disponible en C
+
+02:53.920 --> 03:01.360
+que causa que se imprima en terminal el
+mensaje que nosotros colocamos adentro y la última línea
+
+03:01.360 --> 03:08.520
+pero no menos importante es return 0,
+esto es lo que termina mi función principal main, siempre
+
+03:08.520 --> 03:15.320
+que pongas el return 0 dentro de un main
+se va a cerrar nuestra función principal y esto va a
+
+03:15.320 --> 03:22.480
+terminar la ejecución del programa, mira
+qué pasa si pongo el return 0 antes del print, vas a ver lo
+
+03:22.480 --> 03:29.560
+que ocurre, todo se debería romper, vamos
+a guardar y vamos a compilar y ejecutar nuestro programa, ya
+
+03:29.560 --> 03:35.720
+sabes esto lo hacemos con f6 y mira que
+simple y sencillamente lo compila, lo ejecuta pero no imprime
+
+03:35.720 --> 03:42.360
+nada, porque aquí se salió el programa,
+vamos a borrar eso, guardamos y vuelve a ejecutar y
+
+03:42.360 --> 03:50.480
+vas a ver cómo ahora sí va a aparecer
+hello student, con esto dicho ya sabes compilar un programa en C,
+
+03:50.480 --> 03:56.800
+sabes ejecutar un programa en C, sabes
+todo y sabes sobre todo cómo funciona la estructura de un
+
+03:56.800 --> 04:01.880
+programa básico en lenguaje C, estamos
+listos por esta clase, nos vemos en la próxima.
+
diff --git "a/Curso de Introducci\303\263n a C/02-Estructura de un programa C/01-Resumen.html" "b/Curso de Introducci\303\263n a C/02-Estructura de un programa C/01-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..c0548da62a4bd07e7c7ac6b2ac1782ff1ee204cd
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/02-Estructura de un programa C/01-Resumen.html"
@@ -0,0 +1,91 @@
+
+
+
+
+
+
+ Estructura Básica de un Programa en C
+
+
+
+
+
+
Resumen
¿Cuál es la estructura básica de un programa en C?
+
Al comenzar a programar en C, es fundamental entender la estructura básica de un programa. Esta comprensión te permitirá no solo escribir tus programas desde cero, sino también depurar y mejorar el código existente efectivamente.
+
¿Cómo se gestionan las librerías?
+
La primera parte de cualquier programa en lenguaje C es la sección de las librerías. Se trata de una zona conocida oficialmente como preprocessor commands. Estas instrucciones indican al compilador qué archivos debe incluir antes de comenzar la compilación. Las librerías contienen funciones y definiciones que nuestro programa puede necesitar utilizar. Por ejemplo, para las funciones de entrada y salida estándar, se suele incluir la librería stdio.h.
+
#include<stdio.h>
+
+
¿Qué es la función main?
+
La función main es la función principal donde comienza la ejecución del programa. Todo el código que escribas para que el programa realice determinadas tareas se encuentra dentro de esta función. En esencia, es el punto de partida para cualquier programa en C.
+
intmain(){
+// código del programa
+return0;
+}
+
+
¿Para qué sirven los comentarios?
+
En C, los comentarios son una excelente manera de documentar el código para que sea más comprensible y mantenible. Se inician con /* y se cierran con */. Puedes utilizarlos para explicar qué hace cada sección de tu código o para desactivar temporalmente partes del código sin eliminarlas.
+
/* Este es un comentario en C */
+
+
¿Cómo funciona la función printf?
+
La función printf es fundamental para interactuar con el usuario, ya que permite imprimir texto en la terminal. Esta función se encuentra en la librería stdio.h y es comúnmente utilizada para mostrar mensajes o variables al usuario.
+
printf("Hello, World!");
+
+
¿Por qué es importante el return 0?
+
El return 0 en la función main indica que el programa ha terminado de ejecutarse exitosamente. Es una práctica estándar que sugiere al sistema operativo que el programa se cerró sin problemas.
+
return0;
+
+
¿Qué ocurre si se altera el orden del return 0?
+
Colocar el return 0 antes, por ejemplo, de printf, terminaría la ejecución del programa antes de que logre imprimir cualquier mensaje. Esto significa que cualquier operación después de return 0 no se llevaría a cabo.
+
Recomendaciones para comenzar a programar en C
+
+
Practica frecuentemente: Escribe y compila pequeños programas para afianzar tus conocimientos.
+
Sigue la indentación adecuada: Facilita la lectura y mantenimiento del código.
+
Documenta tu código: Utiliza comentarios para explicar secciones complejas.
+
Experimenta con el compilador: Aprende a utilizar las teclas de función, como F6, para compilar y ejecutar tu código.
+
+
Programar en C puede parecer desafiante al inicio, pero con práctica y dedicación te volverás más eficiente con cada intento. ¡Sigue aprendiendo y explorando nuevas formas de mejorar tu código!
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/01-Lecturas recomendadas.txt" "b/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/01-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..8546899a9e7161f12a3a1a10c0587195bd785fb1
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/01-Lecturas recomendadas.txt"
@@ -0,0 +1 @@
+https://es.science19.com/what-is-e10-11567
diff --git "a/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/01-Resumen.html" "b/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/01-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..f6a5aa3c599edb850c32f4fd6e141fee5fc378f7
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/01-Resumen.html"
@@ -0,0 +1,118 @@
+
+
+
+
+
+
+ Tipos de Datos en C: Enteros y Flotantes
+
+
+
+
+
+
Resumen
¿Cuáles son los tipos de datos en lenguaje C?
+
El lenguaje C es un lenguaje de programación tipado, lo que significa que cada variable debe declararse con un tipo de dato específico. Esto es crucial tanto para el correcto funcionamiento de tu código como para optimizar el uso de memoria. A lo largo de esta guía, exploraremos las diferentes categorías de tipos de datos en C y cómo elegir el más adecuado para tus necesidades de programación.
+
¿Qué son los tipos de datos aritméticos?
+
Los tipos de datos aritméticos en C son aquellos diseñados para almacenar valores numéricos. Estos se subdividen en:
+
+
Enteros (Integer): Permiten almacenar números enteros, y se categoriza en varias variantes dependiendo del tamaño en bytes y si son firmados o no (signed o unsigned).
+
Punto flotante (Floating Point): Diseñados para almacenar números con decimales, y incluyen el tipo float, double, y long double.
+
+
Los enteros se pueden ajustar dependiendo de si necesitas o no incluir números negativos en tu programa. Incluso, puedes especificar el rango numérico, utilizando tipos de datos como unsigned int para números solo positivos.
+
¿Cómo elegir entre signed y unsigned?
+
Al seleccionar un tipo entre signed o unsigned, es esencial considerar el rango numérico de los datos que planeas manipular:
+
+
+
Signed Integers: Permiten representar tanto números negativos como positivos. Son ideales para cálculos como los que se requieren en un programa que maneja deudas o desplazamientos en coordenadas, donde los valores negativos son significativos.
+
+
+
Unsigned Integers: Solo permiten números positivos, expandiendo así el rango positivo disponible. Son útiles en situaciones donde los valores negativos no tienen sentido, como en conteos de elementos o cuando programamos sensores que solo reportan valores positivos.
+
+
+
¿Qué son los tipos de datos de punto flotante?
+
Para manejar números decimales y precisar cálculos aritméticos, C ofrece los tipos de datos de punto flotante:
+
+
+
Float: Ocupa 4 bytes y soporta hasta 6 posiciones decimales, ideal para cálculos rápidos donde la precisión extrema no es crítica.
+
+
+
Double: Ofrece el doble de precisión decimal que float, utilizando 8 bytes y manejando hasta 15 dígitos decimales, adecuado para aplicaciones que requieren cálculos medidos, como simulaciones científicas.
+
+
+
Long Double: Maximiza la precisión a 19 posiciones decimales distribuidas en 10 bytes. Este formato es óptimo para aplicaciones de alta precisión, como cálculos financieros complejos.
+
+
+
¿Por qué es crucial seleccionar el tipo de dato adecuado?
+
Elegir conscientemente el tipo de dato impacta en la eficiencia y fiabilidad de tus programas:
+
+
+
Gestión de Memoria: Usar tipos de datos con mayor capacidad del necesario ocasiona desperdicio de memoria, mientras que seleccionar un tipo con menos capacidad puede generar errores de cálculo o truncamiento de datos.
+
+
+
Rangos Precalculados: Prever el rango de valores en tus variables evita desbordamientos, problemas de almacenamiento y asegura que tu código funcione correctamente bajo todas las condiciones esperadas.
+
+
+
Exactitud de Cálculos: En aplicaciones precisas, como cálculos de nómina o de distancias en aplicaciones de sensores, es esencial que el tipo de dato asevere exactitud y no introduzca errores acumulativos por denominaciones incorrectas.
+
+
+
¿Qué prácticas se deben adoptar al programar en C?
+
Para garantizar calidad y optimización al programar en C:
+
+
+
Calcula rangos mínimos y máximos de las variables antes de implementarlas, permitiendo elegir adecuadamente el tipo de dato en función de las necesidades específicas.
+
+
+
Investiga las características de tu compilador, o cómo este maneja los tamaños y almacenamientos de datos, asegurando que las especificaciones de tu programa concuerden con el entorno de ejecución.
+
+
+
Controla las entradas de datos en formularios o sensores. Implementa restricciones que aseguren que los datos procesados se mantengan dentro de los rangos, previniendo bugs y sobrecargas de sistema.
+
+
+
Optimiza el uso de memoria: Selecciona el tipo de dato que mejor se adapta a las necesidades de la aplicación sin excesos que afecten la eficiencia.
+
+
+
Cada tipo de dato en C tiene su propósito particular, y el dominio de estos te permitirá escribir código robusto, preciso y eficiente. A medida que te familiarices con estos conceptos, serás capaz de optimizar tus programas, asegurando que produzcan resultados precisos y fiables.
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/01-Tipos de Datos en C Enteros y Flotantes.mp4" "b/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/01-Tipos de Datos en C Enteros y Flotantes.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..aac38fa5b4c469c78f64624a424868c648d34b7b
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/01-Tipos de Datos en C Enteros y Flotantes.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:792d94c14dc6d0c957709116c118c39d010816dcee96d13074846dd25bc1d57f
+size 160127996
diff --git "a/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/01-Tipos de Datos en C Enteros y Flotantes.vtt" "b/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/01-Tipos de Datos en C Enteros y Flotantes.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..34ce43c9dd6d175590e6949c2e783e3e0f1eb417
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/01-Tipos de Datos en C Enteros y Flotantes.vtt"
@@ -0,0 +1,522 @@
+WEBVTT
+
+00:00.000 --> 00:08.560
+Hola, en esta clase vamos a aprender sobre
+los tipos de datos de C. Esto va a ser fundamental
+
+00:08.560 --> 00:15.000
+para comenzar a entender cómo funciona
+este lenguaje de programación. Recuerda que C es
+
+00:15.000 --> 00:19.920
+un lenguaje de programación tipado, es decir,
+siempre tienes que declarar de qué tipo de
+
+00:19.920 --> 00:23.960
+dato va a ser tu variable, pero no te
+preocupes, igual si es tu primer curso de programación,
+
+00:23.960 --> 00:28.320
+lo vas a entender todo paso a paso, pero
+si vienes de otro lenguaje, pues para que te vayas
+
+00:28.320 --> 00:34.320
+familiarizando con él, desde ahora. Vamos
+a mi editor de código. Tengo el archivo hello world.c,
+
+00:34.320 --> 00:39.280
+que es el archivo que ya habíamos trabajado,
+y quiero usarlo para escribirte o contarte un
+
+00:39.280 --> 00:46.200
+par de cosas aquí en mi pantalla. En C
+vamos a tener los basic types,
+
+00:48.840 --> 00:53.200
+que van a ser tipos básicos de datos en
+donde nosotros vamos a poder tener
+
+00:53.200 --> 00:59.320
+o vamos a poder almacenar información
+aritmético. Entonces aquí vamos a poder
+
+00:59.320 --> 01:05.920
+tener en los basics, nos vamos a dividir
+en tipos de datos aritméticos
+
+01:08.360 --> 01:16.160
+y tipos de datos, que lo voy a guardar con
+B aquí para que tengas la referencia, flotantes
+
+01:17.840 --> 01:19.680
+o de punto
+flotante.
+
+01:19.680 --> 01:28.520
+¿Qué es lo que se suele declarar como
+float? Y en aritméticos es lo que podríamos declarar
+
+01:28.520 --> 01:33.680
+como integer, entre otros. Vamos a tener
+diferentes tipos de integer según la cantidad
+
+01:33.680 --> 01:40.440
+de información que querramos almacenar.
+Por ejemplo, en tipo de datos aritméticos vamos
+
+01:40.440 --> 01:48.200
+a tener que van a existir integer normales,
+este es de 2 a o 4 bytes según el compilador
+
+01:48.200 --> 01:55.960
+que estés usando y esto nos permitiría
+tener un rango numérico de aproximadamente
+
+01:57.360 --> 02:11.320
+menos 32.768, si es un integer de 2 bytes,
+a 32.768 o de menos 2.147.000.000, no, esto es mucho más que
+
+02:11.320 --> 02:26.520
+2.147.483.648 hasta 2.147.000.000, etcétera,
+etcétera, en positivo. Nota como todos estos rangos numéricos
+
+02:26.520 --> 02:33.240
+cuando estamos trabajando con una variable
+simple, una variable de tipo entero, nos va desde un rango
+
+02:33.240 --> 02:38.080
+que va en números negativos hasta un rango
+en números positivos. Hay ocasiones en las que tú
+
+02:38.080 --> 02:43.280
+estás programando y no necesariamente
+necesitas los números negativos y quizás te preguntas,
+
+02:43.280 --> 02:49.320
+pero cuando voy a no necesitar eso? Primero,
+para cuando no necesitas números negativos vamos a usar
+
+02:49.320 --> 02:56.600
+la instrucción unsigned int, este es un
+tipo de datos que es sin signo, es decir, no nos permite
+
+02:56.600 --> 03:03.240
+tener números negativos, entonces el rango
+de este número, de esta variable o de este
+
+03:03.240 --> 03:16.200
+tipo de datos que estaríamos declarando,
+sería de 0 a 65.000 o de 0 a 4.294.000.000. Date cuenta que esto
+
+03:16.960 --> 03:25.280
+y esto es la misma cantidad de datos,
+va del 0 al 65.000 y aquí va de la mitad, casi, de 32.768
+
+03:25.280 --> 03:33.440
+negativo a 32.767 negativos. Son la misma
+cantidad de datos que tenemos, simplemente que aquí,
+
+03:33.440 --> 03:38.400
+cuando tenemos integer, como tenemos la
+misma cantidad de memoria, y aquí quiero que te quede
+
+03:38.400 --> 03:44.080
+claro esto, si tenemos por ejemplo,
+hablemos de integers de 2 bytes solamente, entonces quitemos
+
+03:44.080 --> 03:50.160
+esto para que sea clara la explicación y
+quitemos esto, entonces también tendríamos que quitar esta
+
+03:50.160 --> 03:58.560
+parte. ¿Qué pasa? Quiero que te quede bien
+claro el concepto, entonces tenemos que este es de 2 bytes
+
+03:58.560 --> 04:05.440
+y tenemos que este de abajo también sería
+de 2 bytes. Lo que te quiero decir aquí es que a veces
+
+04:05.440 --> 04:10.320
+vas a tener variables que van a tener
+resultados negativos, por ejemplo, imagínate que estás
+
+04:10.320 --> 04:17.140
+haciendo una operación de deudas o de
+sumas o una operación, una calculadora, estás haciendo algún
+
+04:17.140 --> 04:23.120
+tipo de programa en donde te vas a mover
+un robot de un lado izquierdo a un lado derecho y utilizas
+
+04:23.120 --> 04:26.440
+los números positivos para el lado
+izquierdo y los números negativos para el lado derecho,
+
+04:26.440 --> 04:34.480
+entonces ahí tendrías que tener un valor
+de tipo signet, o sea, int entero, que nos va a ir desde
+
+04:34.480 --> 04:39.520
+los negativos hasta los positivos. En cambio,
+si tú simplemente estuvieras trabajando con valores
+
+04:39.520 --> 04:45.360
+positivos y nunca vas a tener restas,
+entonces no necesitarías tener la capacidad de irte a
+
+04:45.360 --> 04:51.640
+números negativos porque tu programa nunca
+va a recurrir a esto. Aquí te quiero decir algo,
+
+04:51.640 --> 04:56.400
+en C siempre tienes que estar pensando
+cuáles son los valores que se van a almacenar en tus
+
+04:56.400 --> 05:02.000
+variables. Una de las mejores prácticas
+que te puedo pasar es que antes de que tú lances un
+
+05:02.000 --> 05:09.520
+código al funcionamiento, a producción,
+a un robot, a lo que sea, debes de hacer los cálculos de
+
+05:09.520 --> 05:14.760
+cuáles van a ser los rangos mínimos y
+cuáles van a ser los rangos máximos de los valores que vas a
+
+05:14.760 --> 05:20.600
+tener en tu programa. ¿Por qué? Porque de
+esto depende que sepas qué tipo de dato vas a elegir,
+
+05:20.600 --> 05:27.320
+también necesitas saber tu compilador que
+estás ocupando, cómo los hace, en qué tamaños los
+
+05:27.320 --> 05:32.480
+guarda, todo esto igual lo puedes consultar,
+no hay ningún problema, el estándar hoy en día son
+
+05:32.480 --> 05:38.800
+los mayores, entonces el estándar hoy en
+día es que un tipo int va a ser de 4 bytes, eso es ya
+
+05:38.800 --> 05:46.640
+el estándar hoy por hoy y lo que lo que
+pasa con esto es que tú tienes que siempre ser capaz de
+
+05:46.640 --> 05:52.800
+decir ok esta variable puede llegar a un
+valor de 85 millones y ese es el máximo que puede llegar,
+
+05:52.800 --> 05:59.560
+entonces ¿qué tipo de dato le asigno? Ah
+bueno pues aplica tal tipo de dato o este código puede
+
+05:59.560 --> 06:05.280
+llegar a menos 100 y quizás te preguntas y
+si no sé cuánto tú tienes que saber, en C debes de tener
+
+06:05.280 --> 06:11.920
+el control siempre ¿por qué? porque si no
+vas a permitir que haya leaks de memoria o que sea
+
+06:11.920 --> 06:17.880
+simple y sencillamente ¿qué pasaría si tú
+tienes una calculadora y el límite de tus variables es
+
+06:17.880 --> 06:28.280
+del 0 al 10? ¿qué pasaría si tú sumas 9
+más 9? 18, ya no podría guardar, no podrías almacenar más
+
+06:28.280 --> 06:33.760
+que hasta el 10, eso es lo que quiero que
+entiendas, volvamos a la pantalla, si tú estás trabajando por
+
+06:33.760 --> 06:40.400
+ejemplo con puros números positivos pero
+declaras el int así y la suma total de tus datos daba
+
+06:40.400 --> 06:46.520
+40 mil en una parte de tu programa,
+entonces ¿tú crees que podrías almacenar 42 mil en tu variable
+
+06:46.520 --> 06:53.480
+de tipo entero? no, no podrías almacenar
+40 mil, no podrías almacenar 42 mil, nada más allá de
+
+06:53.480 --> 07:03.000
+32 mil 767, es más seamos exactos no
+podrías almacenar un valor que te diera 32 mil 768 y
+
+07:03.000 --> 07:07.680
+te preguntas bueno pero un 1 ¿qué pasa
+aquí? imagínate que estás programando una aplicación
+
+07:07.680 --> 07:12.880
+de nómina, si no puedes almacenar a más de
+un valor entonces puedes dejar a gente sin su pago
+
+07:12.880 --> 07:17.120
+completo o imagínate que estás haciendo
+una aplicación que se encarga de medir distancias
+
+07:17.120 --> 07:25.920
+a través de un sensor láser y el máximo
+que tu variable puede llegar es a 128 ¿no? de menos 128
+
+07:25.920 --> 07:35.480
+a más 128 ¿qué pasaría ahí? de menos 128 a
+más 127, ponle ¿qué pasaría aquí? pues entonces si
+
+07:35.480 --> 07:41.120
+tuvieras que guardar un valor numérico de
+200 ya no cabría y la máxima distancia que estaría midiendo
+
+07:41.120 --> 07:48.240
+tu sensor sería 127 ¿y qué pasa si hay un
+cálculo importantísimo que te iba a servir ahí? bueno,
+
+07:48.240 --> 07:53.560
+¿me explico? es súper esencial que sepas
+de qué tamaño vas a estar usando tus tipos de datos,
+
+07:53.560 --> 08:00.480
+ahora continuemos aprendiendo más tipos de
+datos que hay en C, otro tipo de datos que puede ser
+
+08:00.480 --> 08:06.400
+muy común para operaciones simples va a
+ser el short, el tipo de datos short te va a servir,
+
+08:06.400 --> 08:14.160
+este si es de 2 bytes, no importa qué
+compilador estés usando está estandarizado en 2 bytes y va
+
+08:14.160 --> 08:20.720
+a llegar a esta misma distancia, déjame
+ponerlo en 4 bytes el otro para que nos vayamos con el
+
+08:20.720 --> 08:35.440
+estándar vamos a ponerle 4 bytes y vamos a
+ponerle sus valorcitos, ese es para el que va de números
+
+08:35.440 --> 08:45.000
+pues de números negativos a números
+positivos y vamos a poner la versión de 4 bytes cuando es
+
+08:45.000 --> 08:50.120
+un signet, entonces ya espero que te haya
+quedado muy claro, estoy seguro que te ha quedado muy
+
+08:50.120 --> 08:56.360
+claro cuándo debes usar un signed int y
+cuándo debes usar int, ahora vamos a ver el short, de
+
+08:56.360 --> 09:01.640
+momento todavía no vamos a entrar a punto
+flotante entonces short todavía sigue siendo aritmético,
+
+09:01.640 --> 09:07.720
+vamos a ponerlo aquí, hay que ser muy
+ordenados para que nuestro código esté claro y legible,
+
+09:07.720 --> 09:13.720
+el short todos los tipos de datos van con
+letra minúscula entonces tenemos el short listo,
+
+09:13.720 --> 09:21.680
+muy bien, obviamente existe un signet short,
+todas tienen su versión unsigned, short y la
+
+09:21.680 --> 09:32.080
+versión de unsigned short va de 0 a 65 mil,
+es de 2 bytes y va de 0 hasta 65 mil, aquí hay otro
+
+09:32.080 --> 09:43.280
+tipo de datos que vamos a poder tener para
+números enteros que va a ser long, el número long también
+
+09:43.280 --> 09:51.080
+puede ser como ya sabes del tipo normal
+que sería con signos y del tipo normal sin signos, así que
+
+09:51.080 --> 09:59.680
+podemos declarar long, long va a ser una
+variable de 8 bytes y nos va a dar estos rangos, la verdad
+
+09:59.680 --> 10:08.000
+son números que ya ni siquiera puedo leer,
+mira aquí hay 700 mil, aquí hay 854 millones, sí bueno
+
+10:08.000 --> 10:15.280
+tú te das cuenta son ya para cuando tienes
+cifras muchísimo más grandes y también tenemos unsigned
+
+10:15.280 --> 10:24.120
+long, quizás dices, bueno esta clase me la
+puedo saltar, no, esto es importantísimo en C
+
+10:24.120 --> 10:29.520
+porque todos tus programas van a depender
+de esto, ya cuando tú sabes cuál puede ser el valor máximo
+
+10:29.520 --> 10:35.640
+en tu código de los números, como tú
+tienes control de todo cuando estás programando en C, pues
+
+10:35.640 --> 10:41.400
+entonces puedes poner restricciones en tus
+cajas de texto, restricciones en tus inputs para que no
+
+10:41.400 --> 10:47.000
+aceptes números más grandes a x cantidades
+porque si no tú sabes que tu código se rompería, a eso
+
+10:47.000 --> 10:54.280
+me refiero con que todo debe de estar
+precalculado, volvamos a nuestro código y date cuenta que estos
+
+10:54.280 --> 11:01.040
+son, quiero decirte que estos son los tres
+tipos de datos que vamos a tener aritméticos, es
+
+11:01.040 --> 11:11.960
+decir que son valores íntegros, valores
+enteros, valores enteros, muy bien todo en orden, ahora
+
+11:11.960 --> 11:20.320
+veamos los tipos de datos de punto
+flotante que vamos a tener, para tipo flotante tenemos las
+
+11:20.320 --> 11:26.240
+siguientes herramientas, los siguientes
+tipos de datos, que el primero va a ser el clásico float,
+
+11:26.240 --> 11:38.080
+este es de 4 bytes y su rango es el siguiente,
+además tiene seis lugares o seis posiciones
+
+11:38.080 --> 11:45.480
+decimales, muy bien, si te das cuenta aquí
+lo estamos expresando en notación científica, si no
+
+11:45.480 --> 11:50.320
+conoces la notación científica te voy a
+dejar un enlace que te lo explica súper fácil en la sección
+
+11:50.320 --> 11:56.640
+de links, no nada, pero yo creo que ya
+deberías saberlo, vamos a tener también aquí el tipo double,
+
+11:58.640 --> 12:05.880
+double, recuerda que la notación
+científica se ocupa para escribir números muy grandes de
+
+12:05.880 --> 12:13.960
+forma legible, vamos a ir aquí, mira que
+este va a tener 308 posiciones, o sea en lo negativo el
+
+12:13.960 --> 12:20.920
+punto se recorrería 308 hacia un lado y en
+lo positivo el punto se recorrería 308 hacia el
+
+12:20.920 --> 12:28.360
+otro lado para darnos una cantidad
+astronómica tal como la tenemos aquí arriba, ahora aquí
+
+12:28.360 --> 12:34.320
+por qué los números no son como estos que
+son tan grandes, porque aquí tenemos las posiciones
+
+12:34.320 --> 12:43.640
+decimales, 15 decimal places, qué
+significa 6 decimal places, 15 decimal places, que aquí vas a
+
+12:43.640 --> 12:49.880
+poder tener 15 datos después del punto,
+aquí vas a poder tener 6, si te das cuenta la precisión
+
+12:49.880 --> 12:58.880
+aquí es gigantesca y por último vamos a
+tener long double y si te das cuenta estos valores no
+
+12:58.880 --> 13:09.280
+pueden ser un SIN, simplemente los tienen
+en SIN y ya, y este es de 10 bytes y los valores que puede
+
+13:09.280 --> 13:20.680
+tener son los siguientes y este tiene 19
+posiciones decimales, es decir nos permite tener 19 valores
+
+13:20.680 --> 13:27.920
+después del punto, es muy importante que
+en estas variables tengas la claridad de cuántos puntos
+
+13:27.920 --> 13:33.200
+decimales necesitas y aquí te voy a pasar
+un tip súper rápido, si tú estás trabajando cuestiones
+
+13:33.200 --> 13:38.560
+financieras pues obviamente no te va a
+servir 6 puntos decimales, deberías tener más quizás,
+
+13:38.560 --> 13:48.880
+por qué? quizás dices pero no tengo,
+o sea con 6 ya puedo tener punto 263 521 centavos, claro pero
+
+13:48.880 --> 13:57.480
+si te faltaron 5 o 6 dígitos después para
+que tengas el número exacto, qué pasa cuando sumas
+
+13:57.480 --> 14:04.320
+unas 100.000 veces esos datos que estaban
+faltando la información, sin duda el número final te va a
+
+14:04.320 --> 14:09.760
+fallar, por eso es que ellos pensaron
+cuando se desarrolló este lenguaje o en general en muchos
+
+14:09.760 --> 14:17.240
+lenguajes en que tú seas capaz de tener el
+control de cuánto o qué información vas a poder guardar,
+
+14:17.240 --> 14:23.600
+qué pasa con más valores o qué pasa si yo
+pongo más puntos decimales simplemente no los guardaría,
+
+14:23.600 --> 14:29.120
+así que tienes que tener mucho cuidado con
+eso porque si no usas el correcto estarías simple y
+
+14:29.120 --> 14:34.440
+sencillamente perdiendo información,
+pero si simplemente usas long double en todo entonces
+
+14:34.440 --> 14:41.040
+estarías desperdiciando memoria, por eso
+te digo en C tienes que aprender a calcular lo que vas a
+
+14:41.040 --> 14:51.440
+utilizar. Con esto terminamos los tipos de
+datos aritméticos, que es una forma fancy de decir
+
+14:51.440 --> 14:58.000
+números o de tipos de datos numéricos pero
+es la correcta y los tipos aritméticos se dividen en dos
+
+14:58.000 --> 15:05.600
+en valores enteros que vamos a tener y en
+valores de punto flotante, el primero siendo float y double
+
+15:05.600 --> 15:12.240
+y long double en respecto a los puntos
+flotantes y valores enteros siendo int, short, long, los tres
+
+15:12.240 --> 15:17.920
+con sus versiones unsigned. En la próxima
+clase aprenderás cómo puedes usar estos tipos de datos
+
+15:17.920 --> 15:28.160
+declarando variables y qué deberías
+almacenar en cada una de ellas. Nos vemos allá.
+
diff --git "a/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/02-Resumen.html" "b/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/02-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..fd1572bded6353fa5f051f267ccd234258761729
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/02-Resumen.html"
@@ -0,0 +1,89 @@
+
+
+
+
+
+
+ Uso del Tipo de Dato Void en Programación en C
+
+
+
+
+
+
Resumen
¿Qué es el tipo de dato void en C?
+
El tipo de dato void es una pieza clave en el lenguaje de programación C, a pesar de que los tipos de datos más utilizados sean los aritméticos, como valores flotantes o enteros. Aquí, el tipo de dato void se presenta como importante y versátil, usado especialmente en varios escenarios que detallaremos a continuación.
+
¿Cuándo una función devuelve void?
+
En C, el tipo void se usa principalmente para especificar que una función no retorna ningún valor. Por ejemplo, mientras que la función main del programa usualmente devuelve un entero —específicamente el valor 0—, una función declarada de la siguiente manera no devolvería nada:
+
voidfunction(){
+// Función que no retorna ningún valor
+}
+
+
Las funciones void son útiles cuando la función ejecuta tareas que no requieren devolver un resultado, como modificar variables internas, realizar operaciones sin necesidad de una salida, etc.
+
¿Cómo funcionan los argumentos void en funciones?
+
Otro uso clave del tipo void es cuando una función no acepta parámetros. En este escenario, el tipo void se coloca en los paréntesis de la función para señalar que no se necesitan argumentos.
+
Imagina que queremos declarar una función que no necesite argumentos pero que aún devuelva algún valor. Paradoxalmente, esto se puede lograr:
+
intrandomFunction(void){
+returnrand();// Ejemplo de uso que devuelve un valor aleatorio
+}
+
+
Aquí, void dentro del paréntesis indica que no hay parámetros esperados, pero la función aún puede realizar operaciones que devuelvan un resultado.
+
¿Qué papel juegan los punteros void?
+
Uno de los conceptos más abstractos y a menudo desafiantes es el del puntero void. Este tipo de puntero es extremadamente flexible, ya que apunta a una dirección de memoria sin preocuparse por el tipo de dato que reside en esa ubicación.
+
void* ptr;
+// Ejemplo de uso de un puntero void
+
+
El poder de un puntero void radica en su capacidad para ser "casteado", o convertido, a cualquier otro tipo de puntero cuando sea necesario. Esto es vital para trabajar con diferentes tipos de datos sin conocer su tipo exacto en tiempo de compilación.
+
Importancia y aplicaciones de los casteos en C
+
Al trabajar con diferentes tipos de datos, los casteos son fundamentales. Permiten convertir tipos de datos en otros que son más adecuados para las operaciones que se desean realizar. Por ejemplo, para sumar un número entero con un número flotante, es necesario castear el entero a flotante:
Este tipo de flexibilidad es vital en programación para asegurar que los datos se manejen con la precisión y el tipo adecuados, aprovechando al máximo las capacidades del lenguaje C.
+
El tipo de dato void, aunque puede parecer avanzado y a veces confuso, se convierte en una herramienta esencial cuando se desea escribir código limpio y eficiente. A medida que avances en tu aprendizaje sobre funciones y punteros, verás cómo estos conceptos comienzan a integrarse de manera natural en tu programación diaria. ¡Sigue adelante con entusiasmo y curiosidad!
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/02-Uso del Tipo de Dato Void en Programaci\303\263n en C.mp4" "b/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/02-Uso del Tipo de Dato Void en Programaci\303\263n en C.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..17f655546c242ef3b6dc089e1943c24a442e1c06
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/02-Uso del Tipo de Dato Void en Programaci\303\263n en C.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f9626a72ac23c9b336a737cc3d916018be35a8af06355664036e38564e09c3fb
+size 73659734
diff --git "a/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/02-Uso del Tipo de Dato Void en Programaci\303\263n en C.vtt" "b/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/02-Uso del Tipo de Dato Void en Programaci\303\263n en C.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..85d493317f873b8e4a8f082f996c38f17c8b3c20
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/02-Uso del Tipo de Dato Void en Programaci\303\263n en C.vtt"
@@ -0,0 +1,242 @@
+WEBVTT
+
+00:00.000 --> 00:08.280
+En esta clase vas a aprender sobre otro
+tipo de datos que es esencial en el lenguaje de
+
+00:08.280 --> 00:13.640
+programación en C. Si bien los más
+populares que vas a estar manejando son los aritméticos,
+
+00:13.640 --> 00:18.720
+ya sea con valores flotantes o con valores
+enteros, igual vas a necesitar este nuevo
+
+00:18.720 --> 00:23.680
+tipo de datos y los próximos que veremos.
+Todos son igual de importantes, solo que en
+
+00:23.680 --> 00:31.240
+programación muchas veces lo que más
+utilizamos son números. Vamos a nuestro editor de código,
+
+00:32.280 --> 00:39.080
+vamos a escribir acá el tipo de dato nuevo
+que te quiero mostrar. Este tipo de dato nuevo que te
+
+00:39.080 --> 00:46.480
+quiero mostrar es el tipo de dato void,
+entonces vamos a escribirlo y esto lo vas a ver en muchas
+
+00:46.480 --> 00:57.720
+partes a lo largo del lenguaje C. Esto
+void lo que hace es que especifica que no hay valor
+
+00:57.720 --> 01:10.880
+disponible. Eso es lo que nos va a
+especificar y se usa en tres escenarios, por decirlo así.
+
+01:10.880 --> 01:34.560
+Bueno, el primero es que una función
+retorna un tipo de datos void. ¿Qué quiere decir esto? Que
+
+01:34.560 --> 01:42.800
+una función cuando la ejecutes no nos va a
+retornar ningún valor. Por ejemplo, una función como la que
+
+01:42.800 --> 01:49.840
+vemos acá en el main nos da un return 0.
+Esta función es del tipo entero porque nos retorna
+
+01:49.840 --> 01:57.120
+un valor de 0. Si tú le pusieras esta
+función void entonces no retornaría ningún valor y se
+
+01:57.120 --> 02:02.560
+rompería todo nuestro código en C. Esta
+función no puede ser de tipo void porque entonces cuando
+
+02:02.560 --> 02:08.200
+nos está retornando este 0 se no detecta
+que el main retorna 0 y eso va a hacer que el programa
+
+02:08.200 --> 02:12.760
+pues no se cerraría, simplemente el
+compilador puede que no te lo deje hacer, son muchas cosas.
+
+02:12.760 --> 02:18.840
+Por eso esta función main que es de tipo
+entero, que ahora ya sabes qué onda, nos retorna el valor
+
+02:18.840 --> 02:32.080
+0. Una función que se declara de la
+siguiente manera void function, esta sería una función
+
+02:32.080 --> 02:37.760
+que no nos va a retornar ningún valor y
+quizás te preguntas ¿para qué voy a querer utilizar una
+
+02:37.760 --> 02:42.040
+función que no nos va a retornar ningún
+valor? Primero veremos funciones más adelante en el
+
+02:42.040 --> 02:47.400
+curso pero te doy el pequeño spoiler y es
+que muchas veces vas a querer configurar variables
+
+02:47.400 --> 02:52.720
+adentro de tu función, cambiar valores,
+pero no necesariamente vas a querer que la función te
+
+02:52.720 --> 02:58.640
+regrese un resultado de una operación
+aritmética o te regrese alguna expresión en caracteres,
+
+02:58.640 --> 03:04.400
+no vas a querer nada, entonces ahí le
+tendrías que poner void para que el programa no espere
+
+03:04.400 --> 03:10.480
+que la función retorne algún tipo de salida.
+Las funciones pueden ser de todo tipo, char,
+
+03:10.480 --> 03:15.120
+las funciones pueden ser float, con todos
+los tipos de datos que hemos aprendido a usar pero
+
+03:15.120 --> 03:21.080
+eso lo veremos más adelante, solo quiero
+que te quede claro que void uno de sus usos es ese.
+
+03:21.080 --> 03:30.200
+Vamos a dejar aquí unos espacios con
+nuestro tabulador, vamos a poner el punto 2,
+
+03:30.200 --> 03:44.960
+function tiene argumentos de tipo void.
+Bueno esto es otro caso de uso, van a existir funciones
+
+03:44.960 --> 03:50.640
+que no aceptan ningún parámetro, una
+función que no acepta ningún parámetro va a ser una
+
+03:50.640 --> 03:58.520
+función que debe de tener void adentro,
+por ejemplo imagínate que declaramos una función
+
+03:58.520 --> 04:04.520
+para que nos dé un valor random, se puede
+utilizar el void ahí, entonces esta función que estoy
+
+04:04.520 --> 04:11.640
+declarando random no necesita ningún
+número como argumento, los argumentos de la función van a ir
+
+04:11.640 --> 04:17.880
+aquí adentro, y mira que esta función si
+nos va a retornar un valor en la salida, porque se puede
+
+04:17.880 --> 04:24.440
+declarar del tipo void. Vamos a poner de
+los ejemplos acá, solo quiero que tengas bien claro
+
+04:24.440 --> 04:37.320
+este tipo de dato que es void, void función,
+una función del tipo int que va a tener void,
+
+04:37.320 --> 04:42.440
+y mira que los tipos de datos también se
+ocupan en funciones, se ocupan en variables y en eso,
+
+04:42.440 --> 04:54.600
+vamos a tener el caso de uso número 3,
+puntero o apuntador, puntero o apuntador que va a la dirección
+
+04:56.000 --> 05:07.080
+en memoria de un objeto en la memoria
+física de tu computadora, pero no le importa el tipo de objeto
+
+05:07.080 --> 05:19.680
+que tenga, el tipo de dato que tenga, ok,
+what does this mean? qué significa esto? lo que pasa en el
+
+05:19.680 --> 05:26.360
+tercer caso es que tú puedes apuntar a una
+dirección de memoria para obtener un dato pero no necesariamente
+
+05:26.360 --> 05:32.880
+vas a ser capaz de que te diga cuál va a
+ser el tipo de datos que vas a estar trabajando, qué
+
+05:32.880 --> 05:38.200
+significa esto? bueno cuando estás
+trabajando con memoria las cosas se ponen complicadas pero no te
+
+05:38.200 --> 05:42.720
+preocupes que más adelante tenemos una
+clase bien buena que te va a explicar todo lo de los punteros,
+
+05:42.720 --> 05:49.800
+mientras tanto te cuento, tú en C puedes
+acceder directo a la memoria a través de apuntar a una
+
+05:49.800 --> 05:55.560
+dirección específica, si tú le pones void,
+si le pones que el puntero sea un dato como void,
+
+05:55.560 --> 06:02.160
+entonces no te va a importar el tipo de
+datos que tenga eso que tú estás manejando en la memoria,
+
+06:02.160 --> 06:09.080
+y esto te va a permitir hacer un casteo de
+este dato a cualquier tipo de datos, un casteo es
+
+06:09.080 --> 06:15.720
+agarrar una información y pasarla o
+transformarla a otro a un tipo de datos específico, los casteos
+
+06:15.720 --> 06:21.240
+son bien importantes porque a veces
+necesitas castear de números enteros a números flotantes
+
+06:21.240 --> 06:26.400
+ya que si no pues cómo vas a hacer la suma,
+qué deberías esperar al final, idealmente deberías
+
+06:26.400 --> 06:32.560
+de si quieres si estás trabajando con
+datos flotantes y por alguna razón había un número
+
+06:32.560 --> 06:36.880
+entero, bueno primero idealmente hubieras
+declarado todo como flotante pero si no tú
+
+06:36.880 --> 06:43.120
+puedes hacer un casteo para convertir tu
+número entero a un número de tipo flotante, existen
+
+06:43.120 --> 06:48.640
+varios casteos en C por defecto y también
+tú puedes programar casteos si quisieras a través
+
+06:48.640 --> 06:53.880
+de pues el código que se te permite escribir,
+con esto dicho ya hemos estudiado el tipo de
+
+06:53.880 --> 06:58.800
+dato void y espero que te quede claro,
+puede ser un poco confuso porque es avanzado pero si tienes
+
+06:58.800 --> 07:03.680
+dudas no te preocupes una vez vayamos
+viendo funciones, una vez vayamos viendo punteros,
+
+07:03.680 --> 07:08.120
+todo esto que acabas de aprender aquí va a
+ser todavía mucho más click pero mientras
+
+07:08.120 --> 07:26.520
+nos vemos en la siguiente
+clase.
+
diff --git "a/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/03-Enums en C Uso y Ejemplos Pr\303\241cticos para Constantes.mp4" "b/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/03-Enums en C Uso y Ejemplos Pr\303\241cticos para Constantes.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..c6151082fdd047ce62ffb95fc232f5a9a04ee50c
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/03-Enums en C Uso y Ejemplos Pr\303\241cticos para Constantes.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b39eb61d82d01ac7767289fb684ba006a359f2087f6f09f46c67971334a3b0df
+size 146113229
diff --git "a/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/03-Enums en C Uso y Ejemplos Pr\303\241cticos para Constantes.vtt" "b/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/03-Enums en C Uso y Ejemplos Pr\303\241cticos para Constantes.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..422d4392d03a9ff2ce913e5b4949af4dc678bac6
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/03-Enums en C Uso y Ejemplos Pr\303\241cticos para Constantes.vtt"
@@ -0,0 +1,498 @@
+WEBVTT
+
+00:00.000 --> 00:09.200
+En esta clase vas a aprender sobre los
+enums o enumerations en el lenguaje C. Esto es una
+
+00:09.200 --> 00:14.760
+especie de lista, es un tipo de datos que
+nos va a servir para guardar valores constantes.
+
+00:14.760 --> 00:20.320
+¿Cómo así? Vamos a Visual Studio Code.
+Lo primero que voy a hacer es guardar todo lo
+
+00:20.320 --> 00:25.560
+que había escrito en la clase anterior y
+voy a ir a File, voy a crear un new file y lo voy
+
+00:25.560 --> 00:35.640
+a guardar como enums.c. Básico. Espero que
+hagas lo mismo y me acompañes a lo largo de esta clase.
+
+00:35.640 --> 00:41.040
+Veamos un ejemplo directo en código para
+que nos vaya quedando claro. Una de las grandes formas
+
+00:41.040 --> 00:47.440
+de explicar los enums, imagínate que tú
+tienes un caso de uso en donde vas a tener datos constantes
+
+00:47.440 --> 00:52.840
+que vas a necesitar en tu programa y que
+van a pertenecer a un mismo grupo de datos. Por ejemplo,
+
+00:52.840 --> 00:59.920
+los días de la semana de lunes a domingo.
+Eso quedaría perfecto en un enum porque puedes
+
+00:59.920 --> 01:05.360
+guardar los días lunes, martes, miércoles,
+jueves, viernes, sábado y domingo y entonces puedes crear
+
+01:05.360 --> 01:11.680
+tu enum que se llame semana. Tienes tus
+valores constantes que son los días de la semana adentro
+
+01:11.680 --> 01:17.360
+de un enum que contiene toda la semana.
+Esta es la lógica que debes usar cuando tengas que
+
+01:17.360 --> 01:23.480
+tomar la decisión si deberías usar un enum
+o no. Otro caso de un enum sería para quizás estás
+
+01:23.480 --> 01:30.360
+pensando un juego y vas a declarar que tal
+tipo de carta tiene tal tipo de ataque. Por ejemplo,
+
+01:30.360 --> 01:36.480
+entonces puedes crear un enum en donde
+crees la carta mazos, la carta espadas, la carta copas,
+
+01:36.480 --> 01:41.920
+la carta no sé cuál es la otra carta en la
+franja española pero tú me entiendes y a cada uno de
+
+01:41.920 --> 01:47.600
+estos tipos de carta le asignas un peso
+entonces tendrías todas las cartas guardadas en una
+
+01:47.600 --> 01:53.800
+variable que se llame dec o monte de cartas.
+Ese es otro ejemplo. Puedes pensar en tus propios
+
+01:53.800 --> 02:00.800
+ejemplos y me los puedes dejar en la
+sección de comentarios. Solo quiero comentarte que los enums,
+
+02:00.800 --> 02:07.600
+los valores o las variables dentro de un
+enum sólo pueden tener un valor. Entonces los enums
+
+02:07.600 --> 02:12.920
+pueden tener constantes como sería el caso
+de uso de los días de la semana y los enums también
+
+02:12.920 --> 02:18.440
+pueden tener variables que van a ser los
+datos que van a estar cambiando. ¿Por qué deberías usar
+
+02:18.440 --> 02:22.360
+variables dentro de un enum? Porque si en
+tu juego estamos hablando del juego de cartas,
+
+02:22.360 --> 02:27.680
+vas a más adelante a hacer un balance
+entre todas las cartas para que tengan diferentes o
+
+02:27.680 --> 02:32.440
+nuevos poderes de ataque por decir algo o
+nuevos valores numéricos por decir algo, entonces
+
+02:32.440 --> 02:37.640
+simplemente vas al enum, haces los cambios
+ahí y todo tu código, toda la lógica del juego sigue
+
+02:37.640 --> 02:43.280
+igual porque las cartas siguen siendo las
+mismas. Vamos a verlo en código. Otro ejemplo que te
+
+02:43.280 --> 02:47.800
+quiero mostrar y ya quiero que entremos en
+los detalles de cómo declararíamos un enum que va
+
+02:47.800 --> 02:53.560
+a tener variables. Imagínate que estás
+haciendo un sistema en donde los elementos de diseño van
+
+02:53.560 --> 03:01.840
+a ser súper importantes entonces yo podría
+poner design elements porque obviamente debes escribir
+
+03:01.840 --> 03:05.840
+código en inglés por favor si escribes
+código en español no lo hagas por nada del mundo.
+
+03:07.360 --> 03:15.000
+Design elements, vamos a abrir nuestras
+llaves y adentro vamos a declarar nuestro enum entonces
+
+03:15.000 --> 03:23.240
+vamos a decir que por decirlo así italics
+va a ser igual a 1 para que si alguien selecciona 1
+
+03:23.240 --> 03:33.800
+se ponga en italic o para que bold sea
+igual a 2 y para que underline o strike
+
+03:38.600 --> 03:43.720
+sea igual a 3 entonces estos son valores
+que vamos a estar definiendo en nuestro código
+
+03:43.720 --> 03:48.560
+obviamente estos números tendrían algún
+impacto en nuestra lógica más adelante ahora hagamos el
+
+03:48.560 --> 03:53.520
+ejemplo con los días de la semana pero ya
+hagámoslo con un código más completo voy a traerme aquí mi
+
+03:53.520 --> 03:59.320
+esqueleto básico de un programa en C ok
+para poder imprimir cositas voy a pegarlo en enums
+
+03:59.320 --> 04:06.600
+solamente tengo el stdio ya sabes tengo el
+main y arriba voy a declarar mi enum vamos a hacer justo
+
+04:06.600 --> 04:14.440
+eso no quiero imprimir hola mundo o ni
+hola estudiante vamos a declarar mi enum. Te acuerdas
+
+04:14.440 --> 04:18.760
+que te dije del ejemplo de los días de la
+semana veamos ese ejemplo en código cómo se podría
+
+04:18.760 --> 04:27.640
+mostrar ya sabes vamos a declarar nuestro
+enum y eso es todo ahora vamos a ponerle weekdays date
+
+04:27.640 --> 04:32.040
+cuenta que yo escribo en camel casing es
+decir siempre vas a empezar con minúscula y después
+
+04:32.040 --> 04:39.200
+cada letra va a estar en mayúscula cada
+palabra nueva va a empezar con su letra en mayúscula la
+
+04:39.200 --> 04:46.960
+primera entonces weekdays of month por
+ejemplo ese sería un caso de uso de mi camel casing que estoy
+
+04:46.960 --> 04:52.960
+teniendo pero no sólo weekdays es más que
+suficiente vamos a abrir nuestro enum vamos a
+
+04:52.960 --> 05:01.440
+crear nuestra listita sunday aquí estamos
+declarando una enumeración de valores constantes así que
+
+05:01.440 --> 05:08.800
+debes de separarlos por comas simple y
+sencillamente va a ser una vil y cruel lista una sencilla lista
+
+05:08.800 --> 05:17.400
+Tuesday, Sunday, Monday, Tuesday, Wednesday,
+tengo problemas siempre en pronunciar esa palabra a
+
+05:17.400 --> 05:25.000
+veces detalles no soy profe de inglés
+Friday y Saturday muy bien ya nos sabemos los días en
+
+05:25.000 --> 05:31.120
+inglés además de saber utilizar los enums
+luego vamos a nuestro main vamos a importar o llamar
+
+05:31.120 --> 05:38.400
+nuestro enum y vamos a decirle oye pásame
+el día de hoy week y quiero un valor que se llame
+
+05:38.400 --> 05:45.000
+today y aquí quizás te preguntas what que
+sería today bueno hay que declararlo entonces today
+
+05:47.240 --> 05:52.320
+today va a ser igual a
+Wednesday
+
+05:54.600 --> 06:02.560
+Wednesday y luego le voy a preguntar a se
+que me diga oye qué día es hoy por favor vamos a ponerle
+
+06:02.560 --> 06:09.520
+%d más adelante vamos a entrar a detalle
+en cómo son los estándares para escribir esto no te
+
+06:09.520 --> 06:17.120
+preocupes por nada entonces de ahí luego
+%d que es para darle formato a la salida quiero sacar
+
+06:17.120 --> 06:23.480
+un número decimal porque quiero saber cuál
+es el día del miércoles ok entonces va a ser today
+
+06:23.480 --> 06:30.560
+más uno y aquí quizás te preguntas por qué
+más uno por qué y esto es un concepto importantísimo
+
+06:30.560 --> 06:38.560
+en el mundo de la programación este valor
+en mi enumeración es el valor 0 mira aquí dice
+
+06:38.560 --> 06:45.840
+sunday igual a 0 es la posición 0 que
+tenemos en nuestro enum y sábado es la posición 5 pero
+
+06:45.840 --> 06:53.120
+nosotros como humanos no tenemos un día 0
+de la semana tenemos el día 1 y tenemos el día 6 de la
+
+06:53.120 --> 07:01.640
+semana sábanse lunes martes miércoles
+jueves viernes sábado domingo ok tenemos del día 1 al
+
+07:01.640 --> 07:08.360
+día 7 de la semana y en código nunca
+empieza desde el 1 en código siempre empezamos desde la posición
+
+07:08.360 --> 07:18.680
+0 así que sería posición 0 posición 1
+posición 2 posición 3 posición 4 y posición 5 y justo con
+
+07:18.680 --> 07:23.840
+esto de conteo que acabo de hacer de las
+posiciones me he dado cuenta que nos faltaba el jueves con
+
+07:23.840 --> 07:30.520
+razón aquí sólo había seis días de la
+semana muy bien tuesday justamente hoy es un día jueves de una
+
+07:30.520 --> 07:36.520
+fecha que no te voy a decir pero es
+curioso que se me haya pasado justo el jueves vamos a guardar
+
+07:36.520 --> 07:42.120
+control s ya actualizamos esto ahora sí
+todo está bien tenemos nuestros siete días sólo que va de
+
+07:42.120 --> 07:48.280
+la posición 0 a la posición 6 tal cual
+como debería ser y como es en el mundo real por eso
+
+07:48.280 --> 07:55.400
+nosotros a today le sumamos un número 1
+para que no empiece en 0 sino que empiece en 1 por ejemplo
+
+07:55.400 --> 08:05.760
+sonde vamos a guardar y vamos a correr
+nuestro código recuerda que lo corres con f6 si tienes
+
+08:05.760 --> 08:11.880
+la configuración igualita la mía y tenemos
+un error claro nos faltó un punto y coma acá muy bien
+
+08:11.880 --> 08:18.360
+y nos faltó un punto y coma acá típico de
+c es bueno que lo veas siempre siempre checa por los
+
+08:18.360 --> 08:27.800
+puntos y comas vamos a volver a ejecutar
+nuestro código ok déjame ir a la terminal y hacer no
+
+08:27.800 --> 08:36.120
+no me está dejando ok claro que no vamos a
+darle clear y vamos acá control s y vamos a volver a
+
+08:36.120 --> 08:44.280
+ejecutar nuestro código esperemos a ver y
+dice que todavía tenemos un error y mira que no sólo
+
+08:44.280 --> 08:49.600
+tenemos el problema de los puntos y comas
+lo que pasa aquí es que nos dice oye no sé de qué hablas
+
+08:49.600 --> 08:55.560
+cuál es el storage size de en un week
+today y aquí es medio deceiving si no tienes experiencia es
+
+08:55.560 --> 09:01.800
+medio confuso si no tienes experiencia
+porque porque today no es el problema el problema es
+
+09:01.800 --> 09:07.440
+que nosotros escribimos week en nuestro en
+un cuando en realidad se llama weekdays vamos a
+
+09:07.440 --> 09:13.160
+actualizar esto guardamos ejecutamos el
+código y esto que acabo de hacer yo esto que te acabo
+
+09:13.160 --> 09:20.440
+de mostrar se conoce como debugging mira
+que ya me dijo que el día sonday es el primer día de la
+
+09:20.440 --> 09:25.880
+semana hagamos un pequeño cambio sólo
+porque en realidad en nuestro sistema todo empieza en el
+
+09:25.880 --> 09:32.480
+lunes entonces vamos a poner un sonday y
+este proceso que hicimos que fue buscar los errores
+
+09:32.480 --> 09:39.880
+leer el output ver qué estaba ocurriendo
+se conoce como debugging es decir vamos a estar buscando en
+
+09:39.880 --> 09:45.320
+dónde están los errores en nuestro código
+es bien importante que siempre leas las líneas y veas qué
+
+09:45.320 --> 09:52.600
+está pasando aquí el set te lo indica pero
+siempre te va a indicar muchas veces un espacio más adelante
+
+09:52.600 --> 09:58.800
+de lo que está mal entonces en este caso
+nos decía hoy el today que pero en realidad el problema era
+
+09:58.800 --> 10:04.040
+porque week no estaba declarado bien era
+weekdays espero que te haya quedado súper claro veamos
+
+10:04.040 --> 10:09.160
+ahora qué pasa con sonde y sólo quiero que
+tengas súper claro el funcionamiento de todo esto vamos a
+
+10:09.160 --> 10:15.400
+correrlo otra vez vamos a nuestro terminal
+y listo tenemos que vamos del día 1 al día 7 ahora hagamos
+
+10:15.400 --> 10:23.320
+el ejemplo con lo que yo te decía de las
+cartas o no sé quizás enemigos en un videojuego lo que sea
+
+10:23.320 --> 10:31.240
+vamos a poder vamos a tener values en un
+proyecto real tendrías que usar nombres de variables mucho
+
+10:31.240 --> 10:37.840
+más nombres de tu genomes mucho más
+específicos de hecho le voy a poner el nombre deck de deck
+
+10:37.840 --> 10:44.240
+de cartas y le voy a poner mi y voy a
+declarar mis variables cuando estoy trabajando con cuando
+
+10:44.240 --> 10:50.400
+estás trabajando con variables siempre es
+mejor que dejes espacio acá que abras y cierres y entonces
+
+10:50.400 --> 11:00.160
+lo escribas vamos a decirle esta va a ser
+mi carta 0 coma luego vamos a tener diamantes este podría
+
+11:00.160 --> 11:09.720
+ser mi carta con un valor de 5 vamos a
+ponerle 5 coma además de diamantes si no me equivoco en los
+
+11:09.720 --> 11:17.840
+juegos de cartas hay corazones entonces
+corazones sería igual a 10 y date cuenta que cada carta va
+
+11:17.840 --> 11:26.880
+teniendo mucho mayor valor y la última
+carta que hay son espadas spades vamos a decirle que espadas
+
+11:26.880 --> 11:32.600
+sería un valor de 15 así sale una carta de
+espadas tienes 15 puntos y matas a los otros no el que
+
+11:32.600 --> 11:38.000
+tenga más puntos al final gana esa es la
+lógica detrás de este juego estamos declarando el deck
+
+11:38.000 --> 11:44.000
+y obviamente un deck va a tener cartas
+vamos a decirle vamos a pasarle el valor card
+
+11:46.800 --> 11:53.280
+y vamos a imprimir esto entonces todo lo
+que habíamos escrito ya nos sirve vamos a pasarle
+
+11:53.280 --> 11:59.640
+la relación de que nuestra carta viene de
+mí en un no nuestra carta que queremos seleccionar la
+
+11:59.640 --> 12:04.760
+primera yo quiero que sea spades aquí
+obviamente esto lo podrías hacer random más adelante con
+
+12:04.760 --> 12:09.640
+una función que aleatoriamente eligiera
+una de las cuatro posiciones dentro de tu en un
+
+12:10.640 --> 12:15.200
+vamos a ponerle eso todo listo y luego
+vamos a imprimir
+
+12:20.640 --> 12:26.880
+por ejemplo que podemos hacer con esto lo
+que te digo sacar aleatoriamente una carta podemos hacer
+
+12:26.880 --> 12:33.000
+muchas muchas cosas pero lo primero que
+quiero es que veamos qué pasa si simplemente utilizamos
+
+12:33.000 --> 12:42.320
+el código que ya tenemos cart ok vamos a
+darle safe y vamos a darle fn f6 en el caso de mi laptop
+
+12:42.320 --> 12:50.120
+en tu caso es solo f6 y mira dice de 15
+porque porque le escribimos de acá porque está esto
+
+12:50.120 --> 13:02.440
+está quemado en el código entonces cart
+value o cart power por ejemplo vamos a darle guardar
+
+13:02.440 --> 13:09.240
+y vamos a otra vez compilar el código y
+ejecutarlo vamos a ver qué sale y mira ya dice cart power
+
+13:09.240 --> 13:15.880
+igual a 15 tal como lo tenemos acá vamos a
+ver qué tanto pesa o cuál es el tamaño de mi variable
+
+13:15.880 --> 13:26.880
+vamos a escribir size of variable y la
+variable cuyo tamaño quiero es la carta pero vamos a
+
+13:26.880 --> 13:33.280
+utilizar una instrucción nueva que se
+llama size of esta es una función que va a sacarme el tamaño
+
+13:33.280 --> 13:40.680
+de la carta cerramos bien nuestros
+paréntesis vamos a guardar y al permitirnos guardar variables
+
+13:40.680 --> 13:46.520
+de tipo enteros simple y sencillamente ya
+sabes que tienes límites de la información que puedes
+
+13:46.520 --> 13:52.960
+guardar por defecto en un en un con esto
+dicho ya sabes para qué son los enums en lenguaje c la
+
+13:52.960 --> 13:58.160
+verdad es que este es un feature o una
+característica del lenguaje que yo personalmente ocupo muchísimo
+
+13:58.160 --> 14:02.760
+aquí te acabo de dar un par de ejemplos
+importantes espero que me cuentes en qué
+
+14:02.760 --> 14:23.760
+lo ocuparías tú y nos vemos en la próxima
+clase!
+
diff --git "a/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/03-Resumen.html" "b/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/03-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..14efaf52a53d95d47bd7419844ca0be635269d7d
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/03-Resumen.html"
@@ -0,0 +1,90 @@
+
+
+
+
+
+
+ Enums en C: Uso y Ejemplos Prácticos para Constantes
+
+
+
+
+
+
Resumen
¿Qué son los Enums en el lenguaje C?
+
Los "enums" o enumeraciones son una funcionalidad esencial en el lenguaje C que te permite crear un tipo de dato para representar valores constantes. Imagina que necesitas agrupar un conjunto de valores que no cambiarán pero que pertenecen a una misma categoría, como los días de la semana o los palos en un juego de cartas. Aquí es donde los enums juegan un papel crucial, al proporcionarte la flexibilidad de gestionar estos grupos de manera eficiente.
+
¿Cómo se declaran y utilizan los Enums?
+
Un enum se declara con la palabra clave enum, seguida del nombre y de una lista de sus elementos encerrada entre llaves. Aquí tienes un ejemplo práctico utilizando los días de la semana, una ocasión común para utilizar un enum:
+
#include<stdio.h>
+
+enumweekdays{ Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday };
+
+intmain(){
+enumweekdays today;
+ today = Wednesday;
+printf("Hoy es el dia número %d de la semana.\n", today +1);
+return0;
+}
+
+
En este código, los días de la semana tienen valores asignados comenzando por 0 (Sunday) y siguiendo el orden ascendente. Para imprimir los días, sumamos uno para que el conteo corresponda con el calendario habitual.
+
¿Cuándo debes usar variables dentro de un Enum?
+
Además de constantes, los enums pueden contener variables, lo cual es útil en casos como el balanceo de poderes en un juego. Supón que tienes un juego de cartas en donde quieres ajustar el poder de algunas cartas sin cambiar la lógica principal del juego. Aquí un ejemplo ilustrativo:
+
enumdeck{ Clubs =0, Diamonds =5, Hearts =10, Spades =15};
+
+intmain(){
+enumdeck card;
+ card = Spades;
+printf("El poder de la carta seleccionada es: %d\n", card);
+return0;
+}
+
+
Al definir estas cartas con distintos valores cuantitativos, puedes ajustar el poder de cada una simplemente cambiando los valores en el enum.
+
¿Qué aprender sobre el debugging y buenas prácticas?
+
Al programar, los errores son inevitables y encontrar su origen puede ser engañoso para los no iniciados. El proceso de debugging consiste en rastrear los errores, entender qué salió mal y corregirlo; como ver errores de sintaxis o inicialización. En el ejemplo del enum weekdays, corregimos la declaración equivocada de week por weekdays para resolver un problema.
Una buena práctica es usar nombres de variables descriptivas y revisar mensajes de error en el compilador, porque, aunque no siempre claros, suelen indicar la línea problemática.
+
Por último, es vital experimentar y ajustar el código. La práctica y la experiencia te irán proporcionando nuevas perspectivas y agilidad para solucionar problemas y optimizar los programas que desarrolles. ¡Mantente aprendiendo y verás cómo progresas en el dominio de los enums y del lenguaje C en general!
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/04-Resumen.html" "b/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/04-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..9d52c2c5561a1971d550b32d945ecd1ec5119831
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/04-Resumen.html"
@@ -0,0 +1,90 @@
+
+
+
+
+
+
+ Tipos de datos char y unsigned char en C
+
+
+
+
+
+
Resumen
¿Qué es el tipo de datos char en C?
+
El tipo de datos char en el lenguaje C es crucial para manejar caracteres en las aplicaciones y programas que desarrollamos. Aunque su principal propósito es almacenar caracteres, internamente opera con valores numéricos, específicamente dentro de un rango entero. Este tipo de dato se presenta en dos formas principales: char y unsigned char.
+
¿Cuál es el tamaño y rango de char?
+
+
+
char: Este tipo de datos ocupa exactamente un byte en memoria. Esto significa que puede almacenar un total de 256 valores diferentes. El rango de un char es de -128 a 127, abarcando tanto números negativos como positivos.
+
+
+
unsigned char: Al igual que char, ocupa un solo byte. Sin embargo, su rango es desde 0 hasta 255, solo incluyendo valores positivos. Esto permite un mayor alcance en el lado positivo comparado con char.
+
+
+
Por ejemplo, el siguiente código define una variable de tipo unsigned char y le asigna un valor dentro de su rango:
+
unsignedchar letra =65;// Almacena el valor 65, que es 'A' en la tabla ASCII
+
+
¿Para qué utilizamos el tipo char?
+
En resumen, char es ideal para almacenar caracteres individuales debido a su tamaño compacto de un byte. Al usar ASCII (American Standard Code for Information Interchange), números enteros (como el 65 en el ejemplo) pueden ser equivalentes a caracteres (la letra 'A'). Este pequeño truco es fundamental para manejar texto a nivel básico dentro de los programas en C.
+
¿Qué tipos derivados podemos esperar?
+
Más allá de los tipos de datos básicos, el lenguaje C también incluye tipos derivados o "derived data types". Estos son fundamentales para desarrollar estructuras de datos más complicadas y robustas en C:
+
+
+
Pointer types: Permiten manejar direcciones de memoria, facilitando la manipulación eficiente de estructuras de datos dinámicas.
+
+
+
Array types: Son colecciones de elementos del mismo tipo, proporcionando una manera eficiente de manejar grandes cantidades de datos.
+
+
+
Structs y union types: Estas estructuras permiten combinar diferentes tipos de datos bajo un único nombre, facilitando el manejo de datos complejos.
+
+
+
Function types: Permiten definir y manipular funciones como tipos de datos, lo que proporciona una flexibilidad notable en el diseño de software.
+
+
+
Estos tipos derivados amplían el potencial y uso del lenguaje C, permitiendo a los desarrolladores crear programas más sofisticados y eficientes. Sin embargo, serán discutidos más a fondo en futuras lecciones para asegurar una comprensión gradual pero sólida.
+
Como siempre, el aprendizaje de un lenguaje de programación es un viaje continuo. Así que sigue adelante, experimenta con estos tipos de datos, y verás cómo tu habilidad para programar en C se fortalece día tras día. ¡Nos vemos en la próxima clase!
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/04-Tipos de datos char y unsigned char en C.mp4" "b/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/04-Tipos de datos char y unsigned char en C.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..22750b1fc27161e7b5cb9cc90c3802b159bcbf7a
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/04-Tipos de datos char y unsigned char en C.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bed999f94d93776eac9817e4a5c28ac2534a7911190b51c6eb1803b666f0811b
+size 22061640
diff --git "a/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/04-Tipos de datos char y unsigned char en C.vtt" "b/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/04-Tipos de datos char y unsigned char en C.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..e17b42a933dca9fafe02d2f3a45a0b0e9d9de7e5
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/03-Tipos de Datos en el lenguaje C/04-Tipos de datos char y unsigned char en C.vtt"
@@ -0,0 +1,70 @@
+WEBVTT
+
+00:00.000 --> 00:10.060
+Hay otro tipo de dato que tenemos que
+discutir en el lenguaje C y es que existe el tipo de datos
+
+00:10.060 --> 00:18.120
+char que nos va a servir para almacenar
+idealmente caracteres pero que está internamente constituido
+
+00:18.120 --> 00:25.320
+por un rango de valores igual que
+cualquier rango de los números enteros. Veamos, vamos a escribirlo
+
+00:25.320 --> 00:36.280
+aquí este sería char y también vamos a
+tener un signet char o char de carácter vamos a tener que
+
+00:36.280 --> 00:45.040
+un char va a ser de un byte nada más y
+nada menos y un signet char va a ser igual de un byte. Ahora
+
+00:45.040 --> 00:54.000
+esto va a tener un rango de menos 128 a
+127 porque es un solo byte tenemos 256 valores que podemos
+
+00:54.000 --> 01:04.520
+almacenar y vamos a ir de 0 a 255 aquí
+están los mismos 256 valores toma que toma en cuenta que 0
+
+01:04.520 --> 01:12.840
+es el valor 1 y 255 sería el valor 256
+aquí simplemente estamos podemos guardar un total de
+
+01:12.840 --> 01:23.560
+256 datos o números diferentes del 0 al
+255 porque porque es de un solo byte y el char idealmente se
+
+01:23.560 --> 01:30.280
+va a utilizar en variables que nos van a
+servir para poder almacenar un carácter. Hasta ahorita
+
+01:30.280 --> 01:35.960
+con esto ya vimos todos los tipos de datos
+que existen en el lenguaje C hay unos más que se
+
+01:35.960 --> 01:43.000
+conocen tipos de datos derivados o derived
+data types o derived types que son derivaciones o que
+
+01:43.000 --> 01:49.400
+combinan ciertos tipos de datos esenciales
+para formar estructuras más complejas eso lo veremos
+
+01:49.400 --> 01:57.360
+mucho más adelante en el curso y son
+pointer types, array types, los strokes y los union types así como
+
+01:57.360 --> 02:02.480
+los function types todo eso lo veremos te
+digo más adelante en nuestros cursos de lenguaje C
+
+02:02.480 --> 02:07.880
+no te preocupes estos que ya sabes son los
+tipos de datos esenciales y en la próxima clase
+
+02:07.880 --> 02:19.880
+comenzaremos viendo justamente cómo
+utilizarlos para crear variables con esto dicho nos vemos en la próxima!
+
diff --git "a/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/01-Declaraci\303\263n y uso de variables en lenguaje C.mp4" "b/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/01-Declaraci\303\263n y uso de variables en lenguaje C.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..d17e2930f2e6d5ce0279905c09000b9eb5db3f23
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/01-Declaraci\303\263n y uso de variables en lenguaje C.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:755f2f56c29b4812fdb953d3a1204316812486d238d9ac1cd5292d6a6d154f92
+size 138588021
diff --git "a/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/01-Declaraci\303\263n y uso de variables en lenguaje C.vtt" "b/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/01-Declaraci\303\263n y uso de variables en lenguaje C.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..86a23b65029980af5cf0e425761716160727c1b9
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/01-Declaraci\303\263n y uso de variables en lenguaje C.vtt"
@@ -0,0 +1,478 @@
+WEBVTT
+
+00:00.000 --> 00:09.240
+Una variable en el lenguaje C, y en
+realidad en cualquier lado, no es nada más que la definición
+
+00:09.240 --> 00:15.320
+o el nombre que le vamos a dar a un
+espacio reservado de la memoria para poder almacenar
+
+00:15.320 --> 00:21.240
+información que nosotros tengamos en
+nuestro programa. Cada variable en C va a tener un
+
+00:21.240 --> 00:26.800
+tipo específico y esos tipos son los que
+vimos en clases anteriores, los tipos de datos de los
+
+00:26.800 --> 00:33.880
+que hablamos, y esto va a determinar el
+tamaño y la estructura que estamos reservando en la memoria.
+
+00:33.880 --> 00:40.680
+Entonces recuerda, tú sabes que yendo aquí
+a mi pantalla en una variable de tipo char,
+
+00:40.680 --> 00:47.320
+pues iba a poder tener la capacidad de
+reservar un byte de memoria, que son 8 bits, 8 espacios
+
+00:47.320 --> 00:54.400
+básicos de la memoria, y va a poder
+almacenar valores de menos 128 a 127, un unsigned int va
+
+00:54.400 --> 01:02.960
+a poder almacenar valores de 0 a 4.294
+millones, etcétera, y esto es el espacio que estamos
+
+01:02.960 --> 01:09.160
+reservando y a este espacio le tenemos que
+dar una etiqueta o un nombre definitivo, un nombre
+
+01:09.160 --> 01:15.160
+que vamos a manejar en todo nuestro programa.
+Vamos al código. Vamos a declarar una serie
+
+01:15.160 --> 01:19.440
+de variables simplemente para que vayas
+viendo cómo funciona la declaración y quiero enseñarte
+
+01:19.440 --> 01:25.960
+un par de cosas. Tú puedes declarar
+variables afuera de tu main y tenerlas todas ordenadas en
+
+01:25.960 --> 01:34.920
+un archivo bastante claro, por ejemplo
+podríamos declarar que vamos a tener nuestra variable int
+
+01:34.920 --> 01:42.440
+y esta variable int puede ser un número o
+un elemento auxiliar que suelen llamarse i, j y k
+
+01:42.440 --> 01:53.480
+en el lenguaje de programación C. También
+podemos tener valores enteros como minutos estacionados,
+
+01:54.920 --> 01:59.680
+por ejemplo asumiendo que estás haciendo
+una aplicación de estacionamiento en donde tienes
+
+01:59.680 --> 02:06.800
+que llevar tracking de cuántos minutos
+estacionado lleva un auto, por ejemplo, y aquí sabrías que
+
+02:06.800 --> 02:15.920
+este auto se podría estacionar hasta 2.
+147 millones de minutos negativos, pero en un
+
+02:15.920 --> 02:21.360
+estacionamiento un auto no debería tener
+minutos negativos, ¿o sí? Pues en realidad sí, es probable
+
+02:21.360 --> 02:26.800
+que un auto pague por adelantado minutos y
+entonces esos serían minutos negativos porque no se los
+
+02:26.800 --> 02:31.600
+tendrías que sumar a una cuenta de cobro.
+¿Ves? Eso es lo que tienes que pensar cuando estás programando
+
+02:31.600 --> 02:36.680
+en C, cuál es el tipo de datos que te va a
+servir más. Igual yo sí no creo que en un auto prepague
+
+02:36.680 --> 02:46.240
+2.147 millones de minutos, pero
+definitivamente puede llegar a prepagar más de 128 minutos,
+
+02:46.240 --> 02:54.640
+que son menos de tres horas, imagínate son
+dos horas que tendría prepagadas, muy
+
+02:54.640 --> 02:59.880
+chiquito. Esto sin duda no aplicaría para
+un estacionamiento, entonces nos podríamos ir con
+
+02:59.880 --> 03:07.800
+int sin ningún problema o podrías irte con
+short, quizás si los cálculos te dan. Ahora volvamos a
+
+03:07.800 --> 03:13.400
+los tipos de variables que vamos a tener,
+recuerda que las variables siempre en lenguaje C tienen
+
+03:13.400 --> 03:20.520
+que empezar con una letra o tienen que
+empezar con underscore, es lo que tiene que pasar
+
+03:20.520 --> 03:28.160
+por definición, si tú por ejemplo empiezas
+a declarar una variable con un símbolo entonces
+
+03:28.160 --> 03:35.120
+esto no lo reconoce y mira que mi editor
+no me lo marca de color azulito, esto sería un error.
+
+03:35.120 --> 03:41.560
+Ahora aquí quiero que veas que tú puedes
+declarar varias variables de un mismo tipo y simplemente
+
+03:41.560 --> 03:47.520
+separarlas por comas, también las
+variables pueden estar inicializadas en un valor o no,
+
+03:47.520 --> 03:54.520
+por ejemplo puedo inicializar mi variable
+en minutos estacionados asumiendo que un estacionamiento de
+
+03:54.520 --> 03:59.720
+coches te cobra 30 minutos de entrada,
+no importa que te quede solamente 10 que de hecho estos
+
+03:59.720 --> 04:04.560
+comportamientos si pasan en los
+estacionamientos tienen como una tarifa mínima, entonces puedes
+
+04:04.560 --> 04:15.800
+inicializar tu variable o crear variables
+tarifa minutos mínimos, esto en inglés sería
+
+04:15.800 --> 04:24.160
+minimum minutes. Este es otro ejemplo de
+cómo les puedes dar un uso a las variables, recuerda que
+
+04:24.160 --> 04:29.080
+este es el tipo int, podemos guardar
+números negativos simplemente los escribes si tuviéramos
+
+04:29.080 --> 04:37.760
+un sinet int entonces no estaría bien que
+guardaras números de tipo negativos simplemente no puede
+
+04:37.760 --> 04:44.600
+hacerlo. Muy bien ahora vamos a quitar
+esto porque se ve feo, van a decir que el profe no sabe y eso
+
+04:44.600 --> 04:50.800
+no es cierto, vamos a continuar ya tenemos
+un int, tenemos un sinet int, ¿qué más quisieras declarar?
+
+04:50.800 --> 04:57.480
+bueno nosotros podemos declarar variables
+de tipo char, imagínate que vas a tener un carácter no
+
+04:57.480 --> 05:05.280
+sé char y y esto va a ser igual a
+efectivamente el carácter y, estos son los tipos de cosas que
+
+05:05.280 --> 05:10.240
+se pueden hacer con la variable char o
+carácter, también tú con la variable char puedes declarar
+
+05:10.240 --> 05:19.640
+números, no pasa nada te permite hacerlo
+el lenguaje c, por ejemplo f horas horas worked hours,
+
+05:19.640 --> 05:31.560
+horas trabajadas, diarias, daily, worked
+hours, esta es una variable que como el día tiene 24 horas sin
+
+05:31.560 --> 05:38.000
+duda podemos hacerla de tipo carácter
+porque porque cabe en el rango numérico que nosotros vamos a
+
+05:38.000 --> 05:44.040
+tener entonces para un día tú puedes tener
+tus horas trabajadas, puedes tener horas trabajadas
+
+05:44.040 --> 05:50.920
+negativas no, así que lo ideal sería
+hacerlo de tipo un sinet char daily worked hours y esta variable
+
+05:50.920 --> 05:56.160
+pues puedes inicializarla en cero sin
+ningún problema o dejarla como está que también estaría
+
+05:56.160 --> 06:03.520
+con un valor de cero de entrada, en
+realidad o sea siempre siempre siempre tus variables van a estar
+
+06:03.520 --> 06:08.280
+en cero si no las inicializas y si tú las
+inicializas igual está correcto, me parece que es
+
+06:08.280 --> 06:14.280
+una muy buena práctica que dejes siempre
+tus variables inicializadas excepto cuando son variables
+
+06:14.280 --> 06:20.040
+de este tipo que son simples y sencillos
+auxiliares a menos que necesites que tu auxiliar que tu número
+
+06:20.040 --> 06:24.640
+auxiliar empiece en un valor dado, más
+adelante los vamos a aprender a usar en cuestiones como
+
+06:24.640 --> 06:30.120
+control de flujo y todo eso. Con esto ya
+viste cómo se declaran las variables todas funcionan
+
+06:30.120 --> 06:35.280
+con esta misma lógica ahora quiero hacer
+unos pequeños demos de cómo las podemos utilizar y
+
+06:35.280 --> 06:40.640
+manipular en un programa en C, vamos a
+darle archivo nuevo archivo vamos a copiar nuestra
+
+06:40.640 --> 06:46.520
+estructura básica, no el archivo no se va
+a llamar así vamos a guardarlo y le voy a poner de nombre
+
+06:46.520 --> 06:56.720
+variables, variables, variables, muy bien
+punto C, todo en orden vamos a ver qué pasa primero voy a
+
+06:56.720 --> 07:03.800
+borrar todo lo que tenía declarado no lo
+necesito para este ejemplo vamos a hacerlo luego voy a
+
+07:03.800 --> 07:08.520
+dejar el print siempre es bienvenido ese
+print lo vamos a necesitar y vamos a declarar nuestras
+
+07:08.520 --> 07:17.960
+variables aquí siempre es bueno que
+empieces con un comentario variable declarations para que si
+
+07:17.960 --> 07:22.920
+alguien más lee tu código sepa que todo lo
+que va a estar aquí son declaraciones de variables,
+
+07:22.920 --> 07:28.360
+este símbolo que estamos usando es
+diferente al otro de comentarios este comentario sólo
+
+07:28.360 --> 07:33.400
+aplica para la línea actual y nada más que
+la línea actual no no es como el anterior que te
+
+07:33.400 --> 07:39.480
+había enseñado que nos va a servir para
+todo y también quiero enseñarte algo más en C existe
+
+07:39.480 --> 07:45.440
+el comando extern que te va a permitir
+declarar variables cuando las vas a ocupar en diferentes
+
+07:45.440 --> 07:52.200
+archivos a lo largo de tu código esto no
+siempre lo necesitas a menos que estés trabajando en
+
+07:52.200 --> 07:59.400
+proyectos mucho mucho más grandes y que
+estás usando múltiples archivos de C, no para nada
+
+07:59.400 --> 08:03.920
+esto lo vamos a hacer en este primer curso
+recuerda que esta es la introducción pero si más adelante
+
+08:03.920 --> 08:09.680
+en la carrera sin duda lo veremos ocurrir
+pero de todos modos tienes que saberlo desde ya porque si
+
+08:09.680 --> 08:15.680
+por alguna razón te topas con algo que
+están utilizando la directiva extern entonces ya sabes
+
+08:15.680 --> 08:20.840
+a qué se refiere es para que el compilador
+sepa que esa variable es externa y que se va a estar
+
+08:20.840 --> 08:26.720
+usando a lo largo de todo tu proyecto
+entonces ya no necesitará más información cuando esté compilando
+
+08:26.720 --> 08:33.320
+es una buena práctica nosotros no estamos
+con varios archivos y entonces no vamos a hacerlo
+
+08:33.320 --> 08:38.360
+vamos a declarar todas nuestras variables
+la primera que voy a declarar va a ser una variable
+
+08:38.360 --> 08:47.360
+de tipo entero a y una variable de tipo
+entero b punto y coma también voy a declarar una variable
+
+08:47.360 --> 08:57.680
+que se hace vamos a declarar la k mi
+variable c muy bien punto y coma y vamos a hacer lo mismo
+
+08:57.680 --> 09:08.520
+para una variable de tipo float que van a
+ser la variable f g h muy bien todo en orden tenemos a
+
+09:08.520 --> 09:15.640
+b c f g h aquí tenemos tres variables
+enteras tres variables flotantes hagamos algo con estas variables
+
+09:15.640 --> 09:21.720
+para trabajar con estas variables lo que
+yo voy a hacer simplemente es escribir un par de sumas
+
+09:21.720 --> 09:27.400
+vamos a inicializar mis variables les voy
+a dar su primer valor les voy a decir que a va a ser
+
+09:27.400 --> 09:35.760
+igual a cuánto podemos ponerle unos para
+que sea una suma bastante simple para nosotros sin ningún
+
+09:35.760 --> 09:44.240
+problema y vamos a poner b que va a ser
+igual a 34 date cuenta todo lo que estamos haciendo acá
+
+09:44.240 --> 09:50.000
+estamos declarando nuestra variable y aquí
+estamos inicializando nuestra variable quiero que por
+
+09:50.000 --> 09:55.640
+favor te aprendas estos términos porque
+son esenciales en el lenguaje variable variable
+
+09:57.000 --> 10:05.800
+inicialización inicialización muy bien
+tenemos esto hagamos una pequeña suma vamos a sumar c
+
+10:05.800 --> 10:14.800
+esto va a ser igual a más b y vamos a
+poner un bello punto y coma al final porque estamos en el
+
+10:14.800 --> 10:24.680
+lenguaje c me gusta dejar espacio por
+buena práctica luego vamos a decirle que imprima el valor de la
+
+10:24.680 --> 10:33.360
+suma es y le vamos a pasar el elemento que
+nos va a dar el formato y ya quiero que te vayas dando
+
+10:33.360 --> 10:38.920
+cuenta que hace este esta instrucción de
+por ciento de lo que hace esta instrucción de por ciento de
+
+10:38.920 --> 10:45.560
+es que aquí justo en donde yo la estoy
+colocando va a escribir la variable que yo le pase cuál va
+
+10:45.560 --> 10:50.680
+a ser la variable que yo le voy a pasar la
+variable c ahorita te va a quedar todavía más claro con el
+
+10:50.680 --> 10:56.720
+ejemplo que tengo planeado vamos a
+imprimir esto vamos a guardar y vamos a ejecutar nuestro código
+
+10:56.720 --> 11:08.440
+y mira tenemos que ejecutó el código y la
+suma es 35 todo está excelente ahora qué pasaría si yo
+
+11:08.440 --> 11:15.000
+este por ciento de por ejemplo lo pongo en
+value off mira mira mira lo que va a pasar quiero que
+
+11:15.000 --> 11:24.800
+esto te ayude a entender para qué nos
+sirve el por ciento de vamos a ejecutarlo y mira dice
+
+11:24.800 --> 11:30.520
+value 35 de la suma es porque porque aquí
+está la variable que le estamos pasando a nuestro
+
+11:30.520 --> 11:36.440
+print pero aquí está el por ciento de en
+donde tú le pongas el tipo de dato de la variable es
+
+11:36.440 --> 11:41.800
+donde lo va a imprimir vamos a colocarlo
+bien otra vez por supuesto que no queremos que esto
+
+11:41.800 --> 11:48.600
+se rompa y mira vamos a nuestro archivo de
+hello world y cuánto es el máximo valor que podemos
+
+11:48.600 --> 11:54.040
+guardar en una variable de tipo entero
+este este es el máximo valor que podemos guardar vamos a
+
+11:54.040 --> 11:59.680
+nuestro archivo de variables y vamos a
+asignarle a ve el máximo valor que puede guardar y vamos a
+
+11:59.680 --> 12:08.800
+sumarle 1 vamos a sumarle 10 para ser
+exactos vamos a darle control s vamos a darle fn fc dice
+
+12:08.800 --> 12:15.120
+en mi caso fc dicen el tuyo si no estás en
+un laptop y vamos a ver qué pasa y mira se rompió
+
+12:15.120 --> 12:23.160
+estamos sumando dos números dos números
+positivos pero él me lo manda a los negativos porque por
+
+12:23.160 --> 12:29.560
+cómo funciona adentro en c la memoria lo
+que hicimos es que nos desbordamos los espacios que
+
+12:29.560 --> 12:35.440
+teníamos reservados para valores positivos
+y algo desbordarnos los espacios para valores positivos
+
+12:35.440 --> 12:41.760
+el número se fue a los valores para
+números negativos esto es algo maravilloso de c es algo
+
+12:41.760 --> 12:46.640
+que mucha gente dice que es el uno de los
+principales problemas de este lenguaje porque si
+
+12:46.640 --> 12:51.760
+se te van las manos si se te falla algo
+con el manejo de la memoria tu problema va a crashear
+
+12:51.760 --> 12:56.080
+si tu programa crashea puede que lo dejes
+vulnerable a ataques de seguridad puede que
+
+12:56.080 --> 13:01.280
+obviamente la experiencia de usuario no
+sea ideal pero por eso te estoy enseñando con mucho detalle
+
+13:01.280 --> 13:06.720
+a pensar en qué tipo de datos vas a usar
+cuando los vas a usar tienes que pensar en todo momento
+
+13:06.720 --> 13:11.080
+las declaraciones que estás haciendo en c
+y cuáles van a ser los valores máximos que estarías
+
+13:11.080 --> 13:17.560
+haciendo en tus operaciones nos vemos en
+la próxima clase donde profundizaremos más en las variables y
+
+13:17.560 --> 13:24.560
+su
+declaración
+
diff --git "a/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/01-Resumen.html" "b/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/01-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..d4846b99a6541757ace5b95a8a6d26ee1484cb4d
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/01-Resumen.html"
@@ -0,0 +1,93 @@
+
+
+
+
+
+
+ Declaración y uso de variables en lenguaje C
+
+
+
+
+
+
Resumen
¿Qué es una variable en C?
+
Una variable en el lenguaje C es fundamentalmente el nombre que se asigna a un espacio reservado de la memoria para almacenar información utilizada en un programa. Cada variable tiene un tipo específico que determina el tamaño y la estructura que se reserva en la memoria. Por ejemplo, una variable de tipo char puede contener un byte de memoria, mientras que un unsigned int puede almacenar valores de 0 a aproximadamente 4.294 millones. Entender esto es crucial para gestionar eficientemente la memoria y los recursos de tu aplicación en C.
+
¿Cómo se declaran variables en C?
+
Para comenzar a trabajar con variables en C, es importante saber cómo declararlas correctamente. Las variables pueden ser declaradas dentro o fuera de la función main(), aunque mantenerlas organizadas en un archivo claro es buena práctica.
+
int i, j, k;// Variables enteras
+
+
+
Las variables deben comenzar con una letra o con el carácter underscore (_).
+
No pueden comenzar con un símbolo, lo que sería error de sintaxis.
+
+
Puedes declarar múltiples variables del mismo tipo separándolas por comas:
+
int minutosEstacionados =0;// Ejemplo con inicialización
+
+
Asimismo, en C puedes inicializar tus variables en el momento de la declaración, una práctica recomendada para evitar valores basura.
+
¿Cuándo usar extern en las declaraciones de variables?
+
En proyectos más grandes, donde se utilizan múltiples archivos, es posible que debas declarar una variable como extern. Esta directiva indica que la variable es externa y será utilizada en otros archivos del proyecto. Su uso es limitado y no se discutirá en profundidad en este curso por ser una introducción, pero es vital conocer su existencia.
+
externint variableExterna;// Ejemplo de declaración `extern`
+
+
¿Cómo se manejan las operaciones básicas con variables?
+
Veamos cómo manejar operaciones básicas como la suma usando variables ya declaradas:
+
#include<stdio.h>
+
+intmain(){
+int a =1, b =34;
+int c = a + b;
+printf("La suma es: %d\n", c);// Uso del %d para imprimir variables de tipo int
+return0;
+}
+
+
El código anterior muestra cómo inicializar variables y realizar una operación de suma. También se ilustra el uso de %d en el printf para imprimir el valor de una variable int.
+
¿Qué sucede con el manejo de memoria y errores?
+
El lenguaje C ofrece un nivel bajo de control sobre la memoria del sistema, lo cual puede ser ventajoso, pero también es la fuente de varios problemas. Por ejemplo, si sumas valores que exceden la capacidad de la variable asignada, puedes obtener un comportamiento inesperado:
+
b =2147483647;// Máximo valor para un int
+c = a + b;
+
+
Este enfoque puede llevar a un desbordamiento del espacio reservado en memoria, haciendo que los valores positivos pasen al espectro de números negativos. Es crucial considerar el tipo de dato idóneo y los límites de rango en las operaciones para evitar crasheos y vulnerabilidades.
+
En resumen, la correcta declaración y uso de variables, junto con un manejo responsable de la memoria, son pilares fundamentales para una eficiente programación en C. Sigue adelante y profundiza en el aprendizaje sobre la declaración y el uso de variables para construir programas robustos y libres de errores.
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/02-Manejo de Variables Externas en C y Precisi\303\263n Num\303\251rica.mp4" "b/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/02-Manejo de Variables Externas en C y Precisi\303\263n Num\303\251rica.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..4ad47621bceba6a9c19111b3c8923f3c4e51dcd8
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/02-Manejo de Variables Externas en C y Precisi\303\263n Num\303\251rica.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a131229c2d983bdacd977c5df1e5eee2b66ca81e336874d80dbe7114687fdba5
+size 54419836
diff --git "a/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/02-Manejo de Variables Externas en C y Precisi\303\263n Num\303\251rica.vtt" "b/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/02-Manejo de Variables Externas en C y Precisi\303\263n Num\303\251rica.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..36924e2957422890ee534e72971fb8da38ad0ae5
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/02-Manejo de Variables Externas en C y Precisi\303\263n Num\303\251rica.vtt"
@@ -0,0 +1,178 @@
+WEBVTT
+
+00:00.000 --> 00:08.400
+Hay una última cosa que te quiero enseñar
+sobre la declaración de variables y es cómo vas a
+
+00:08.400 --> 00:13.680
+manejar variables cuando estés trabajando
+con diferentes archivos. Vamos a ello. Como ya te
+
+00:13.680 --> 00:21.440
+lo había indicado en la clase pasada,
+vamos a tener nuestras variables extern, extern, de externas,
+
+00:21.440 --> 00:27.640
+nada más, nada raro por ahí, pero al
+momento de utilizarlas dentro de nuestro código no va a ser
+
+00:27.640 --> 00:36.000
+tan simple como solamente inicializarlas y ya.
+Vamos a tener que hacer una definición nueva de
+
+00:36.000 --> 00:42.040
+nuestras variables para indicar que la
+vamos a estar utilizando adentro de nuestro código. Es
+
+00:42.040 --> 00:51.720
+decir, vamos a bajar esto por acá y vamos
+a crear un nuevo comentario que diga variable y esto sería
+
+00:51.720 --> 01:04.720
+definition. Voy a decirle que voy a tener
+mis variables int, a, b y c y ya con esto el programa
+
+01:04.720 --> 01:10.720
+sabrá que estamos trabajando con estas
+variables. Es decir, aquí estamos diciendo que van a ser
+
+01:10.720 --> 01:16.000
+externas y aquí ya estamos diciendo en
+esta parte del código las voy a utilizar, no se declara
+
+01:16.000 --> 01:22.520
+doble int, ahí se me fue un typo y ya.
+Una vez haces esto simplemente puedes guardar y puedes
+
+01:22.520 --> 01:28.240
+ejecutar tu código y vas a ver que va a
+funcionar a la perfección. Ahora obviamente no hace la suma
+
+01:28.240 --> 01:35.280
+bien porque lo hicimos a propósito,
+sumémosle 0 y veamos qué ocurre. Vamos a compilar y ejecutar
+
+01:35.280 --> 01:41.640
+otra vez nuestro programa y ya
+efectivamente estamos al máximo de la capacidad de nuestra
+
+01:41.640 --> 01:47.760
+variable. Pero ahora qué pasa si superamos
+el máximo negativo al que podemos llegar? Quiero
+
+01:47.760 --> 01:54.600
+que veas ese experimento, vamos a agarrar
+todo en negativo y vamos a sumarle menos 10, control s y
+
+01:54.600 --> 02:02.200
+vamos a ejecutar este código esperando a
+que termine y mira que nada, no pasa nada, simplemente
+
+02:02.200 --> 02:08.920
+llega al valor máximo y ya llega a un
+valor que no debería llegar, se fue a un número positivo cuando
+
+02:08.920 --> 02:15.400
+debería ser negativo y los comportamientos
+son erráticos. Ahora que ya viste estos ejemplos,
+
+02:15.400 --> 02:23.120
+hagamos ejemplos con números negativos.
+Para esto vamos a utilizar g, vamos a utilizar h y el
+
+02:23.120 --> 02:32.680
+resultado de la suma de g no es h, g y f y
+el resultado de la suma de g más f lo vamos a guardar
+
+02:32.680 --> 02:39.520
+en h. Obviamente hay que cambiarlo aquí en
+donde estábamos imprimiendo el resultado y también acá
+
+02:39.520 --> 02:44.040
+porque el porciento de es para imprimir un
+número decimal, para imprimir un número flotante
+
+02:44.040 --> 02:50.560
+necesitaremos porciento f. Vamos a ver qué
+pasa con estos valores simplemente, recuerda que esta
+
+02:50.560 --> 02:56.740
+variable es de mucho mayor espacio que la
+variable de tipo entero, vamos a ver qué pasa y mira aquí
+
+02:56.740 --> 03:02.560
+parece que si logra hacer la suma y nos
+agrega seis números decimales que es la precisión que vamos a
+
+03:02.560 --> 03:20.840
+tener. Ahora sumemos 1000 positivo punto
+999 con 1 punto 1111, estamos sumando dos números de
+
+03:20.840 --> 03:30.320
+cuatro decimales. Vamos a ver qué
+resultado nos da esto y ve todo está funcionando, simplemente
+
+03:30.320 --> 03:35.920
+tenemos nuestros cinco números decimales,
+nuestros cuatro números decimales pero ahora la suma utiliza
+
+03:35.920 --> 03:42.960
+los seis números decimales que podíamos tener,
+obviamente nos da todo muy preciso, veamos qué pasa
+
+03:42.960 --> 03:53.400
+si nosotros ahora quisiéramos sumar 999999
+en la parte decimal, o sea seis números decimales,
+
+03:53.400 --> 04:05.680
+vamos a 1 2 1 2 3 4 5 6 y borramos ese
+último 1, guardamos y ejecutamos el código,
+
+04:07.200 --> 04:12.880
+vamos a esperar a que la consola la
+terminal nos arroje un resultado, si te das cuenta la suma
+
+04:12.880 --> 04:19.400
+estuvo ok, simplemente se corta a los seis
+decimales, no le va a poner más precisión aunque
+
+04:19.400 --> 04:25.720
+nosotros hiciéramos sumas de más decimales,
+no estaríamos teniendo una afectación en cuestión
+
+04:25.720 --> 04:32.280
+de que el programa lance un error, pero sí
+que tendríamos una afectación en cuestión de que
+
+04:32.280 --> 04:39.200
+estaríamos perdiendo precisión de los datos,
+entiendes? el código no te va a decir que hay un
+
+04:39.200 --> 04:44.040
+error y es que esa es la parte tricky de C,
+C no te va a decir oye todo está mal porque declaraste
+
+04:44.040 --> 04:49.680
+estas variables y se desborda y estás
+perdiendo información, C es un lenguaje que se hizo en los
+
+04:49.680 --> 04:56.760
+70s y aunque es maravilloso no tiene ese
+nivel de un sistema o algo que se esté encargando de
+
+04:56.760 --> 05:03.440
+ayudarte a manejar las variables, no eres
+tú quien se debe de ayudar y por eso quería mostrarte estos
+
+05:03.440 --> 05:09.040
+ejemplos porque C no te marca ningún error
+pero sí que estás perdiendo precisión en los datos que
+
+05:09.040 --> 05:14.320
+estás manejando, debes tenerlo en cuenta,
+nos vemos en la próxima clase en donde te enseñaré cómo
+
+05:14.320 --> 05:39.360
+trabajar con valores
+constantes.
+
diff --git "a/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/02-Resumen.html" "b/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/02-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..6124139c28445562311865325ef3ce58c0873068
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/02-Resumen.html"
@@ -0,0 +1,100 @@
+
+
+
+
+
+
+ Manejo de Variables Externas en C y Precisión Numérica
+
+
+
+
+
+
Resumen
¿Cómo manejar variables externas en C?
+
Manejar variables en C cuando trabajas con varios archivos es un aspecto crucial de la programación en este lenguaje. Las variables externas, o extern, te permiten compartir variables entre diferentes archivos, lo que facilita la cooperación entre varios componentes de un programa. Veamos cómo puedes implementar esto de manera efectiva.
+
Declaración y definición de variables externas
+
Cuando declaramos una variable como extern, estamos indicando que la variable está definida en otra parte, posiblemente en otro archivo. No es suficiente con solo inicializarlas, sino que también debes definirlas.
+
// Ejemplo de declaración de variables externas
+externint a, b, c;
+
+// Definición de variables
+int a, b, c;
+
+
En el ejemplo anterior, primero indicamos que las variables a, b y c existen en otro lugar. Luego, definimos las variables en el archivo adecuado para poder utilizarlas en nuestro programa.
+
Beneficios y cuidados a tener con las variables externas
+
Las variables externas te ofrecen la ventaja de compartir datos entre archivos sin necesidad de volver a declarar o inicializar constantemente. Sin embargo, es importante recordar que estas variables deben ser manejadas con cuidado para evitar conflictos o errores complejos.
+
Usos y experimentos con límites de variables
+
Ahora que sabemos cómo declarar y definir variables, realicemos algunos experimentos con los límites de las mismas. ¿Qué ocurre cuando sumamos valores extremos o cuando superamos el rango permitido?
+
// Ejemplo de comportamiento al exceder el límite
+int valor = INT_MAX;
+valor +=1;// Excede el límite positivo
+
+
En este caso, es posible que el valor se desborde y produzca comportamientos inesperados. Algo similar ocurre si aplicas operaciones que llevan la variable al límite negativo.
+
¿Cómo trabajar con decimales en C?
+
Cuando trabajamos con números flotantes (decimales) en C, es fundamental entender cómo opera con la precisión de los decimales. Esto es crucial para cálculos que dependen de alta precisión.
+
Visibilidad de precisión decimal
+
Al imprimir decimales, utilizamos %f para representarlos. Por defecto, C nos da seis cifras decimales de precisión.
+
// Ejemplo de suma de decimales
+float g =1.1111, f =1000.999;
+float h = g + f;
+printf("%.6f", h);// Mostrará 1002.110100
+
+
Pérdida de precisión en cálculos
+
A pesar de recibir varias cifras decimales, tienes que ser consciente de que las operaciones pueden llevar a pérdida de precisión si las variables no se manejan adecuadamente. Esto es una limitación inherente del lenguaje.
+
float precisionReduce =0.111111;
+precisionReduce +=999999.999999;
+printf("%.6f", precisionReduce);// Redondeará a seis decimales
+
+
En este escenario, el lenguaje C podría no lanzar un error, pero se perderá precisión. Esto se debe al hecho de que el lenguaje C fue diseñado sin las facilidades de gestión mejoradas para variables.
+
Implicaciones y mejores prácticas en el uso de C
+
Aprender a trabajar con variables en C, tanto externas como internas, es fundamental para maximizar la eficiencia de tu código. Aquí te dejamos algunas mejores prácticas:
+
+
Siempre verifica los rangos de variables. Mantente atento a los posibles desbordamientos.
+
Asegúrate de separar la declaración de variables de la definición. Esto evita errores en tiempo de compilación.
+
Utiliza herramientas externas para monitorear la precisión de tus cálculos. Con extensiones o depuradores puedes evitar problemas potenciales.
+
+
Finalmente, es importante recordar que el lenguaje C, a pesar de sus limitaciones, sigue siendo una herramienta potente para los programadores. La clave está en entender sus peculiaridades y cómo manejarlas a nuestro favor. Sigue explorando, experimentando y aprendiendo, pues cada nueva aplicación es una oportunidad para profundizar tus conocimientos. ¡Nos vemos!
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/03-Uso de Constantes y Literales en C.mp4" "b/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/03-Uso de Constantes y Literales en C.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..3debe02d6833e37f4e4334d8d0bf0bbd03aa57eb
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/03-Uso de Constantes y Literales en C.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b5fe9a23ca722679e0a7a33abf92c5249940a85f04a224804f15b4d4bd712410
+size 70126107
diff --git "a/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/03-Uso de Constantes y Literales en C.vtt" "b/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/03-Uso de Constantes y Literales en C.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..aa6db63b7acedc686f791610c8db254bd40c8a7f
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/03-Uso de Constantes y Literales en C.vtt"
@@ -0,0 +1,246 @@
+WEBVTT
+
+00:00.000 --> 00:09.000
+En esta clase vamos a aprender todo sobre
+las constantes. Las constantes son valores que no
+
+00:09.000 --> 00:13.960
+van a cambiar en tu código, a diferencia
+de las variables, que son valores que asignas
+
+00:13.960 --> 00:19.320
+espacios en la memoria de la computadora
+en la que estás ejecutando tu código y ese espacio
+
+00:19.320 --> 00:23.640
+de memoria lo puedes llenar con la
+información que tú quieras. Puedes borrar esa información,
+
+00:23.640 --> 00:29.120
+puedes cambiar esa información y siempre
+vas a tener ese espacio de memoria reservado. Eso
+
+00:29.120 --> 00:34.520
+era una variable, la constante no va a
+estar cambiando, entonces se podría decir que sí,
+
+00:34.520 --> 00:40.400
+son valores fijos, también se conocen como
+literales y son valores que no van a cambiar,
+
+00:40.400 --> 00:46.320
+pero igual vas a tener que darles un tipo
+de dato porque esto es el lenguaje C y tienes que decirle
+
+00:46.320 --> 00:52.760
+que para esta constante reserve tanto
+espacio en memoria. Estas pueden ser cualquier tipo de
+
+00:52.760 --> 00:58.480
+dato de los que ya te enseñé, puede ser
+entero, puede ser flotante, puede ser character o puede
+
+00:58.480 --> 01:05.280
+ser un string literal, que es un dato
+nuevo que ahorita vamos a ver de qué se trata. Vamos a
+
+01:05.280 --> 01:13.040
+nuestro Visual Studio Code, archivo,
+archivo nuevo y vamos a guardar este archivo nuevo con
+
+01:13.040 --> 01:24.280
+control s como mi archivo de constantes.
+Bien ya tenemos Visual Studio listo, lo primero es que
+
+01:24.280 --> 01:30.440
+voy a empezar por contarte qué es un
+string literal. En clases anteriores has visto que
+
+01:30.440 --> 01:38.080
+nosotros utilizamos la siguiente expresión
+dentro de un elemento prim, por ejemplo es de humanos
+
+01:38.080 --> 01:48.080
+errar, algo bien poético, esto sería un
+string literal, lo que nosotros podemos colocar dentro
+
+01:48.080 --> 01:54.600
+de dos comillas dobles, estas que tenemos
+aquí dentro de C, van a ser mis string literals y esto
+
+01:54.600 --> 02:02.000
+internamente se lo está almacenando como
+un array o un arreglo, es decir una estructura de datos en
+
+02:02.000 --> 02:08.920
+donde se guarda carácter a carácter
+incluyendo los espacios en blanco y por último termina con
+
+02:08.920 --> 02:17.080
+un carácter con el comando null, un
+carácter null. Esto es un string literal en C, en C no tenemos
+
+02:17.080 --> 02:22.120
+el tipo de datos string que sí existen
+otros lenguajes de programación, te dejo este tip por
+
+02:22.120 --> 02:26.680
+si este no es tu primer lenguaje de
+programación que estás intentando aprender, pero si no, si este
+
+02:26.680 --> 02:30.960
+sí es tu primer lenguaje de programación
+no te preocupes, simplemente es que hay otros lenguajes
+
+02:30.960 --> 02:36.600
+que tienen el tipo de datos string para
+almacenar cadenas de caracteres, en C si tú quisieras
+
+02:36.600 --> 02:42.400
+trabajar con cadenas de caracteres lo que
+tendrías que hacer es un array y en ese array escribir char
+
+02:42.400 --> 02:48.000
+por char lo que tú quieres guardar, así
+que ese es un lenguaje viejito hay que creerlo con sus
+
+02:48.000 --> 02:54.320
+limitantes. Vamos a continuar entonces,
+con esto dicho nosotros vamos a poder declarar constantes
+
+02:54.320 --> 03:02.760
+de tipo int, de tipo float, de tipo char,
+pero también hay que ser muy realistas y para poder
+
+03:02.760 --> 03:09.080
+declarar las que sean constantes solamente
+hay que utilizar la palabra reservada const, entonces
+
+03:09.080 --> 03:14.480
+aquí tenemos una constante entera, vamos a
+poder también tener una constante flotante para guardar
+
+03:14.480 --> 03:21.080
+números con valores flotantes y la
+constante char que se puede usar para los mismos valores numéricos
+
+03:21.080 --> 03:30.880
+que yo ya te había enseñado previamente.
+Ahora, ¿qué podemos guardar en una variable
+
+03:30.880 --> 03:36.400
+en una constante del tipo entero? Bueno,
+podemos guardar números, por ejemplo podríamos declarar
+
+03:36.400 --> 03:48.000
+que esta variable, esta constante se llame
+costo hotdog, claramente ya tengo un poquito de hambre,
+
+03:48.000 --> 03:56.880
+costo hotdog, me salió ahí la dislexia y
+el costo de hotdog lo podemos dejar definido en 100,
+
+03:56.880 --> 04:03.800
+lo podemos dejar definido en un millón,
+lo podemos dejar definido en cualquier valor que
+
+04:03.800 --> 04:09.960
+quepa dentro de nuestro entero. También
+podemos guardar, como son constantes, podemos guardar
+
+04:09.960 --> 04:16.160
+combinaciones de números y letras, por
+ejemplo un código como 100a para indicar que esto es
+
+04:16.160 --> 04:22.520
+un elemento específico, eso se podría hacer.
+También podemos crear combinaciones y podemos
+
+04:22.520 --> 04:30.360
+decirle que sea 100u, la u es un sufijo
+que nos va a servir para decir que es un signet o para
+
+04:30.360 --> 04:36.320
+decir que sea long, podemos usar el sufijo
+L para indicar long y el sufijo u para indicar un signet
+
+04:36.320 --> 04:42.400
+respectivamente. Estos sufijos pueden ser
+en mayúscula o en minúscula y no hay problema,
+
+04:42.400 --> 04:47.640
+por eso date cuenta que nos los marca bien,
+pero si yo agrego 100w no, si yo agrego 100a no,
+
+04:47.640 --> 04:53.280
+si yo agrego 100q no. Espero que te haya
+quedado claro, estoy seguro que con esto ya te queda claro
+
+04:53.280 --> 05:03.520
+cómo funcionan los enteros. También
+podemos guardar ciertas palabras que empiecen, también
+
+05:03.520 --> 05:11.520
+podemos guardar palabras dentro de esto,
+por ejemplo guardar la palabra fill, guardar la palabra doc,
+
+05:11.520 --> 05:19.120
+podemos guardar letras y podemos guardar más.
+Recuerda que aquí estamos creando constantes
+
+05:19.120 --> 05:25.280
+enteras, entonces trata de trabajar con
+números directamente, podemos crear constantes flotantes
+
+05:25.280 --> 05:35.000
+como para decir cambio, una constante en
+donde damos el cambio de un precio o algo,
+
+05:35.000 --> 05:47.760
+cambio hay que ponerlo en inglés, esto
+sería cost, y aquí sería total bill para indicar que es la
+
+05:47.760 --> 05:59.120
+cuenta total. Ahora vamos a declararla y
+esta podría ser por ejemplo 100.57, 100.58, como está
+
+05:59.120 --> 06:07.120
+en float pues no se puede más de seis
+caracteres, pero también podríamos usar los tipos de datos
+
+06:07.120 --> 06:15.680
+flotantes que tengan más caracteres
+siempre y cuando nosotros lo indiquemos. Por último podemos
+
+06:15.680 --> 06:24.080
+declarar una constante de tipo carácter,
+aquí tú podrías llamarla por ejemplo newline, o podríamos
+
+06:24.080 --> 06:33.440
+sí, salto de línea, newline, el salto de
+línea es algo que se ocupa en el lenguaje C para poder
+
+06:33.440 --> 06:39.120
+definir que todo lo que escribamos a
+partir de cierto punto se vaya a una nueva línea en la
+
+06:39.120 --> 06:44.800
+pantalla o en la terminal y es diagonal
+invertida n, así que la podemos asignar a un char para que
+
+06:44.800 --> 06:51.160
+tenga un valor como newline, esto se puede
+hacer sin ningún problema aquí y funcionaría. En esta clase
+
+06:51.160 --> 06:56.760
+ya vimos cómo funcionan las constantes,
+quiero pasarte un par de tips en tus códigos, pero eso
+
+06:56.760 --> 07:04.720
+lo haremos en la próxima clase en donde
+aprendamos a usar el preprocesador de fine, que es excelente
+
+07:04.720 --> 07:17.360
+y es una gran herramienta para programar en C.
+Nos vemos allá.
+
diff --git "a/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/04-Resumen.html" "b/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/04-Resumen.html"
new file mode 100644
index 0000000000000000000000000000000000000000..6cb2af7af2693a3a50a6c9713beb0648c914e9db
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/04-Resumen.html"
@@ -0,0 +1,96 @@
+
+
+
+
+
+
+ Uso de "define" y "const" para constantes en C
+
+
+
+
+
+
Resumen
¿Cómo utilizar la directiva define en C?
+
El lenguaje C nos ofrece diversas herramientas para facilitarnos la programación, y una de ellas es la directiva de preprocesador define. Esta permite declarar constantes de una forma eficiente y práctica, especialmente útil cuando se trabaja con valores que no cambian durante la ejecución del programa.
+
¿Cuáles son las buenas prácticas al usar define?
+
+
Nombres en mayúsculas: Es una buena práctica escribir las constantes en mayúsculas para diferenciarlas de las variables comunes.
+
Definir al inicio del archivo: Colocar todas tus constantes definidas al inicio del archivo, así cualquier modificación se hace solo en un sitio.
+
+
Ejemplo de implementación de constantes
+
Vamos a ver un ejemplo práctico donde utilizamos constantes para representar el costo de una pizza, entre otras cosas:
define: Ideal para valores que son configurables y repetidos en distintos puntos del código, pero que no cambian durante la ejecución. Al definirlos al inicio, se centraliza el control de los mismos, evitando la necesidad de modificar cada uso individualmente.
+
+
+
const: Útil para definir constantes dentro de una función cuando el valor no necesita ser accesible de forma global, proporcionando así un orden y encapsulamiento más controlado en el código.
+
+
+
Beneficios de centralizar las definiciones con define
+
Usar define al inicio del código proporciona ventajas significativas:
+
+
Centralización y claridad: Al modificar un valor, solo necesitas cambiarlo una vez, y todo tu código se actualizará automáticamente.
+
Eficiencia: Evita búsquedas innecesarias para modificar valores múltiplemente definidos en el código.
+
Mantenimiento: Si un valor aparece muchas veces en el código, no tendrás que buscar y reemplazar cada instancia individualmente.
+
+
En resumen, la utilización de define y const en C no solo aumenta la eficiencia del programador, sino que también mejora la legibilidad y mantenibilidad del código. Recuerda siempre poner en práctica estas técnicas para lograr un desarrollo más organizado y efectivo. ¡Continúa con tu aprendizaje y conviértete en un mejor desarrollador C!
+
+
+
+
\ No newline at end of file
diff --git "a/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/04-Uso de define y const para constantes en C.mp4" "b/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/04-Uso de define y const para constantes en C.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..b311642d10dd437ee84a73bde17599e78a1b1675
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/04-Uso de define y const para constantes en C.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:86eeaa27c11139b4e7f3a7d002e16cbd49a846ac562d91ed1c557b906ae6fb76
+size 82138396
diff --git "a/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/04-Uso de define y const para constantes en C.vtt" "b/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/04-Uso de define y const para constantes en C.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..deddc5eb581189db58cb1c55e46ccb12282537a1
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/04-Variables en el lenguaje C/04-Uso de define y const para constantes en C.vtt"
@@ -0,0 +1,254 @@
+WEBVTT
+
+00:00.000 --> 00:09.920
+ahora te quiero enseñar a utilizar la
+directiva de preprocesador o el propio procesor define vamos
+
+00:09.920 --> 00:16.680
+a hacerlo y para esto voy a volver a mi
+hola mundo voy a volver a mi variables no constantes
+
+00:16.680 --> 00:22.320
+aquí estamos muy bien y quiero enseñarte
+que esta es otra forma de declarar simplemente tienes que
+
+00:22.320 --> 00:29.560
+poner define y vas a decir por ejemplo
+length es una muy buena práctica que las constantes se
+
+00:29.560 --> 00:39.040
+declaran en mayúsculas así que vamos a
+pasar todo a mayúsculas es lo correcto cost hot dog bill
+
+00:41.360 --> 00:49.520
+y new line esto es una buena práctica de
+se recuerda lo siempre vamos a poner un punto
+
+00:49.520 --> 00:55.120
+como acá no más porque sí y vamos a
+definir nuestras variables por ejemplo podemos tener el
+
+00:55.120 --> 01:00.600
+largo de un de una figura el largo de una
+autopista el largo de algo que queramos definir podemos
+
+01:00.600 --> 01:08.720
+tener el costo fijo por ejemplo paper cost
+el costo del papel y esto va a ser fijo y podemos
+
+01:08.720 --> 01:15.120
+darle un valor digamos tres dólares punto
+y coma date cuenta que acá no estamos utilizando el
+
+01:15.120 --> 01:20.440
+operador de asignación igual simplemente
+esta es la forma en la que se escriben y de hecho ni
+
+01:20.440 --> 01:25.560
+siquiera llevan punto y coma estos
+elementos y ahora quiero mostrarte cómo los utilizarías en
+
+01:25.560 --> 01:35.160
+un código real vamos a vamos a escribir
+nuestro nuestro tradicional include vamos a poner stdio
+
+01:38.080 --> 01:46.120
+stdio punto h vamos a cerrar muy bien y
+vamos a definir una serie de valores que puede ser por
+
+01:46.120 --> 02:00.800
+ejemplo define y quiero definir el costo
+de papel no pizza cost luego quiero definir acá int main
+
+02:00.800 --> 02:05.720
+vamos a escribir nuestro código principal
+con la lógica vamos a darle un costo por supuesto
+
+02:05.720 --> 02:13.280
+quiero que la pizza tenga un costo de 1.
+5 esto obviamente en dólares vamos a proceder vamos a
+
+02:13.280 --> 02:21.760
+decirle que ahora llaves int y aquí voy a
+hacer el cálculo no puede ser in tiene que ser float
+
+02:22.880 --> 02:31.560
+costo pizzas esta es mi variable flotante
+la estamos inicializando por acá y vamos a calcular
+
+02:31.560 --> 02:43.240
+que el costo de las pizzas sea igual a
+pizza cost que es mi constante multiplicado por el total
+
+02:45.640 --> 02:57.240
+total pizzas number of slices mejor number
+of slices aquí estamos haciendo nuestro super
+
+02:57.240 --> 03:03.120
+sistema de cobro para pizzas de momento
+voy a declarar mi variable número of slices flot
+
+03:05.120 --> 03:16.480
+number of slices y esta la vamos a
+inicializar en un valor de 1 para la operación simple y
+
+03:16.480 --> 03:22.640
+sencillamente punto y coma todo bien ya
+tenemos aquí la multiplicación se está guardando en mi
+
+03:22.640 --> 03:30.520
+variable con costo pizzas estamos
+comprando 3 ahora vamos a imprimir esto pero antes quiero
+
+03:30.520 --> 03:36.500
+demostrarte que podemos combinar las dos y
+también te voy a explicar cuándo usar cada una no te
+
+03:36.500 --> 03:45.200
+preocupes entonces new line va a ser igual
+a y habíamos declarado que para una línea nueva le
+
+03:45.200 --> 03:52.120
+íbamos a dar el valor de diagonal
+invertida n está así que debe llevar su punto y coma al final
+
+03:52.120 --> 03:58.360
+porque así es como se escribe vamos
+tenemos ya acá todo vamos a imprimir el resultado para esto vamos
+
+03:58.360 --> 04:05.920
+a ir a nuestro a nuestra función de la
+librería estándar input output print f vamos a decirle que
+
+04:05.920 --> 04:19.680
+por favor me imprima value total total
+bill o sea como tu recibo total tu costo total dos puntos
+
+04:19.680 --> 04:28.160
+y aquí le vamos a pasar el resultado que
+sería por ciento f de flotante vamos a cerrar muy bien
+
+04:28.160 --> 04:38.960
+coma y le pasamos mi variable costo costo
+pizzas excelente vamos a poner acá punto y coma y luego
+
+04:38.960 --> 04:46.080
+vamos a imprimir acá una nueva línea y
+ahorita vas a ver cómo se muestra esto en nuestra consola por
+
+04:46.080 --> 04:56.520
+ciento c porque es un carácter coma le
+pasamos nuestra constante excelente tenemos y un online
+
+04:56.520 --> 05:03.880
+tenemos todo constant new line si te das a
+cuenta si te das cuenta aquí no le declaré que fuera un
+
+05:03.880 --> 05:11.600
+carácter con car muy bien ahora sí vamos a
+guardar vamos a poner el punto y coma acá en donde me hace
+
+05:11.600 --> 05:20.000
+falta y vamos a ejecutar el código y ya
+simplemente total bill y después nos hace un salto de línea y
+
+05:20.000 --> 05:27.200
+nos manda a la finalización del programa
+si quieres ver más clara la parte de new line podemos hacerlo
+
+05:27.200 --> 05:34.560
+mira que mira que vamos a jugar con esto
+quiero que el bill total aparezca abajo entonces podemos
+
+05:34.560 --> 05:42.880
+hacerlo así tenemos todo listo obviamente
+hay que borrar esta última línea porque ya lo pusimos
+
+05:42.880 --> 05:47.600
+arriba hay que poner el orden bien date
+cuenta que primero está la variable c así que hay que
+
+05:47.600 --> 05:55.880
+hay que asignarlas hay quedarse las hace
+en ese orden y varía mis variables vamos a imprimir el
+
+05:55.880 --> 06:02.520
+resultado compilamos ejecutamos esperamos
+a que todo salga y ya date cuenta cómo dice total bill
+
+06:02.520 --> 06:09.160
+qué es lo que debe decir luego está el
+salto de línea y luego viene el total bill que yo quería
+
+06:09.160 --> 06:15.920
+mostrar con esto ya aprendiste dos formas
+de declarar valores constantes utilizando cons y
+
+06:15.920 --> 06:23.120
+utilizando define cuando deberías utilizar
+define define es genial para que lo tengas siempre todas
+
+06:23.120 --> 06:28.960
+tus definiciones de valores arriba por
+ejemplo piensa en un código en donde tienes que definir
+
+06:28.960 --> 06:34.480
+un valor por ejemplo el tiempo en el que
+se demora en cambiar un semáforo de color rojo a verde
+
+06:34.480 --> 06:42.440
+entonces esa constante se va a llamar
+cambio no y eso ese ese valor lo puedes usar en muchas partes
+
+06:42.440 --> 06:47.800
+de tu programa entonces si tú lo defines
+una sola vez y tienes todas tus definiciones en la parte de
+
+06:47.800 --> 06:54.040
+arriba del programa lo que va a pasar es
+que no tienes que ir a buscar una de una en una todas
+
+06:54.040 --> 06:59.440
+las líneas de código en donde se utilice
+esto en donde se utilice este valor para hacer operaciones
+
+06:59.440 --> 07:04.480
+porque porque tú lo tienes definido arriba
+entonces simplemente vas a tus defines haces todos los
+
+07:04.480 --> 07:10.160
+ajustes ahí y todo se actualiza en tu
+código sin necesidad de que no sé imagínate que lo tienes
+
+07:10.160 --> 07:15.600
+5.000 veces repetido en tu código esa
+línea cambiarlo manualmente sería imposible por eso
+
+07:15.600 --> 07:22.160
+es una muy buena práctica definir estos
+valores que van a ser configurables sí pero no van a ser
+
+07:22.160 --> 07:28.320
+cambiantes durante el tiempo de ejecución
+los vas a configurar tú como programador vas a probar y vas
+
+07:28.320 --> 07:33.760
+a ver cómo se comporta el programa y si se
+comporta mal los vas los cambias los modificas y vuelves a
+
+07:33.760 --> 07:38.640
+ver cómo se comporta el programa hasta que
+tengas tus definiciones finales para mandar tu programa
+
+07:38.640 --> 07:44.440
+a producción esto es genial que lo ocupes
+así y si tienes dentro de una función que utilizar una
+
+07:44.440 --> 07:49.840
+constante que no va a ser global para todo
+tu código entonces ahí sí puedes declararla rápidamente
+
+07:49.840 --> 07:55.520
+con const y no pasa absolutamente nada con
+esto dicho nos vemos en la próxima clase
+
diff --git "a/Curso de Introducci\303\263n a C/05-Conclusiones/01-Funciones B\303\241sicas del Lenguaje C.mp4" "b/Curso de Introducci\303\263n a C/05-Conclusiones/01-Funciones B\303\241sicas del Lenguaje C.mp4"
new file mode 100644
index 0000000000000000000000000000000000000000..a78111116ee635ea799a441258394daf435392c8
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/05-Conclusiones/01-Funciones B\303\241sicas del Lenguaje C.mp4"
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9c68ca5e3352057edb5e1243ef1f54b610607bfc7148af6c73bbe383cfe32070
+size 15417830
diff --git "a/Curso de Introducci\303\263n a C/05-Conclusiones/01-Funciones B\303\241sicas del Lenguaje C.vtt" "b/Curso de Introducci\303\263n a C/05-Conclusiones/01-Funciones B\303\241sicas del Lenguaje C.vtt"
new file mode 100644
index 0000000000000000000000000000000000000000..73ca8cfcc1d96cb231404eb67a4f531a7f03ca86
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/05-Conclusiones/01-Funciones B\303\241sicas del Lenguaje C.vtt"
@@ -0,0 +1,62 @@
+WEBVTT
+
+00:00.000 --> 00:09.480
+¡Ey! Logramos terminar nuestro curso de
+Introducción a C. Sin duda has aprendido muchísimo y si ya
+
+00:09.480 --> 00:14.520
+sabías esto entonces seguro que te sirvió
+para un repaso. Recuerda que te esperan muchos más
+
+00:14.520 --> 00:20.240
+cursos y que a propósito estamos haciendo
+estos cursos muy pequeños y muy autocontenidos. Aquí
+
+00:20.240 --> 00:25.760
+sólo vimos las funciones de verdad básicas
+del lenguaje y te preparé, velo como un precalentamiento
+
+00:25.760 --> 00:31.040
+para que estés listo o lista para el
+siguiente curso que es nuestro curso de programación en C.
+
+00:31.040 --> 00:36.320
+Por supuesto te dejo el enlace al mismo en
+la sección de enlaces aquí en la plataforma. Yo
+
+00:36.320 --> 00:41.440
+soy Ricardo Celis, fue un gusto haber sido
+tu profesor, espero que de verdad aproveches este
+
+00:41.440 --> 00:46.280
+lenguaje de programación que es súper
+poderoso, igual lo vas a poder descubrir más adelante en el
+
+00:46.280 --> 00:51.840
+resto de cursos. Haz tu examen, compárteme
+tu diploma en redes sociales, etiquétame, mi twitter
+
+00:51.840 --> 00:57.760
+es arroba CelisMx, todo junto y también
+puedes etiquetar a arroba Platzi para que todos sepamos
+
+00:57.760 --> 01:04.000
+que te gustó este curso. También cuéntame
+en los comentarios un review, un feedback más grande de
+
+01:04.000 --> 01:08.440
+qué es lo que más te gustó de este curso,
+qué es lo que hubieras mejorado y sobre todo déjame un
+
+01:08.440 --> 01:13.400
+review de 5 estrellas al finalizar tu examen,
+eso me ayuda muchísimo a seguir creando cursos,
+
+01:13.400 --> 01:18.440
+me motiva muchísimo y bueno nos vemos en
+el próximo, te estaré esperando. Recuerda,
+
+01:18.440 --> 01:22.800
+escríbeme en twitter, escríbeme en los
+comentarios y nos vemos en la próxima ocasión.
+
diff --git "a/Curso de Introducci\303\263n a C/05-Conclusiones/01-Lecturas recomendadas.txt" "b/Curso de Introducci\303\263n a C/05-Conclusiones/01-Lecturas recomendadas.txt"
new file mode 100644
index 0000000000000000000000000000000000000000..58f118bcbc992035a2e2a4b4d7ce76aeb3b637b9
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/05-Conclusiones/01-Lecturas recomendadas.txt"
@@ -0,0 +1 @@
+https://platzi.com/cursos/flujo-c-2020/
diff --git "a/Curso de Introducci\303\263n a C/presentation.mhtml" "b/Curso de Introducci\303\263n a C/presentation.mhtml"
new file mode 100644
index 0000000000000000000000000000000000000000..7d6bcef6e716f83cb9b6d02dc6140d909c15d6b0
--- /dev/null
+++ "b/Curso de Introducci\303\263n a C/presentation.mhtml"
@@ -0,0 +1,38355 @@
+From:
+Snapshot-Content-Location: https://platzi.com/cursos/lenguaje-c/
+Subject: =?utf-8?Q?Curso=20de=20Introducci=C3=B3n=20a=20C?=
+Date: Sat, 8 Nov 2025 15:16:21 -0500
+MIME-Version: 1.0
+Content-Type: multipart/related;
+ type="text/html";
+ boundary="----MultipartBoundary--798spy3DO6fvNxsHDDlPpUX9i1iH7EdpcBCQc5OyrS----"
+
+
+------MultipartBoundary--798spy3DO6fvNxsHDDlPpUX9i1iH7EdpcBCQc5OyrS----
+Content-Type: text/html
+Content-ID:
+Content-Transfer-Encoding: quoted-printable
+Content-Location: https://platzi.com/cursos/lenguaje-c/
+
+=
+Curso de Introducci=C3=B3n a C
Aprende los funda=
+mentos de C para desarrollar software. Descubre c=C3=B3mo funcionan los pro=
+gramas en C, declara variables, trabaja con tipos de datos y constantes. Id=
+eal para quienes inician en este potente lenguaje de programaci=C3=B3n.
Estuvo bueno el curso, amplio mi pano=
+rama sobre los lengaujes de programaci=C3=B3n y sobre todo me esta ayudando=
+ en la Universidad en Licenciatura en Inform=C3=A1tica UNAM :)
Ruben Higuita<=
+/h3>
@higrub89=C2=B7=
+
=
+excelnte profe.
Alarcon Ricardo Ezequiel
@Ez=
+eAlarcon=C2=B7
Excelent=
+e curso introductorio a c
Andrea Zavala
@anzguz_7=C2=B7
=
+
Es una introducci=C3=B3n demasiado gen=C3=A9ri=
+ca. Pr=C3=A1cticamente s=C3=B3lo conoces los tipos de datos. Ser=C3=ADa bue=
+no que explicara m=C3=A1s a detalle estructuras (struct, typedef, enum) m=
+=C3=A1s ampliamente para visualizar y comprender mejor.
![3D"Dereck"](3D"https://static.platzi.com/media/avatars/tomalabeck=)
![3D"Cur=](3D"https://static.platzi.com/=)
![3D"Curso](3D"https://static.platzi.com/media/achievements/badge-8-738d99=){kind=icon}
![](3D"https://static.platzi.com/media/ach=)
![3D"Markdo=](3D"https://i.imgur.com/Qi4Lqk4.png")
![3D"Markdo=](3D"https://i.imgur.com/i6NIq6X.png")
![3D"Markdo=](3D"https://i.imgur.com/Fwn4C8v.png")
![3D"Markdo=](3D"https://i.imgur.com/LDhoyP7.png")
![3D"VS](3D"https://i.imgur.com/x9zG2e1.png")
![3D"VS](3D"https://i.imgur.com/8OkX89a.png")
![3D"VS](3D"https://i.imgur.com/H0lSyY9.png")
![3D"Gino](3D"https://static.platzi.com/media/avatars/avatars/eng.viloria_05d6cc6=)
![3D"Wiki"](3D"https://i.imgur.com/ThClT5w.png")
<=
+/div>
+![3D"Primer=](3D"https://i.imgur.com/okNXIrQ.png")
![3D"Home"](3D"https://i.imgur.com/ZpMzvAQ.png")
<=
+/div>
+![3D"Proyec=](3D"https://i.imgur.com/ziwh8pd.png")
![3D"P=C3=](3D"https://i.imgur.com/NLfEusa.png")
![3D"P=C3=](3D"https://i.imgur.com/CzvxNGh.png")
![3D"Sideba=](3D"https://i.imgur.com/Jb7cjGp.png")
![3D"Custom=](3D"https://i.imgur.com/LY9plQM.png")
![3D"Custom=](3D"https://i.imgur.com/RYFNfUJ.png")
![3D"Mauricio](3D"https://static.platzi.com/media/avatars/avatars/hmau=)
![3D""](3D"https://static.platzi.com/media/user_upload/upload-0f4ebca3-ee93-40=)
![3D"https://static.platzi.com/media/flags=](3D"https://static.platzi.com/media/flags/CL.png")
![3D"Diego](3D"https://static.platzi.com/media/avatars/a=)
![3D"https://static.platzi.com/media/flags/CO.png"](+=3D"https://static.platzi.com/media/flags/CO.png")
![3D"Carlos](3D"https://static.platzi.com/media/avatars/charliet=)
![3D"Andrea](3D"https://static.platzi.com/static/website/v2/images/avatar=){kind=avatar}
![3D"https:=](3D"https://static.platzi.com/me=)
![3D"https://static.platzi.com/media/flags/CO.png"=](3D"https://static.platzi.com/media/flags/CO.png")
![3D"Oscar](3D"https://static.platzi.com/media/avatars/avatars/oscarmendez96_23b51=)
![](3D"https://static.=)
![3D"Richard](3D"https://static.platzi.com/static/webs=)
![3D"https://static.plat=](3D"https://static.platzi.com/media/flags/VE.=)
![3D"Albert](3D"https://static.platzi.com/static/website/v2/imag=)
![+=3D"https://static.platzi.com/media/flags/VE.png"](3D"https://static.pla=)
![3D"https://static.platzi.c=](3D"https://static.platzi.com/media/flags/CO.png"=)
![](3D"https://static.platzi.com/m=)
![3D"https://static.platzi.com/media/flags/=](3D"https://static.platzi.com/media/flags/UY.png")
![](3D"https://static.platzi.com/media/ava=)
![3D"Cesar](3D"https://static.platzi.com/media/avatars/avatars/ceg=)
=
+![3D"Ronaldo](3D"https://static.platzi.co=)
![3D"Joan](3D"https://static.platzi.com/media/avatars/ejairo45_f175ab9b-f9fa=)
![3D"Ailer](3D"https://static.platzi.com/static/website/v2/images/avatar_=){kind=avatar}
![3D"https:/=](3D"https://static.platzi.com/med=)
![3D"Curso](3D"https://static.platzi.com/media/achievements/badge-interm-word-1d8=){kind=icon}
![3D"Curso](3D"https://static.platzi.com/media/achievements/badge-=){kind=icon}
![3D"Curso](3D"https://static.platzi.com/media/achievements/badge-postgr=){kind=icon}
![3D"Curso](3D"https://static.platzi.com/media/achievements/pie=)
![3D"Cu=](3D"https://static.platzi.com/media/achievements/piezas-l=)
<=
+/figure>![3D"Curso](3D"https://static.platzi.com/media/achievements/piezas=)
![3D"Curso](3D"https://static.platzi.com/media/achievements/badge-8-738d990a-87e0-=){kind=icon}
![3D"Curso](3D"https://static.platzi.com/media/achievements/badge-fasta=){kind=icon}
![3D"Curso](3D"https://static.platzi.com/media/achievements/badge_curso_django=){kind=icon}
![3D"Curso](3D"https://static.platzi.com/media/achieveme=)
![3D"Curso](3D"https://static.platzi.com/media/achievements/piezas-=)
![3D"Curso](3D"https://static.platzi.com/media/achievements/badge-int=){kind=icon}
![3D"Curso](3D"https://static.platzi.com/media/achievements/=)
<=
+/figure>![3D"Curso](3D"https://static.p=)
![3D"Curso](3D"https://static.platzi.com/media/achievements/piezas-fundamentosd=)
![3D"Curso](3D"https://static.platzi=)
![3D"Curso](3D"https://static.platzi.com/media/achiev=)
![+=3D"Curso](3D"https://static.platzi.=)
![3D"Curso](3D"https://static.platzi.com/media/achievements/piezas-curs=)
![3D"Curso](3D"https://static.platzi.com/media/achievement=)
![3D"Curso](3D"https://static.platzi.com/media/achievements/piezas-fundament=)
![3D"Curso](3D"https://static.platzi.com/media/achievements/piezas-f=)
![3D"Curso](3D"https://static.platzi.com/medi=)
![3D"Cu=](3D"https://static.platzi.com/media/achievements/ba=)
![3D"Curso](3D"https://static.platzi.com/media/achievements/piezas-co=)
![3D"Curso](3D"https://static.pl=)
![](+=3D"https://static.platzi.com/media/achievements/piezas-curso-de-introducci=)
![3D"Curso](3D"https://static.platzi.com/media/achievements=)
![3D"Audiocurso](3D"https://static.platzi.com/media/achievements/m=)
![3D"Curso](3D"https://static.platzi.com/media/achievements/badge-te=){kind=icon}
![3D"Curso](3D"https://static.platzi.com/media/achievements/bad=)
![3D"Curso](3D"https://static.platzi.com/media/achie=)
![](3D"https://static.platzi.com/media/achievements/badge-creacion-de-fil=){kind=icon}
![3D"country](3D"https://static.platzi.com/cdn-cgi/image/width=3D1024,quality=)
![3D=](3D"https://static.platzi.com/cdn-cgi/=)
![3D"cou=](3D"https://static.platzi.com/cdn-cgi/imag=)
![](3D"https://static.platzi.com/media/diplomas/=)
![3D"Ricardo](3D"https://static.platzi.com/media/teacher=)
![+=3D"David](3D"https://static.platzi.com/s=)
![3D"https://static.platzi.com/media/flags/GB.png"](+=3D"https://static.platzi.com/media/flags/GB.png")
![3D"https://static.platzi.com/medi=](3D"https://static.platzi.com/media/flags/GT.png")
![3D"osman](3D"https://static.platzi.com/media/avatars/av=)
![3D"Jonathan](3D"https://static.platzi.com/media/avatars/jonathanhigueros_abebb=)
![3D"https://static.pla=](3D"https://static.platzi.com/media/flags/GT=)
![3D"Carlos](3D"https://static.platzi.com/media/avatars/avatars/unimaur=)
<=
+img alt=3D"https://static.platzi.com/media/flags/PE.png" loading=3D"lazy" w=
+idth=3D"20" height=3D"20" decoding=3D"async" data-nimg=3D"1" class=3D"Cours=
+eReviewItem_CourseReviewItem__User__Avatar__Flag__4udAL" src=3D"https://sta=
+tic.platzi.com/media/flags/PE.png" style=3D"color: transparent;">![3D"Yaehl](3D"https://static.platzi.com/static/website/v2/images/avatar_d=){kind=avatar}
![3D"Mariano](3D"https://static.platzi.com/media/avatars/avatars/mariano-monje_c2=)
![3D"https://static.platzi.com/media=](3D"https://static.platzi.com/media/flags/PE.png")
![3D"Erick](3D"https://static.platz=)
![3D"https://static.pl=](3D"https://static.platzi.com/media/flags/P=)
![3D"Anglorys](3D"https://static.platzi.com/media/avatars/avatars/an=)
![3D"Fernando](3D"https://static.platzi.com/media/a=)
![3D"https://static.platzi.com/media/flags/MX.png"=](3D"https://static.platzi.com/media/flags/MX.png")
![3D"https://static.platzi.com/media/fla=](3D"https://static.platzi.com/media/flags/AR.png")
![3D"Leonardo](3D"https://static.platzi.com/media/avatars/avatars/leosr17_7fc3ef=)
![3D"https://stati=](3D"https://static.platzi.com/media/fla=)
![3D"Jorge](3D"https://static.platzi.com/media/avatars/avatars/george28_61b29c1=)
![3D"Diego](3D"https://static.platzi.com/media/avatars/avatars/diegoaupinzonca_=)
![3D"Orlando](3D"https://static.platzi.com/media/avatars/avatars/orlandcald=)
<=
+img alt=3D"https://static.platzi.com/media/flags/MX.png" loading=3D"lazy" w=
+idth=3D"20" height=3D"20" decoding=3D"async" data-nimg=3D"1" class=3D"Cours=
+eReviewItem_CourseReviewItem__User__Avatar__Flag__4udAL" src=3D"https://sta=
+tic.platzi.com/media/flags/MX.png" style=3D"color: transparent;">![3D"Ruben](3D"https://static.platzi.com/media/avatars/higrub89_6b819c54-741e-=)
![3D"Andrea](3D"https://static.platzi.com=)
![3D"https://static.platzi.com/media/flags/MX.png"](+=3D"https://static.platzi.com/media/flags/MX.png")
![3D"Limhi](3D"https://static.platzi.com/media/avatars/avatars/las=)
<=
+img alt=3D"https://static.platzi.com/media/flags/MX.png" loading=3D"lazy" w=
+idth=3D"20" height=3D"20" decoding=3D"async" data-nimg=3D"1" class=3D"Cours=
+eReviewItem_CourseReviewItem__User__Avatar__Flag__4udAL" src=3D"https://sta=
+tic.platzi.com/media/flags/MX.png" style=3D"color: transparent;">![3D=](3D"https://static.platzi.com/media/avatars/davidlare=)
=
+![3D"Jose](3D"https://static.platzi.com/media/avatars/avatars/cast=)
![3D"Curso](3D"https://static.platzi.com/media/achievements/1252-e585c35b=)
![3D"Curso](3D"https://static.platzi.com/media/achievements/iot-telecomunicacio=)
![3D"Curso](3D"https://static.platzi.com/media/achievements/piezas-fu=)
![3D"Curso](3D"https://static.platzi.com/media/=)
![3D"Curso](3D"https://static.platzi.com/media/ac=)
![+=3D"Platzi](3D"https://static.platzi.com/media/achievements/piezas-space-p=)
=
+![3D"Curso](+=3D"https://static.platzi.com/media/achievements/badge-js-bases-eb6e2feb-e4=){kind=icon}
![3D"Curso](+=3D"https://static.platzi.com/media/achievements/badges-curso-c-basico-9e53=)
![3D"Curso](+=3D"https://static.platzi.com/media/achievements/badge-introduccion-c-ab190=){kind=icon}
![3D"Curso](3D"https://static.platzi.com/media/achievements/badges-curso-c-basico-=)
![](3D"https://static.platzi.com/media/avatars/ava=)
![3D"Erick](+=3D"https://static.platzi.com/media/avatars/avatars/werglay_3f41420d-03a8-4=)
![3D"Enzo](+=3D"https://static.platzi.com/media/avatars/avatars/83xu9dVXfpJZFgQn_dff064=)
![3D"Oscar](3D"https://static.platzi.com/media/avatars/avatars/ojaramillo_6115e032=)
![3D"Espi=](3D"https://static.platzi.com/media/avatars/avatars/cyberanh=)
![3D"country](3D"https://static.platzi.com/cdn-cgi/image/wid=)
![](3D"https://static.platzi.com/cd=)
![3D"country](+=3D"https://static.platzi.com/cdn-cgi/image/width=3D1024,quality=3D85,forma=)
![3D"country](3D"https://static.platzi.com/cdn-cgi/image/width=3D1024=)